Notice of Pre-AIA or AIA Status
The present application, filed on or after March 16, 2013, is being examined under the first inventor to file provisions of the AIA .
Information Disclosure Statement
The information disclosure statement (IDS) submitted on 05/09/2024 is in compliance with the provisions of 37 CFR 1.97. Accordingly, the information disclosure statement is being considered by the examiner.
Examiner’s Note (EN)
The prior art rejections below cite particular paragraphs, columns, and/or line numbers in the references for the convenience of the applicant. Although the specified citations are representative of the teachings in the art and are applied to the specific limitations within the individual claim, other passages and figures may apply as well. It is respectfully requested that, in preparing responses, the applicant fully consider the references in their entirety as potentially teaching all or part of the claimed invention, as well as the context of the passage as taught by the prior art.
Claim Rejections - 35 USC § 112
The following is a quotation of 35 U.S.C. 112(b):
(b) CONCLUSION. —The specification shall conclude with one or more claims particularly pointing out and distinctly claiming the subject matter which the inventor or a joint inventor regards as the invention.
The following is a quotation of 35 U.S.C. 112 (pre-AIA ), second paragraph:
The specification shall conclude with one or more claims particularly pointing out and distinctly claiming the subject matter which the applicant regards as his invention.
Claim 4 is rejected under 35 U.S.C. 112(d) or pre-AIA 35 U.S.C. 112, 4th paragraph, as being of improper dependent form for failing to further limit the subject matter of the claim upon which it depends, or for failing to include all the limitations of the claim upon which it depends. Applicant may cancel the claim(s), amend the claim(s) to place the claim(s) in proper dependent form, rewrite the claim(s) in independent form, or present a sufficient showing that the dependent claim(s) complies with the statutory requirements.
Claims 5-9 are dependent on claim 4 and are rejected for inheriting the deficiencies of claim 4.
Claim Rejections - 35 USC § 101
35 U.S.C. 101 reads as follows:
Whoever invents or discovers any new and useful process, machine, manufacture, or composition of matter, or any new and useful improvement thereof, may obtain a patent therefor, subject to the conditions and requirements of this title.
Claims 1 and 13-15 are rejected under 35 U.S.C. 101 because the claimed invention is directed to an abstract idea without significantly more.
Claim 1
Step 1: Statutory class – method.
Step 2A Prong One: Does the claim recite an abstract idea, law of nature or natural phenomenon?
Yes
“3) Mental processes – concepts performed in the human mind (including an observation, evaluation, judgment, opinion) (see MPEP § 2106.04(a)(2), subsection III).” MPEP § 2106.04(a).
The claims are directed to an abstract idea of data processing and analysis. The claim recites:
determining that the software module does not include profiling;
transforming the requested function into a profiling-enhanced function by wrapping the requested function with profiling;
The determining and transforming are limitations of mental processes of evaluation, judgement and organization. By way of example, one can mentally evaluate if the code includes modules/functions that perform profiling. Additionally, one can modify/write code that would transform the function into a profiling enhanced function by adding the profiling wrappers/functionality.
Step 2A Prong Two: Does the claim recite additional elements that integrate the judicial exception into a practical application?
No.
The additional elements are:
receiving a request from a client application to import a requested function during a backend session of a software platform, the request comprising an indication to enhance the requested function with profiling; and
responsive to the request:
importing a software module comprising the requested function with a software engine;
outputting the profiling-enhanced function.
The receiving and outputting are mere data collection and data output. MPEP 2106.05(g)
The importing is mere instructions to apply an exception on a generic computer.
MPEP 2106.05(f) provides the following considerations for determining whether a claim simply recites a judicial exception with the words “apply it” (or an equivalent), such as mere instructions to implement an abstract idea on a computer.
Step 2B: Does the claim recite additional elements that amount to significantly more than judicial exception?
No, as discussed with respect to Step 2A, the additional limitation are mere data gathering, data output, and instructions to apply an exception on a generic computer. See MPEP 2106.05(f). MPEP 2106.05(f) provides the following considerations for determining whether a claim simply recites a judicial exception with the words “apply it” (or an equivalent), such as mere instructions to implement an abstract idea on a computer.
Additionally, the limitations do not impose any meaningful limits on practicing the abstract idea and therefore the claim does not provide an inventive concept in Step 2B. Further, in regards to step 2B and as cited above in step 2A, MPEP 2106.05(g) “Obtaining information about transactions using the Internet to verify credit card transactions, CyberSource v. Retail Decisions, Inc., 654 F.3d 1366, 1375, 99 USPQ2d 1690, 1694 (Fed. Cir.2011)” is merely data gathering. The additional elements have been considered both individually and as an ordered combination in the significantly more consideration. This claim is ineligible.
Claim 13 recites wherein the requested function is a first requested function, and wherein the software module is a first software module, the method further comprising: receiving a request for a second requested function, the request for the second requested function comprising an indication to enhance the second requested function with profiling; and responsive to the request for the second requested function: importing a second software module comprising the second requested function; determining that the second requested function includes profiling; and outputting the second requested function, which is a mental process under Step 2A Prong One, while the receiving and outputting are mere data collection and data output, MPEP 2106.05(g) and the importing limitation is mere instructions to apply an exception on a generic computer under Step 2A Prong Two and 2B.
The additional abstract idea and identified elements whether considered individually or in a
combination with the parent claims further do not amount to significantly more than the judicial
exception because the elements merely apply the abstract idea to be implemented on a generic
computer and therefore the identified claim does not amount to significantly more. See MPEP
2106.05(f). Therefore, the claim is considered ineligible under 35 USC 101. Therefore, the claim is
considered ineligible under 35 USC 101.
Claim 14 recites wherein the indication to enhance the requested function with profiling comprises a configuration flag with an ON value, which is a mental process under Step 2A Prong One.
The additional abstract idea and identified elements whether considered individually or in a
combination with the parent claims further do not amount to significantly more than the judicial
exception because the elements merely apply the abstract idea to be implemented on a generic
computer and therefore the identified claim does not amount to significantly more. See MPEP
2106.05(f). Therefore, the claim is considered ineligible under 35 USC 101. Therefore, the claim is
considered ineligible under 35 USC 101.
Claim 15 recites a computing system configured to host a software platform, comprising: (statutory category – process)
At least one hardware processor, at least one memory coupled to the at least one hardware processor; one or more non-transitory computer readable media having stored therein computer-executable instructions that, when executed by the computing system, cause the computing system to perform, which is mere instructions to apply an exception on a generic computer under Step 2A Prong Two and 2B.
The remaining limitations are similar to claim 1 and are rejected under the same rationale. Therefore, the claim is considered ineligible under 35 USC 101.
Claim Rejections - 35 USC § 103
The following is a quotation of 35 U.S.C. 103 which forms the basis for all obviousness rejections set forth in this Office action:
A patent for a claimed invention may not be obtained, notwithstanding that the claimed invention is not identically disclosed as set forth in section 102, if the differences between the claimed invention and the prior art are such that the claimed invention as a whole would have been obvious before the effective filing date of the claimed invention to a person having ordinary skill in the art to which the claimed invention pertains. Patentability shall not be negated by the manner in which the invention was made.
Claims 1-11 and 13-20 are rejected under 35 U.S.C. 103 as being unpatentable over Avakian et al. (US20050039171A1)
Regarding Claim 1, Avakian teaches a computer-implemented method comprising: receiving a request from a client application to import a requested function during a backend session of a software platform, the request comprising an indication to enhance the requested function with profiling ([0046-0047] “A software component, e.g., a servlet, invoked on the application server 16 may require the services of another application server for performing business logic needed for servicing the request received from the user. In this exemplary embodiment, software components running on the application server 16 can communicate with other software components running on another application server 20. For example, in embodiments in which the application server 16 is a J2EE server, a servlet or a JPS running on the application server 16 can invoke an Enterprise Java Bean (EJB) software component hosted on the application server 20 for performing a desired business logic. For example, if the user is utilizing the web server for on-line shopping, the EJB may keep track of items in the user's shopping cart. Similar to the application server 16, the application server 20 also includes a monitoring agent 18 according to the teachings of the invention that can provide performance analysis of selected methods and/or functions associated with its software components. For example, the transaction monitoring agent 18 can determine the time spent by selected methods associated with these software components for processing a request.” [0054] “The application server can employ a class loader 30 that provides a class loader hook interface 32. The class loader hook 32 invokes the BIC tool 26 to determine whether any methods of the exemplary class C need to be instrumented. The BIC tool in turn determines whether any method(s) of class C is slated for bytecode modification by communicating with an interface 34, herein referred to as HookControl interface, that directs the bytecode modification process. More particularly, the HookControl interface 34 allows a user to identify selected classes or interfaces, and selected methods associated with these classes, for instrumentation.” EN: The class loader in Java loads classes requested by applications. Please see [0121])
responsive to the request: importing a software module comprising the requested function with a software engine ([0054] "The application server can employ a class loader 30 that provides a class loader hook interface 32. The class loader hook 32 invokes the BIC tool 26 to determine whether any methods of the exemplary class C need to be instrumented. The BIC tool in turn determines whether any method(s) of class C is slated for bytecode modification by communicating with an interface 34, herein referred to as HookControl interface, that directs the bytecode modification process. More particularly, the HookControl interface 34 allows a user to identify selected classes or interfaces, and selected methods associated with these classes, for instrumentation." Also [0121] and [0046-0047]).
determining that the software module does not include profiling ([0091] "At 648, the modified class is marked as having been modified, such as by setting a custom attribute. This custom attribute can be, for example, a name-value pair, such as “BIP” plus a version number of the instrumentation tool 38.Marking the class as having been modified can prevent the instrumentation tool 38 from subsequently instrumenting this class again, for example if it is inadvertently subsequently processed by the instrumentation tool a second time. In addition, the instrumentation tool 38 or another tool can be used to ascertain if the class has been modified and, if so, which methods were instrumented. While modifying this class, the instrumentation tool 38 added constants to the constants pool. At 650, the constants pool of the class is marked as being complete with its new size.")
transforming the requested function into a profiling-enhanced function by wrapping the requested function with profiling ([0053] "The BIC tool can receive a byte array containing a Java class and can return a modified version of the byte array containing one or more methods in that class in which selected instrumentation code is inserted, as discussed below. The inserted code is herein referred to as an instrumentation hook and represents a bridge between an instrumented method and the instrumentation code." [0056-0057] "The HookControl interface 34 can direct instrumentation of selected methods of software components, such as, servlets, JSP classes, EJB classes, and JDBC classes. For example, for JSP classes, the _jspService method can be identified for instrumentation. As another example, the service method or the doFilter, doGet, and doPost methods of servlet classes can be selected for instrumentation. For EJB classes, the HookControl interface 34 can direct, for example, instrumentation of the container-generated EJB object class, which wraps the user written EJB… With continued reference to FIG. 2, if the BIC tool 26 identifies, upon communication with the HookControl interface 34, one or more methods of class C for instrumentation, the BIC tool 26 operates on the bytecode representations of these methods, in a manner described below, to insert instrumentation code therein. In other words, for each s method that is slated for instrumentation, the BIC tool 26 generates a wrapper method that contains instrumentation code for determining the response time of that method. A class containing wrapper methods corresponding to selected methods of class C is herein designated as class C′." Also see [0059-0061] [0095] "To insert a hook into a method, the instrumentation tool 38 renames the original method to $BIP$<originalName> and creates a new “wrapper” method having the original method's name and attributes. Thus, if a program attempts to call the original method, control instead passes to the wrapper method. FIG. 7 is a listing of an exemplary wrapper method 700. In the example of FIG. 7, the original method's name was “buy”, and the renamed method “$BIP$buy” appears at 701." Also see the code in [0146])
outputting the profiling-enhanced function ([0053] "The BIC tool can receive a byte array containing a Java class and can return a modified version of the byte array containing one or more methods in that class in which selected instrumentation code is inserted, as discussed below. The inserted code is herein referred to as an instrumentation hook and represents a bridge between an instrumented method and the instrumentation code." and [0056, 0059-0063])
Avakian presents the wrapped code that provides the profiling enhanced functionality in [0059-0063, 0146, 0185-0188] as well as Fig. 7 and 24. Before the effective filing date of the invention, it would have been obvious to a person of ordinary skill in the art, that the wrapping includes calling the method as an arguments utilized in the monitoring / performance of the wrapped methods to produce the profiling function with expected results.
Regarding Claim 2, Avakian teaches the method of claim 1. Avakian further teaches wherein wrapping the requested function with profiling comprises executing a profiling function which receives the requested function as an argument and returns the profiling-enhanced function ([0059-0063] [0095] and [0053-0054] "The BIC (Bytecode Instrumentation Controller) tool can receive a byte array containing a Java class and can return a modified version of the byte array containing one or more methods in that class in which selected instrumentation code is inserted, as discussed below. The inserted code is herein referred to as an instrumentation hook and represents a bridge between an instrumented method and the instrumentation code … By way of example, FIG. 2 schematically illustrates modification of an exemplary class C, and more specifically modification of one or more methods of class C, of a Java application by the BIC tool 26 of the invention as the class is being loaded by a JVM 28 running on an application server," [0057] "In other words, for each s method that is slated for instrumentation, the BIC tool 26 generates a wrapper method that contains instrumentation code for determining the response time of that method. A class containing wrapper methods corresponding to selected methods of class C is herein designated as class C′."; see also [0185-0190 and figure 24)
Regarding Claim 3, Avakian teaches the method of claim 2. Avakian further teaches wherein the profiling function, when executed, generates the profiling-enhanced function by adding computer-executable instructions to the requested function for measuring performance data associated with the requested function ([0053] and [0056-0057, 0185-0190])
Regarding Claim 4, Avakian teaches the method of claim 3. Avakian further teaches wherein wrapping the requested function with profiling comprises executing the profiling function with the requested function as the argument ([0059-0064] [0095] [0053-0057] and [0185-0190])
Regarding Claim 5, Avakian teaches the method of claim 4. Avakian further teaches wherein the requested function is one of a plurality of entities included in the software module, and wherein, for each entity of the plurality of entities, executing the profiling function with the entity as the argument comprises adding, to the entity, computer-executable instructions for measuring performance data associated with the entity ([0194] “In some cases, a method of a COM object invoked to perform a selected business logic may invoke methods of other COM objects within a single thread of execution to request performance of selected tasks, e.g., obtaining data from a database. Hence, a hierarchical chain of dependency among a plurality of COM objects can be created in which each COM object is a parent and/or a child of another COM object. For example, with reference to FIG. 28, an exemplary COM object 2140, which is instrumented by a wrapper object 2140 a, can spawn a child COM object 2142, which is instrumented by a wrapper object 2142 a. The COM object 2142 in turn invokes, via its wrapper object 2142 a, another COM object 2144, which is also instrumented by a wrapper object 2144 a.” and [0053-0054, 0057, 0185-0190])
wherein the performance data associated with the entity comprises an execution time of the entity and/or a number of function calls associated with execution of the entity ([0133] "For example, with reference to FIG. 14, an exemplary application 42, which can be, for example, a client or a server application, can call an ARM interface 44 when a selected transaction, for example, a method within the application, starts and when that transaction stops. The ARM interface 44 keeps track of the time elapsed between the start and the end of the transaction. The ARM interface can further transmit this timing data to a management agent 46 for analysis and reporting.")
Regarding Claim 6, Avakian teaches the method of claim 5. Avakian further teaches wherein the plurality of entities comprises one or more functions and/or one or more classes ([0051] "As discussed above, a transaction monitoring system according to the teachings of the invention can include an instrumentation engine that can be utilized for instrumenting selected methods and/or functions associated with software components hosted, for example, on application servers employed in a multi-tier Web architecture. Java-based applications constitute one category of such software components whose selected methods can be instrumented by utilizing methods and systems, and more particularly transaction monitoring agents, provided by the invention, as discussed in more detail below." [0057] "In other words, for each s method that is slated for instrumentation, the BIC tool 26 generates a wrapper method that contains instrumentation code for determining the response time of that method. A class containing wrapper methods corresponding to selected methods of class C is herein designated as class C′." [0065] "In addition, each instrumented class can be bound to a different implementation of the execCallback interface 36, i.e. to a different plug-in instrument 27A-B." and [0194]).
Regarding Claim 7, Avakian teaches the method of claim 6. Avakian further teaches further comprising:
determining that the plurality of entities comprise a first class, the first class comprising a first method([0054] and [0071-0074] specifically, "The HookControl interface 34 between the BIP instrumentation tool 38 and the control object 29 enables the control object to control which classes and methods are instrumented. During execution of the BIP instrumentation tool 38, the tool loads an external control class and instantiates a control object 29 from this class")
wrapping the first class by executing the profiling function with the first class as the argument; ([0056])
wrapping the first method by executing the profiling function with the first method as the argument ([0095])
Regarding Claim 8, Avakian teaches the method of claim 7. Avakian further teaches further comprising:
determining that the first class is a subclass of a superclass ([0072] "For each class the instrumentation tool 38 finds in the class file 40, the instrumentation tool collects context information, such as information about all superclasses and superinterfaces of the found class. This may require reading additional class files. The instrumentation tool 38 sends this class context information to the hookClass method 33, which returns an indication of whether the class is to be instrumented.")
wrapping the superclass by executing the profiling function with the superclass as the argument ([0073] and [0074] "The “superclasses” parameter 406 is an array of names of classes that are superclasses of the found class. The “superinterfaces” parameter 408 is an array of names of interfaces that are superinterfaces of the found class. If the instrumentation tool 38 succeeds in collecting context information about all the superclasses and superinterfaces of the found class, superclasses[0] contains the name of the immediate superclass and superclasses[last] contains “java.lang.Object”. On the other hand, if the instrumentation tool 38 cannot ascertain all the superclass and superinterface information, the “superclasses” array contains one element, i.e. the immediate super class, and the “superinterfaces” array contains only direct interfaces." )
Regarding Claim 9, Avakian teaches the method of claim 8. Avakian further teaches wherein the superclass comprises a second method, the method further comprising:
wrapping the second method by executing the profiling function with the second method as the argument ([0054] ". The BIC tool in turn determines whether any method(s) of class C is slated for bytecode modification by communicating with an interface 34, herein referred to as HookControl interface, that directs the bytecode modification process. More particularly, the HookControl interface 34 allows a user to identify selected classes or interfaces, and selected methods associated with these classes, for instrumentation." [0060] "Similar to the BIC tool 26, the BIP tool 38 also communicates with the HookControl interface 34 to identify classes, and selected methods within those classes, for instrumentation." And [0073-0074])
Regarding Claim 10, Avakian teaches the method of claim 3. Avakian further teaches wherein the performance data comprises an execution time of the requested function ([0133] "For example, with reference to FIG. 14, an exemplary application 42, which can be, for example, a client or a server application, can call an ARM interface 44 when a selected transaction, for example, a method within the application, starts and when that transaction stops. The ARM interface 44 keeps track of the time elapsed between the start and the end of the transaction. The ARM interface can further transmit this timing data to a management agent 46 for analysis and reporting.")
Regarding Claim 11, Avakian teaches the method of claim 10. Avakian further teaches wherein the computer-executable instructions for measuring the performance data associated with the requested function comprise:
instructions to record an execution start time of the requested function ([0133] "For example, with reference to FIG. 14, an exemplary application 42, which can be, for example, a client or a server application, can call an ARM interface 44 when a selected transaction, for example, a method within the application, starts and when that transaction stops. The ARM interface 44 keeps track of the time elapsed between the start and the end of the transaction. The ARM interface can further transmit this timing data to a management agent 46 for analysis and reporting." [0144] "For example, immediately prior to starting an instrumented method or function in class C′, the ExecCallBack interface can communicate with the ARM agent 48 to invoke an ARM start) method that allows the ARM transaction object to save a start time marker (timestamp). Further, immediately after the transaction ends, an ARM stop ( ) method is invoked to save a stop time marker (timestamp). The start and step time markers can then be utilized to determine the response time of the instrumented method or function.")
instructions to record an execution end time of the requested function ([0133] "For example, with reference to FIG. 14, an exemplary application 42, which can be, for example, a client or a server application, can call an ARM interface 44 when a selected transaction, for example, a method within the application, starts and when that transaction stops. The ARM interface 44 keeps track of the time elapsed between the start and the end of the transaction. The ARM interface can further transmit this timing data to a management agent 46 for analysis and reporting." also [0144] and [0148])
instructions to determine the execution time associated with the requested function as a difference between the execution end time and the execution start time ([0133] "For example, with reference to FIG. 14, an exemplary application 42, which can be, for example, a client or a server application, can call an ARM interface 44 when a selected transaction, for example, a method within the application, starts and when that transaction stops. The ARM interface 44 keeps track of the time elapsed between the start and the end of the transaction. The ARM interface can further transmit this timing data to a management agent 46 for analysis and reporting." [0144] and [0148])
Regarding Claim 13, Avakian teaches the method of claim 1. Avakian further teaches wherein the requested function is a first requested function, and wherein the software module is a first software module, the method further comprising: receiving a request for a second requested function, the request for the second requested function comprising an indication to enhance the second requested function with profiling ([0046-0047] and [0044] “More particularly, the invention installs transaction monitoring agents on one or more of these servers to monitor performance, for example, time required for execution, of selected methods of a plurality of software components that participate in processing the transactions.”)
responsive to the request for the second requested function: importing a second software module comprising the second requested function ([0044] and [0046-0047])
determining that the second requested function includes profiling ([0091] "At 648, the modified class is marked as having been modified, such as by setting a custom attribute. This custom attribute can be, for example, a name-value pair, such as “BIP” plus a version number of the instrumentation tool 38.Marking the class as having been modified can prevent the instrumentation tool 38 from subsequently instrumenting this class again, for example if it is inadvertently subsequently processed by the instrumentation tool a second time. In addition, the instrumentation tool 38 or another tool can be used to ascertain if the class has been modified and, if so, which methods were instrumented. While modifying this class, the instrumentation tool 38 added constants to the constants pool. At 650, the constants pool of the class is marked as being complete with its new size.")
outputting the second requested function ([0053,0056])
Regarding Claim 14, Avakian teaches the method of claim 1. Avakian further teaches wherein the indication to enhance the requested function with profiling comprises a configuration flag with an ON value ([0063] " The control object 29 can identify the selected methods and kinds of information to the BIP instrumentation tool 38 via the HookControl interface 34. Alternatively, a pattern file 31 can be used to create the control object 29 that can select which methods are to be instrumented and kinds of information that is to be passed to the plug-in instrument 27A. The pattern file 31 can contain descriptors of classes and/or method that are to be included and/or excluded from instrumentation. The syntax of the pattern file can include, for example, regular expressions, wildcard characters or any other syntax that can be used to identify individual classes or methods or groups thereof, as is well known in the art.")
Regarding Claim 15, Avakian teaches a computing system configured to host a software platform, comprising: at least one hardware processor; at least one memory coupled to the at least one hardware processor; one or more non-transitory computer-readable media having stored therein computer-executable instructions that, when executed by the computing system, cause the computing system to perform: ([0044] “The present invention generally provides methods and systems for end-to-end monitoring of transactions that originate from a computer system, for example, from a user's desktop computer, and can invoke one or more software components in other computer systems, such as, web, application, and database servers. Such transactions typically return data back to the originating computer.”)
initiating a backend session with a client application; and during the backend session: receiving a request from the client application to import a requested function, the request comprising an indication to enhance the requested function with profiling ([0046-0047)
responsive to the request: determining that the requested function does not include profiling ([0091])
importing a software module comprising the requested function with a software engine ([0054] and [0121])
transforming the requested function into a profiling-enhanced function by wrapping the requested function with profiling ([0059-0061] and [0095])
outputting the profiling-enhanced function ([0053,0056])
Regarding Claim 16, Avakian teaches the method of claim 15. Avakian further teaches further comprising: a stored class definition of a profiler class comprising ([0121] "A Java virtual machine (VJM) includes a class loader, and an application server invokes this class loader to load one or more classes. Most application servers, such as the WebLogic Platform from BEA Systems, Inc. San Jose, Calif., include a class load hook, which can be used to execute a user-specified class before the JVM class loader loads a normal class. Depending on the application server, one might have to specify a name of the user-specified class and/or set a property when starting the application server to notify the application server to execute a user-specified class when loading normal classes. The application server might define an interface, and the user-specified class might implement this interface to communicate with the application server. Thus, the user-specified class can be provided with an opportunity to read and modify a class file as it is being given to the class loader. By this mechanism, the BIC instrumentation tool 26 can modify classes as they are being loaded.")
a first method for generating a profiling function([0057] "the BIC tool 26 operates on the bytecode representations of these methods, in a manner described below, to insert instrumentation code therein. In other words, for each s method that is slated for instrumentation, the BIC tool 26 generates a wrapper method that contains instrumentation code for determining the response time of that method. A class containing wrapper methods corresponding to selected methods of class C is herein designated as class C′." [0095] "To insert a hook into a method, the instrumentation tool 38 renames the original method to $BIP$<originalName> and creates a new “wrapper” method having the original method's name and attributes. Thus, if a program attempts to call the original method, control instead passes to the wrapper method. FIG. 7 is a listing of an exemplary wrapper method 700. In the example of FIG. 7, the original method's name was “buy”, and the renamed method “$BIP$buy” appears at 701.").
a second method for intercepting an import of the software module and executing the profiling function on the requested function to generate the profiling-enhanced function ([0054] " The application server can employ a class loader 30 that provides a class loader hook interface 32. The class loader hook 32 invokes the BIC tool 26 to determine whether any methods of the exemplary class C need to be instrumented." and [0121])
Executing the profiling function on the requested function to generate the profiling-enhanced function ([0057] and [0059])
Regarding Claim 17, Avakian teaches the method of claim 16. Avakian further teaches wherein the profiling function is executable to receive the requested function as an argument and generate the profiling-enhanced function by adding, to the requested function, computer-executable instructions for measuring an execution time associated with the requested function (0053-0054)
Regarding Claim 18, Avakian teaches the method of claim 17. Avakian further teaches wherein the software module comprises, in addition to the requested function, one or more other functions and/or one or more classes ([0085)
Regarding Claim 19, Avakian teaches the method of claim 18. Avakian further teaches wherein the software module further comprises a first class, wherein the first class comprises a first method ([0056-0057)
wherein the system further comprises computer-executable instructions for executing the profiling function on the first class and the first method after importing the software module ([0044-0045] “The present invention generally provides methods and systems for end-to-end monitoring of transactions that originate from a computer system, for example, from a user's desktop computer, and can invoke one or more software components in other computer systems, such as, web, application, and database servers. Such transactions typically return data back to the originating computer. For example, the end-to-end transaction can relate to a database query initiated by a web browser, and processed by a number of software components running on various servers providing a chain of communication between the web browser and the database. More particularly, the invention installs transaction monitoring agents on one or more of these servers to monitor performance, for example, time required for execution, of selected methods of a plurality of software components that participate in processing the transactions. FIG. 1 schematically depicts an exemplary distributed multi-tier Web application architecture 10 in which transaction monitoring agents according to the teachings of the invention are incorporated. The illustrated multi-tier architecture 10 employs a client 12 as an interface for receiving requests from a user. The client 12 can be, for example, a web browser, or alternatively a probe that periodically transmits requests to a web server 14 for testing operations of the system. Without any loss of generality, the client 12 is assumed to be a web browser in the following discussion. The web browser 12 can be running, for example, on a user's desktop, or alternatively, on a PDA or any other suitable platform. The web browser 12 transmits a user's request to a web server 14 that in turn can communicate with an application server 16 that hosts a number of software components, e.g., JSPs or servlets. The exemplary application server 16 also hosts a transaction monitoring agent 18 according to the teachings of the invention that can monitor performance of selected methods in software components invoked on the application server 16 in response to requests received from the web server 14, as discussed in more detail below. The term “transaction,” as used herein, refers generally to a method or a function within a software component.” )
Regarding Claim 20, Avakian teaches one or more non-transitory computer-readable media comprising computer-executable instructions that, when executed by a computing system, cause the computing system to perform operations comprising: ([0044])
receiving a request from a client application to import a requested function, the request comprising an indication to enhance the requested function with profiling ([0046-0047])
responsive to the request, instantiating a profiler class comprising: a first method for generating a profiling function, the profiling function being executable to receive the requested function as an argument and transform the requested function into a profiling-enhanced function by adding, to the requested function, computer-executable instructions for measuring an execution time associated with the requested function ([0095] and [0057])
a second method for executing the profiling function on the requested function ([0053,0056,0057])
executing the first method to generate the profiling function for the requested function ([0095] and [0057])
executing the second method to transform the requested function into the profiling-enhanced function ([0053,0056,0057])
outputting the profiling-enhanced function ([0053,0056,0057])
Claims 12 is rejected under 35 U.S.C. 103 as being unpatentable over Avakian et al. (US20050039171A1) in view of Python3.3 (27.4 The Python Profilers)
Regarding Claim 12, Avakian teaches the method of claim 10. Python3.3 further teaches wherein the performance data further comprises a number of function calls associated with the requested function (Pg 8, print_callers, "With profile, a number is shown in parentheses after each caller to show how many times this specific call was made" Also see the screenshot for the stats output by the profiling function on Pg. 1-2 which shows the number of calls for the function profiled).
PNG
media_image1.png
254
747
media_image1.png
Greyscale
Avakian and Python3.3 are analogous art because they are from the same field of endeavor in code execution profiling. Before the effective filing date of the invention, it would have been obvious to a person of ordinary skill in the art, to combine Avakian and Python3.3 to incorporate Python’s expanded profiling functionality and stats reporting including number of functions called per profiling session.
Conclusion
The prior art made of record and not relied upon is considered pertinent to applicant's disclosure.
Greifeneder et al. (US20130179868A1): discloses instrumentation techniques including inheritance and dependency iteration.
Stewart (US20100064279A1): discloses multiple versions of instrumented functions providing more flexibility for instrumentation.
Any inquiry concerning this communication or earlier communications from the examiner should be directed to AMIR DARWISH whose telephone number is (571)272-4779. The examiner can normally be reached 7:30-5:30 M-Thurs.
Examiner interviews are available via telephone, in-person, and video conferencing using a USPTO supplied web-based collaboration tool. To schedule an interview, applicant is encouraged to use the USPTO Automated Interview Request (AIR) at http://www.uspto.gov/interviewpractice.
If attempts to reach the examiner by telephone are unsuccessful, the examiner’s supervisor, Emerson Puente can be reached on 571-272-3652. The fax phone number for the organization where this application or proceeding is assigned is 571-273-8300.
Information regarding the status of published or unpublished applications may be obtained from Patent Center. Unpublished application information in Patent Center is available to registered users. To file and manage patent submissions in Patent Center, visit: https://patentcenter.uspto.gov. Visit https://www.uspto.gov/patents/apply/patent-center for more information about Patent Center and https://www.uspto.gov/patents/docx for information about filing in DOCX format. For additional questions, contact the Electronic Business Center (EBC) at 866-217-9197 (toll-free). If you would like assistance from a USPTO Customer Service Representative, call 800-786-9199 (IN USA OR CANADA) or 571-272-1000.
/A.E.D./Examiner, Art Unit 2187
/LEWIS A BULLOCK JR/Supervisory Patent Examiner, Art Unit 2199