DETAILED ACTION
Claims 1, 3, 5-15 and 17-22 are presented for examination.
Claims 1, 3, 5, 15, 17, and 20 have been amended.
Claims 2, 4, and 16 have been cancelled.
Claims 21-22 are new.
This office action is in response to the amendment submitted on 24-JUN-2026.
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 .
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.
Response to Arguments – 35 USC 103
Applicant’s arguments with respect to the 103 rejections have been considered, but are not persuasive.
The applicant argues the additional amended limitations distinguish over the current art. However, as shown in the 35 USC 103 rejection below, Avakian does in other embodiments teach the additional limitations as mapped below. Primarily the newly amended limitations discuss additional client side aspect for the instrumentation process. Avakian’s [0178-0191] discloses an embodiment that utilizes a client for additional instrumentation functionality as part of the overall instrumentation process.
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, 3, 5-11, 13-15 and 17-22 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]).
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])
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)
outputting the profiling-enhanced function to the client application ([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])
to the client application ([0178-0191] “In another aspect, the invention provides monitoring agents deployed on web and application servers for monitoring the response time of one or more methods invoked in a web transaction in a multi-tier web transaction processing environment in which COM objects are utilized for performing, for example, business logic required for servicing the transactions. As discussed in more detail below, such a transaction monitoring agent of the invention can intercept a request from a software component for creating a COM object. Upon interception of the request, the monitoring agent generates a COM object, herein referred to as a wrapper object, that can invoke methods of interest in the COM object whose creation was requested, herein also referred to as the wrapped object. The requesting software component, herein also referred to as a client, can be, for example, another COM object. The monitoring agent provides the client with a pointer that refers to the wrapper object, rather than the wrapped object, such that any request for invoking a method of the wrapped object would be implemented, in a manner described below, via the wrapper object. The wrapper object can further include instrumentation code that can cause an ARM agent, such as the one described above, to determine the response time of selected invoked methods of the wrapped object. With reference to FIGS. 21 and 23, the monitoring agent 2126, upon interception of a request for creation of the object 2118, generates a wrapper object 2132 corresponding to the object 2118. The wrapper object 2132 implements a universal interface 2134, common to all wrapper objects generated in accordance with the teachings of the invention, that includes a plurality of virtual functions, each of which refers to a set of instructions for implementing that function. In this example, the universal interface 2134 includes 1024 virtual functions, a size selected based on the observation that an interface of a COM object to be wrapped is unlikely to include more than 1024 entries… By way of example, a client may invoke the foo method associated with the Exmple interface of the object 2118. The request for the invocation of the foo method, namely, function number 7 in the Exmple interface associated with the COM object 2118, is directed to the wrapper object 2132 because, as discussed above, the client is provided with a pointer that points to the wrapper object 2132 rather than the original object 2118.Because the virtual function associated with the foo method is entry number 7 in the interface 2130 associated with the object 2118, the wrapper object invokes the virtual function corresponding to the entry number 7 in the universal interface 2134 that points to the code that invokes the PreCallI method and passes 7 as the method number thereto. The PreCallI method can determine the type and the size of each argument of method number 7, namely, the foo method, via the TypeInfo data structure of the wrapper object 2132. Hence, the PrecallI function can determine the number of bytes on the client's stack that correspond to the arguments of the foo method. The PreCallI can utilize this information to call the foo method by employing the pointer in the wrapper object to the original object to access the vtable and utilize the virtual function associated with entry number 7 in the interface of the original object to discover the code for the foo method. ” EN: The wrapper object includes the profiling function. It’s outputted to the client through the pointer to its address so that the client can call the profiling enhanced functions. [0179-0191] provide the actual implementation details on how the client can run the profiling enhanced functions.)
wherein the profiling-enhanced function comprises code executable by the client application to perform functionality associated with the requested function while measuring performance data associated with the requested function ([0178-0109] provides detailed implementation examples for example [0189] “By way of example, consider the invocation of the CoCreateInstance, supplied by Ole32.dll, by a COM program run by a client for generating a COM object. FIG. 25 schematically depicts that CoCreateInstance includes binary code 2136 that can be loaded into memory for execution. The system provides a hook, namely, a string designated AppInit_dll stored in the system registry, in the context of any COM program that employs user32.dll dynamic link library. This hook can be utilized by a monitoring agent of the invention for hooking the CoCreateInstance function as described below. For example, a monitoring agent of the invention can write the name of a dynamic link library, herein referred to as OvCom.dll, provided by the monitoring agent and stored in the required system directory, to the AppInit_DLL string. This causes the system to load OvCom.dll in the COM program utilizing the CoCreateInstance, as shown schematically in FIG. 25. The OvCom.dll executes prior to the execution of CoCreateInstance to patch the code 2136 associated with CoCreateInstance in the following manner”)
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 3, Avakian teaches the method of claim 1. 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 5, Avakian teaches the method of claim 3. 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: 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 to the client application ([0053,0056] for the client side: [0178-0191])
wherein the profiling-enhanced function comprises code executable by the client application to perform functionality associated with the requested function while measuring performance data associated with the requested function ([0178-0191])
wherein the system further comprises 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 ([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])
and 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 15. 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 to the client application ([0053,0056,0057] and for the client side [0178-0191])
wherein the profiling-enhanced function comprises code executable by the client application to perform functionality associated with the requested function while measuring performance data associated with the requested function ([0178-0191])
Regarding Claim 21, Avakian teaches the method of claim 1, wherein the profiling-enhanced function comprises a function call that requires import of another software module, and wherein the method further comprises, responsive to the import of the other software module, wrapping one or more entities exported by the other software module with profiling. ([0194-0195] “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.”)
Regarding Claim 22, Avakian teaches the method of claim 5, wherein the plurality of entities comprise entities exported by the software module, and wherein the method further comprises repeating a wrapping process for additional entities exported by the software module until all entities exported by the software module that do not already include profiling are wrapped with profiling ([0194-0197] “In some cases, an instrumented COM object may invoke another instrumented COM object executing in a different process either on the same platform or on a different platform. For example, with reference to FIG. 29, a COM object A executing on a platform 2146 can call another COM object executing on a separate platform 2148. The passing of a correlator between the object A and the object B can be accomplished by utilizing a hooking mechanism as described below. For example, an IChannelhook object can be generated on each of the platforms 2146 and 2148 to intercept an outgoing call 2150, an incoming call 2152, an outgoing return call 2154, and an incoming return call 2156. The IChannelhook object can include four methods, each of which performs tasks associated with one of these interceptions. For example, the IChannelhook object executing on the platform 2146 can register, for example, via CoRegisterChannelHook, to intercept the outgoing call 2150 from the object A to the object B. Upon interception of the outgoing call 2150, a correlator 2158 associated with the object A can be added to a data payload 2160 that is transmitted from the object A to the object B. The IChannelHook object executing on the platform 2148 will inspect the incoming payload at the incoming call interception point 2152, and will extract the correlator 2158, if present in the payload. The object B will utilize this correlator as its parent correlator, and it will further generate its own correlator. Upon completion of the transaction associated with the object B, the correlator associated with B will be popped from the stack, and data generated by the object B in response to the call from object A will be sent back to the object A. The IChannelhook object executing on the platform 2148 will intercept the return payload at the outgoing return call point 2154, and will add the original correlator 2158 to the return payload. In some alternative embodiments of the invention, the original correlator 2158 is not added to the return payload.” [0181-0187] “In some embodiments of the invention, all COM objects requested by a client are wrapped to generate corresponding wrapper objects. In some other embodiments of the invention, a pre-defined policy is utilized to wrap selected COM objects. Such a policy can be stored, for example, in the form of a table in the system's registry. In some embodiments, such policy tables can be indexed by interface ID's (IID), class ID's, or program ID's to identify, for example, COM interfaces for which wrapping is not required. For example, a COM object may not be wrapped if there is a risk that the corresponding wrapper object may cause the system to behave in an unstable fashion. In general, a proxy object, a COM object that belongs to an MTS (Microsoft transaction server) package, or a COM+ object are wrapped.” [0184] discusses the foo method of a instrumented COM object. Instant spec [0051] explains exported as: (e.g., functions, classes, or other entities exported by the module))
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.
Colton et al. (US-8639743-B1): discloses exporting and running instrumentation code physically on the client side.
PyTracer (https://github.com/yohanchatelain/pytracer): discloses advanced profiling including recursively profiling called methods and objects.
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.
Applicant's amendment necessitated the new ground(s) of rejection presented in this Office action. Accordingly, THIS ACTION IS MADE FINAL. See MPEP § 706.07(a). Applicant is reminded of the extension of time policy as set forth in 37 CFR 1.136(a).
A shortened statutory period for reply to this final action is set to expire THREE MONTHS from the mailing date of this action. In the event a first reply is filed within TWO MONTHS of the mailing date of this final action and the advisory action is not mailed until after the end of the THREE-MONTH shortened statutory period, then the shortened statutory period will expire on the date the advisory action is mailed, and any nonprovisional extension fee (37 CFR 1.17(a)) pursuant to 37 CFR 1.136(a) will be calculated from the mailing date of the advisory action. In no event, however, will the statutory period for reply expire later than SIX MONTHS from the mailing date of this final action.
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 2199
/LEWIS A BULLOCK JR/Supervisory Patent Examiner, Art Unit 2199
Prosecution Insights