WO2009122390A2 - Apparatus and method for tracking requests in a multi threaded multi tier computerized environment - Google Patents
Apparatus and method for tracking requests in a multi threaded multi tier computerized environment Download PDFInfo
- Publication number
- WO2009122390A2 WO2009122390A2 PCT/IL2008/000439 IL2008000439W WO2009122390A2 WO 2009122390 A2 WO2009122390 A2 WO 2009122390A2 IL 2008000439 W IL2008000439 W IL 2008000439W WO 2009122390 A2 WO2009122390 A2 WO 2009122390A2
- Authority
- WO
- WIPO (PCT)
- Prior art keywords
- tier
- request
- outgoing
- incoming
- requests
- Prior art date
Links
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/54—Interprogram communication
- G06F9/544—Buffers; Shared memory; Pipes
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/54—Interprogram communication
- G06F9/545—Interprogram communication where tasks reside in different layers, e.g. user- and kernel-space
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L67/00—Network arrangements or protocols for supporting network services or applications
- H04L67/01—Protocols
- H04L67/02—Protocols based on web technology, e.g. hypertext transfer protocol [HTTP]
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L67/00—Network arrangements or protocols for supporting network services or applications
- H04L67/01—Protocols
- H04L67/10—Protocols in which an application is distributed across nodes in the network
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L69/00—Network arrangements, protocols or services independent of the application payload and not provided for in the other groups of this subclass
- H04L69/22—Parsing or analysis of headers
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F2209/00—Indexing scheme relating to G06F9/00
- G06F2209/54—Indexing scheme relating to G06F9/54
- G06F2209/542—Intercept
Definitions
- the present invention relates to tracking transaction related data within a computerized device in general, and to tracking transaction related data in a multi- tier computerized environment, in particular.
- a complex, multi-tier computerized network environment makes it difficult to keep track of a single transaction as it spans across multiple tiers.
- a tier can be a software or hardware module that executes an application.
- An example for such multi-tier computerized environment can comprise a HTTP tier, such as a web portal, and servers, databases; packaged and homegrown applications.
- a transaction sent by a user preferably requires resources of several tiers, and in many cases generates several requests. Such requests are sent to tiers for retrieving or modifying data stored in such tiers. For example, retrieving data according to a query sent from a user, or updating data in case a user performs an action via the multi-tier computerize environment.
- One solution for tracking requests and responses of a single transaction is to add a tag to a parent request, the first request of a transaction, and maintain the same tag for other requests generated by the parent request.
- This solution requires a tagging module that is complex to implement, install and can be perceived as intrusive therefore raise concern with users and system administrators. More so, it may influence the entire tier or client machine in case of a malfunction. Further, the tag is added to the packet headers related to requests and responses and thus handles deeper layers of the operating system, network or communication protocol. In accordance with some known architectures, two or more threads may operate within a single tier.
- a listener-worker model in which one thread receives a request and delegates the request to another thread that executes it, generates additional requests or sends the request to another tier.
- Other architectures may comprise additional threads, for example, another thread that receives responses from other tiers and sends a response to the tier from which the request was sent.
- Figure IA shows three tiers as implemented as known in the art, Tierl (110), Tier2 (120) and Tier3 (130).
- a communication channel (not shown) connects Tierl (110) and Tier2 (120) and two communication channels (not shown) connect Tier2 (120) and Tier3 (130).
- US patent No. 7,051,339 provides for track and measurement of tasks related to a transaction by tagging each data related to transactions, such as requests and responses.
- the disadvantages of tagging are disclosed above.
- US patent No. 6,714,976 discloses tracking transactions in a client-server environment. For example, detecting data in the client side, and compare the detected data to data in the server side. The solution disclosed in US patent No. 6,714,976 might not be suitable for a multi-tier computerized environment.
- US patent publication number 2006/015512 discloses tracking data in a multi-tier computing environment by assigning two agents on each tier, one agent for detecting data related to requests and another agent communicates with agents of neighboring tiers and send the data fields detected by the first agent. This solution requires another communication channel for the transmission of data related to request and requires another module for each tier. Additionally, the solution requires two agents in each tier, for different purposes, one for detecting and the other for processing data and transmits it to agent of other tiers.
- the disclosed subject matter provides for methods and apparatus for associating requests and responses without using another module in the tiers besides the parsing modules or another detecting element.
- the subject matter also discloses a method for associating requests and responses in case more than one thread operates in the tiers.
- the method further comprises a step of determining resource consumption of a request. In some embodiments, the method further comprises a step of determining resource consumption of a transaction. In some embodiments, an agent residing within the tier performs detecting incoming and outgoing data flow. In some embodiments, an agent residing outside the tier performs associating incoming requests of one tier to outgoing requests of a neighboring tier.
- the at least one parsing unit resides within each tier.
- the processing module is connected to the at least one parsing units.
- the method further comprises a step of detecting data associated with outgoing child requests generated by the working thread executing the request and detecting incoming responses to the child requests.
- the association is performed using an ad-hoc ID contained within the outgoing response and a value contained within the sending tier that receives the outgoing response.
- the value is a serial number of an event performed after the step of establishing the communication channel.
- the value is a serial number of a countable event executed within the tier.
- the value is a function of a hash code or a CRC process.
- the method further comprises a step of associating between the incoming request and the outgoing request according to the detected data. In some embodiments, the method further comprises steps of detecting an incoming response, detecting the communication channel via which the incoming response was transmitted to the tier and detecting the thread that sent the incoming response. In some embodiments, the method further comprises a step of detecting an outgoing response and the thread ID of the thread that handled the outgoing response.
- Fig. IA shows a multi-tier computerized environment, according to some embodiments of the prior art
- Fig. IB shows a multi-tier computerized environment, according to some embodiments of the disclosed subject matter
- Figure 2 shows a computerized environment according to some exemplary embodiments of the subject matter
- Figures 3A and 3B show multi-threaded tiers within a multi-tier computerized environment, according to some exemplary embodiments of the disclosed subject matter.
- Figure 4 shows a flowchart of the method for associating requests within a multi-tier computerized environment, according to some exemplary embodiments of the subject matter.
- One technical problem addressed by the disclosed subject matter is to track requests associated with a transaction without modifying or adding data fields within the request.
- Another technical problem is to associate requests and responses within a multi-threaded tier.
- the technical solution disclosed in the subject matter comprises an apparatus and method for associating requests related to the same transaction and handled in a multi-tier computerized environment.
- a transaction is preferably a command or request for receiving or modifying data within a data field located in a computerized environment.
- a transaction may refer to receiving data associated with bank account details, or transferring money between accounts, purchase of stocks and the like.
- the apparatus comprises at least one parsing unit residing in at least a portion of the tiers in the multi-tier computerized environment or in communication with one or more tiers.
- at least one parsing unit may detect data flow related to more than one tier.
- Such at least one parsing unit detects incoming and outgoing data flow of one or more tiers.
- the at least one parsing unit is connected to a processing module that associates requests and responses related to the same transaction, based on data sent from the at least one parsing unit. Since each parsing unit is aware of partial information regarding requests and responses, the processing module associates the requests and responses according to predetermined algorithms and data fields.
- the data detected by the at least one parsing unit is sent to a central storage, connected to the processing module that uses the data within central storage to associate requests and responses. The association further results in determining resource consumption of transactions, and the time required for each request relate to the transaction.
- the disclosed subject matter also provides for associating incoming requests and outgoing requests of the same tier in a multi-threaded environment, in which more than one thread handle the request. Such method is disclosed in details below.
- Fig. IB shows a multi-tier computerized environment, according to some embodiments of the disclosed subject matter.
- Tierl (410) is an HTTP server that receives HTTP requests from a user or from another tier (not shown).
- Tier2 (420) is an application server that receives requests from Tierl (410) and sends responses to Tierl (410) after the request is processed.
- Tier3 (430) is a database server that receives requests from Tier2 (420) and sends responses to Tier2 (420) after the requests are processed.
- a multi-threaded tier comprises several threads, each performs a different task in handling the request.
- Tierl (110) comprises two threads, a listener thread 412 and a worker thread 414.
- Listener thread 412 receives a request from a neighboring tier and delegates the request to the worker thread 414 within the tier.
- Worker thread 414 handles the request received from listener thread 112 and may generate additional requests that may be sent to Tier2 (420).
- worker thread 114 also receives HOP responses from Tier2 (420) and may send the HTTP response back to Tierl (410) to the user (not shown).
- Worker thread 414 may execute the request in the tier, or generate additional requests associated with the incoming request. Such additional requests are also named child requests.
- Tier2 (420) comprises three threads, receives requests from Tierl (410) sends responses to Tierl (410), sends requests to Tier3 (430) and receives responses from Tier3 (430).
- the three threads are listener thread 422, worker thread 424 and worker thread 426.
- Listener thread 422 of Tier2 (420) receives the request from Tierl (410), sends the request within Tier2 (420) to worker thread 424 that handles the request, and preferably sends additional requests to Tier3 (430).
- Worker thread 424 may also generate SQL Request 2, receive response SQL Response 2, generate SQL Request3, receive SQL Response 3 and send the response HOP Respond312 to Tier 1(400).
- Worker thread 426 receives HOP request 246 from listener thread 422, generates SQL Request 1, receives SQL respond 1, and send response HOP Response246 to Tierl (410).
- the multi-thread architecture requires less operations from each thread and enables more requests to be handled at a given time period.
- the communication between Tierl (410) and Tier2 (420) is performed via a communication channel, while the communication between Tier2 (420) and Tier3 (430) is performed via two communication channels (not shown).
- SQL Request2 is sent from Tier2 (420) to Tier3 (430) via communication channel 2
- the technical problem is to determine the parent request of a request in a multi-threaded environment without tagging requests and without interfering in the kernel level, especially when the communication protocols implement asynchronous responses.
- the communication channel may be any computerized entity in which one side is enabled to write data and other side is enabled to read data.
- Such computerized entity may be a TCP/IP socket, a pipe, shared memory, a file, a queue, a messaging queue and the like.
- the method comprises a step of detecting data sent to and from each of the tiers.
- Each detected request or response is stored, partially or in its entirety in storage associated with a tier or associated with a communication channel.
- each detected request or response is assigned one or more values or parameters by the at least one parsing unit.
- the value may be a time stamp related to the time a request or response was sent or received, a serial number or index related to the number of requests or responses sent after a specific event, such as a protocol handshake, a communication channel ID or thread ID that handled or generated the request or response and the like.
- the value or index of the request or response is stored in the storage.
- the storage may reside within the tier, or can be connected to the at least one parsing unit.
- Another parameter that may be stored by the storage is an ad-hoc ID of each request.
- ad-hoc ID is generated by the thread handling the request, preferably when using asynchronous protocols, and is stored in the response to each request.
- Such ad-hoc ID is not generated by the application disclosed in the subject matter, and is not implemented the same way as the tagging method disclosed in the prior art. According to the disclosed subject matter, the ad-hoc ID is not provided in the context of previous requests or responses, but only in the context of the handled request or response, and is stored in the storage and used for further associating requests and child requests.
- both storages of Tierl (410) and Tier2 (420) detect the ad-hoc ID of the request.
- an agent residing in the tier may determine or assign the ad-hoc ID to the request or response.
- a response is sent from tier2 (420) to Tierl (410)
- it is logged in both storages of Tierl (410) and Tier2 (420).
- the time elapsed between the request was sent from Tierl (410) and the associated response was sent from tier2 (420) can be determined as a function of the time measured by both Tierl (410) and Tier2 (420).
- the data stored in the storages of Tierl (410) and Tier2 (420) is sent to a central storage where the requests are associated by the ad-hoc ID, the tiers' ID, timestamps, communication channels ID and the like.
- the requests are associated by the ad-hoc ID, the tiers' ID, timestamps, communication channels ID and the like.
- Resource consumption of requests can be measured from the initiation of a request, until the specific tier receives a response or sends back a response.
- the measurement of resource consumption may be achieved by inquiring the operating system using common APIs detecting the thread's current resource consumption profile, such as for example CPU consumption during a time period, number of bytes read/written to I/O devices, consumption of RAM memory, how much bytes were read/written to the network and the like.
- Another parameters logged in the storages that facilitates determining resource consumption is the timestamp of which a request is sent and the response is received, which allows measuring the time spent in each tier and between tiers in the communication channel.
- the accuracy of time detected in more than one tier is limited to the differences between the clocks in the more than one tier.
- the methods further comprise a step of synchronizing the clocks of the more than one tier.
- Figure 2 shows a computerized environment according to some exemplary embodiments of the subject matter.
- the computerized environment comprises three tiers, 220, 240 and 260.
- tier 220 when a transaction is sent to the computerized environment, it is received at tier 220.
- the request is logged by parser 222 with parameters associated with the request.
- parameters may be the time the request was sent or received, ad-hoc ID of the request, a hash-code value of the request characters, a hash-code value of the request parameters or combination, a result of a CRC function applied over the request characters or the request parameters or combination.
- Other parameters may be parts of the protocol which can be associated with a single request instance, a communication channel ID from which a request or response was received at a tier, a counter ID indicating the number of previous requests received or sent by tier 220, IP: port of the source or destination of the request, whether the request is incoming or outgoing and the like.
- parser 222 When a response is received at tier 220 or sent from the tier 220, similar parameters are detected by parser 222 and stored in storage 225. In a preferred embodiment of the disclosed subject matter, data fields within the requests are not modified when requests are transmitted between tiers. Additionally, no data fields are added to the request, as performed when using a tagging module. Parsers 222, 242 and 262 may reside in the user's space, and may reside in the kernel space, according to the preferences and specifications of the tiers and the computerized environment.
- Parser 222 may perform several parsing methods, either complicated parsing methods or shallow parsing.
- Suggested parsing methods may be Top-down parsing, such as recursive descent parser, LL parser, packrat parser, or bottom-up parsing methods such as precedence parser, BC (bounded context) parsing or LR parser and the like.
- Storages 225, 245 and 265 may be any kind of memory, such as RAM, ROM, flash, magnetic memory, and the like. Storages 225, 245 and 265 may reside within the tiers, or communicate with the tiers.
- Each storage communicates with the tiers and with central storage 270 and transmits data detected by the associated parser to the central storage 270.
- storage 225 of tier 220 receives data from parsing unit 222 and sends the data to central storage 270.
- storage 225 sends all the data fields to central storage 270.
- the data sent from the storages 225, 245 and 265 to central storage 270 is provided only upon a query from central storage 270.
- central storage 270 requests only data related to some requests, data related only to data flow during a time period, data related only to requests associated with a specific entity or the like.
- central storage 270 and a processing module reside in a server-like module of the computerized environment, while the tiers and the storages associated with the tiers reside at a client-like module of the computerized environment.
- server side is connected to many client sides, each resides in each tier.
- processing module (not shown) comprises matching unit 280.
- matching unit 280 associates outgoing requests from tier N and the incoming requests to tier N+l, for example, outgoing requests from tier 220 and incoming requests to tier 240.
- implementation of matching between data received from several tiers is performed by storing the requests and responses related to each tier in a separate sequence, and assign a unique value to each request or response.
- unique values may be based on a time stamp, IP:port, counter ID, communication channel ID, request ID, ad-hoc ID, message queue ID, file ID, file type ID, correlation ID, result of a hash code function, CRC function result and the like.
- An example of a sequence may be incoming requests to tier N+l, while another sequence may contain outgoing responses from tier N+l, compared to a sequence containing incoming responses to tier N.
- variety of parameters may be used in associating elements within the sequences, as listed above.
- Matching unit 280 allows association of several requests to one another or to a transaction using the data detected by parsing units as disclosed above while avoiding the tagging module as disclosed in the prior art.
- Matching unit 280 associates outgoing requests from tier N and incoming requests to tier N+l . The association is performed by comparing parameters related to data fields of the requests or to packets that contain the requests. Such parameters may be time stamp, IP:port, counter ID, communication channel ID, request ID, ad-hoc ID, message queue ID, file ID, file type ID, correlation ID, result of a hash code function, CRC function result and the like.
- association of a request received at tier N and requests generated as a result of handling the previously received request requires monitoring of thread activity, communication channels used, the way a request is handled by a thread and the like.
- a thread-to-thread table is utilized to correlate the data based on the communication channel being used, the ad-hoc ID if exists and the like.
- an agent residing within the tier adds or modifies data fields of the request, and determines the relations between requests and the child requests.
- agent is complex to provide in the client side within the tiers, and is more difficult to install, maintain, and is perceived as more intrusive, and may affect the entire tier or client machine in case of a malfunction.
- the processing of data fields associated with requests and responses sent from storages 225, 245, 265 is only performed in matching unit 280.
- the data is sent from the tiers to matching unit 280 that stores the received data in central storage 270 and retrieves such data when required to associate requests.
- matching unit 280 matches incoming request of tier N+l and outgoing requests of tier N using parameters stored in storages 225, 245, 265 such as the timestamp of each request, ad-hoc ID, the unique ID of the request as determined using hash functions or CRC functions and alike and the like. Such data is received from both tier N and tier N+l, and matched by matching unit 280. Matching unit 280 compares data stored in storage associated with tier N with data stored in storage associated with tier N+l and matches incoming requests of tier N+l and outgoing requests of tier N as noted above.
- matching unit 280 In case one of the storages has more indexes, for example in case a request was not received at tier N+l, or a request received more than once, or values of parameters of the request that are used within the sequence are identical for different requests, several algorithms may be used by matching unit 280.
- This problem is also named sequence alignment episode matching problem, and may be solved using any method known to a person skilled in the art.
- One solution may be synchronizing the sequences using a Longest Common Subsequence (LCS) algorithm.
- LCS- Delta algorithm Another solution may be LCS- Delta algorithm.
- Figures 3A and 3B show multi-threaded tiers within a multi-tier computerized environment, according to some exemplary embodiments of the disclosed subject matter.
- Figure 3 A shows a tier 310 comprising two threads, a listener thread 312 and a worker thread 314.
- an incoming request arrives to the listener thread 312 over an existing communication channel.
- the ID of listener thread 312 and the communication channel ID the request was sent upon are both logged to the storage within the tier or associated with the tier, such as storages 225, 245, 265.
- the arriving request is assigned an ID by the parsing unit within the tier where the thread executes.
- ID is different from the ad-hoc IQ since it is assigned and determined by an agent of the disclosed subject matter, not by the protocol implementation within the monitored application as the ad-hoc ID.
- This request is then sent to a working thread 314.
- the association between the request and the respond is done according to the communication channel, assuming a synchronous protocol.
- the association between the request and the respond is done according to the ad-hoc ID generated by the protocol implementation.
- the working thread In case the working thread generates additional requests, they are logged to the storage. Outgoing requests generated by threads that handle a request are also called child requests. In case a child request is sent to another tier, a new ID is assigned to the child request, and the information regarding the working thread 314 that sent the child request and the communication channel used are logged to the storage associated with the tier. In an exemplary embodiment of the subject matter, the parser (such as 222, 242 and 262 of figure 2) assigns the new ID to the child request. After a response is returned to the working thread 314, the working thread 314 sends the response to the request that arrived to the listener thread 312.
- the parser such as 222, 242 and 262 of figure 2
- This response is sent over the same communication channel that the request arrived on, thus enabling association of the request arriving to the listener thread 312, the child requests sent by the worker thread 314, and their responses with the response sent back by the working thread 314 over the same communication channel.
- a synchronous protocol the response is sent immediately after the request.
- an asynchronous protocol the association between the request and response is done according to the ad-hoc ID generated by the protocol implementation. Thus, an association between the arriving request and the new generated child requests is created.
- the response to each request carries an ad-hoc ID, in order to identify a specific request relative to the others.
- Such ad-hoc ID is matched with a value associated with a specific incoming request. For example, in case three requests are generated and sent from one tier to another after the communication is established, each request is assigned a value. Such value may be a function of the ad-hoc ID, or may be associated with the respective ad-hoc ID using an adaptive storage. For example, a numeric value is assigned to a request, indicating the number of events that happened before the request was sent from a tier.
- the ad-hoc ID of the response to that specific request carries an ad-hoc ID associated with the numeric values of the request.
- the association is simple since each response corresponds to the previous request. In most cases, a response is sent on the same communication channel used to transmit the request associated with the response. Hence, the association may be provided by parsing data associated with the requests and responses and parsing data flow on a specific communication channel.
- FIG. 3B shows another embodiment of a multi-threaded tier 330.
- Tier 330 comprises listener thread 332 that receives the request and sends the request to working thread 334. In case additional child requests are generated by working thread 334, they are sent by worker thread 334 to a dispatcher thread 336 that sends the actual child requests to the neighboring tier. Once a child request is sent, a new ID is assigned to the child request, and the information regarding the communication channel it was sent over is logged to the storage associated with the tier. A receiver thread 338 receives the response from the next tier.
- the respond is sent over the same communication channel, and can be associated with the request according to the order, if a synchronous protocol is used, or according to the ad-hoc ID if an asynchronous protocol is used.
- the response is delegated back to the worker thread 334.
- Worker thread 334 sends the response to a sending thread 340 that sends the response to the tier that generated the request associated with the response.
- a thread-to-thread table is required to associate requests with their child requests.
- Such thread-to-thread table maps the data received and sent from each thread. Mapping is performed by tracking thread actions and hooking data within the user space or kernel space. For example, detecting and parsing packets used to transmit data between tiers, or parsing byte stream transmitted via threads within the same tier.
- Figure 4 shows a flowchart of the method for associating requests within a multi-tier computerized environment, according to some exemplary embodiments of the subject matter.
- step 510 data flow within tiers is detected.
- the detected data comprises both incoming and outgoing data flow.
- the detection is performed by a parsing unit residing within the tier.
- the parsing unit is associated with one or more communication channels instead of associated with one or more tiers.
- the detected data is sent from the at least one parsing unit to a processing module that analyzes the detected data.
- the processing module resides outside the tiers and communicates with the at least one parsing unit that reside within the tiers.
- data detected from parsing unit of one tier is compared to data detected from parsing unit of another tier.
- the comparison is performed between outgoing data flow of one tier and incoming data flow of its neighboring tier. For example, outgoing data flow of Tierl (410 of figure IB) is compared to incoming data flow of Tier 2 (420 of figure IB).
- the comparison may be based on request ID determined by applying a hash function, CRC function or the like over the request characters or the request parameters or combination; or over other parts of the protocol which can be associated with a single request instance.
- Other parameters used for comparing incoming and outgoing data flow may be a communication channel ID from which a request or response was received at a tier, a counter ID indicating the number of previous requests received or sent by tier 220, IP: port of the source or destination of the request, whether the request is incoming or outgoing, the time it was sent or received by each tier and the like.
- the comparison may be based on other parameters as disclosed above, or as may be determined by a person skilled in the art.
- requests are associated using the matching unit (280, of figure 2) according to the parameters disclosed above.
- the processing module such as LCS, or any other method used by a person skilled in the art.
- the processing module determines resource consumption of requests or transactions.
- One technical effect of the subject matter is to provide association of incoming requests of one tier and outgoing requests of another tier without modifying data within the requests and without adding a module besides a parsing or detecting module.
- This architecture and apparatus is new and unobvious and provides simple implementation, install and modifications.
- This architecture does not allow analysis of resource consumption in real time, since only the matching unit 280 is aware of the requests associated with a single transaction, while in the tagging method, each tier is aware of the previous requests associated with the same transaction.
- Resource consumption is determined according to the time each request was executed within each tier, and according to the parameters related to the thread that executed the request. Since several requests are associated to the same transaction, a person skilled in the art can sum the resources consumed by each request to determine the resource consumption of a transaction. Other resources may be CPU, memory, I/O devices, and the like, are parsed by the at least one parsing unit and sent to the central storage where the data is processed.
- Time differences between tiers due to internal clock shifts is addressed by receiving periodically actual clock value of each tier and comparing to the clock value in the central storage, thus synchronizing time differences among tiers. Any other method for synchronizing tiers may be provided by a person skilled in the art.
- the methods and apparatus disclosed in the subject matter may be implemented in various operating systems, among which are windows versions, Linux, Solaris, mainframe, AIX, HPUX, AS400, VxWorks or any other OS and derivatives of the above.
Abstract
Description
Claims
Priority Applications (6)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
CN200880128473.2A CN101983366B (en) | 2008-03-30 | 2008-03-30 | Apparatus and method for tracking requests in multi threaded multi tier computerized environment |
PCT/IL2008/000439 WO2009122390A2 (en) | 2008-03-30 | 2008-03-30 | Apparatus and method for tracking requests in a multi threaded multi tier computerized environment |
US12/934,657 US8892726B2 (en) | 2008-03-30 | 2008-03-30 | Apparatus and method for tracking requests in a multi threaded multi tier computerized environment |
EP20080738151 EP2283409A4 (en) | 2008-03-30 | 2008-03-30 | Apparatus and method for tracking requests in a multi threaded multi tier computerized environment |
CA2720026A CA2720026A1 (en) | 2008-03-30 | 2008-03-30 | Apparatus and method for tracking requests in a multi threaded multi tier computerized environment |
IL208418A IL208418A (en) | 2008-03-30 | 2010-10-03 | Apparatus and method for tracking requests in a multi-threaded multi-tier computerized environment |
Applications Claiming Priority (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
PCT/IL2008/000439 WO2009122390A2 (en) | 2008-03-30 | 2008-03-30 | Apparatus and method for tracking requests in a multi threaded multi tier computerized environment |
Publications (2)
Publication Number | Publication Date |
---|---|
WO2009122390A2 true WO2009122390A2 (en) | 2009-10-08 |
WO2009122390A3 WO2009122390A3 (en) | 2010-02-25 |
Family
ID=41136003
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
PCT/IL2008/000439 WO2009122390A2 (en) | 2008-03-30 | 2008-03-30 | Apparatus and method for tracking requests in a multi threaded multi tier computerized environment |
Country Status (5)
Country | Link |
---|---|
US (1) | US8892726B2 (en) |
EP (1) | EP2283409A4 (en) |
CN (1) | CN101983366B (en) |
CA (1) | CA2720026A1 (en) |
WO (1) | WO2009122390A2 (en) |
Families Citing this family (10)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20130268663A1 (en) * | 2010-12-28 | 2013-10-10 | Mitsubishi Electric Corporation | Communication network system |
US8732302B2 (en) | 2011-07-15 | 2014-05-20 | Inetco Systems Limited | Method and system for monitoring performance of an application system |
US11233709B2 (en) | 2011-07-15 | 2022-01-25 | Inetco Systems Limited | Method and system for monitoring performance of an application system |
US8655955B2 (en) * | 2011-08-18 | 2014-02-18 | International Business Machines Corporation | Stream processing using a client-server architecture |
US20130179448A1 (en) * | 2012-01-05 | 2013-07-11 | International Business Machines Corporation | Linking Single System Synchronous Inter-Domain Transaction Activity |
US9154580B2 (en) * | 2012-02-01 | 2015-10-06 | Tata Consultancy Services Limited | Connection management in a computer networking environment |
US9641609B2 (en) * | 2012-02-28 | 2017-05-02 | Google Inc. | Integrated messaging |
US20140041053A1 (en) * | 2012-07-31 | 2014-02-06 | Aled Edwards | Data block access control |
US20160105347A1 (en) * | 2014-10-13 | 2016-04-14 | AppFirst, Inc. | Method of tracing a transaction in a network |
CN104503854A (en) * | 2014-12-29 | 2015-04-08 | 成都科来软件有限公司 | Inter-process communication method and device |
Citations (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US6714976B1 (en) | 1997-03-20 | 2004-03-30 | Concord Communications, Inc. | Systems and methods for monitoring distributed applications using diagnostic information |
US20060015512A1 (en) | 2004-06-04 | 2006-01-19 | Optier Ltd. | System and method for performance management in a multi-tier computing environment |
US7051339B2 (en) | 2001-06-29 | 2006-05-23 | Goldman, Sachs & Co. | System and method to measure latency of transaction information flowing through a computer system |
Family Cites Families (13)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US6356555B1 (en) * | 1995-08-25 | 2002-03-12 | Terayon Communications Systems, Inc. | Apparatus and method for digital data transmission using orthogonal codes |
US5790789A (en) * | 1996-08-02 | 1998-08-04 | Suarez; Larry | Method and architecture for the creation, control and deployment of services within a distributed computer environment |
US6108700A (en) * | 1997-08-01 | 2000-08-22 | International Business Machines Corporation | Application end-to-end response time measurement and decomposition |
US6134594A (en) * | 1997-10-28 | 2000-10-17 | Microsoft Corporation | Multi-user, multiple tier distributed application architecture with single-user access control of middle tier objects |
US7076784B1 (en) * | 1997-10-28 | 2006-07-11 | Microsoft Corporation | Software component execution management using context objects for tracking externally-defined intrinsic properties of executing software components within an execution environment |
US6922685B2 (en) * | 2000-05-22 | 2005-07-26 | Mci, Inc. | Method and system for managing partitioned data resources |
US6823382B2 (en) * | 2001-08-20 | 2004-11-23 | Altaworks Corporation | Monitoring and control engine for multi-tiered service-level management of distributed web-application servers |
AU2003304166A1 (en) * | 2002-01-25 | 2005-01-21 | Seurat Company | Data integration system and method for presenting 3600 customer views |
US20040177042A1 (en) * | 2003-03-05 | 2004-09-09 | Comverse Network Systems, Ltd. | Digital rights management for end-user content |
CA2629015A1 (en) | 2005-11-18 | 2008-05-08 | Rick L. Orsini | Secure data parser method and system |
US7720806B2 (en) * | 2006-05-15 | 2010-05-18 | Algebraix Data Corporation | Systems and methods for data manipulation using multiple storage formats |
US8296413B2 (en) * | 2006-05-31 | 2012-10-23 | Sap Ag | Device registration in a hierarchical monitor service |
US8141100B2 (en) * | 2006-12-20 | 2012-03-20 | International Business Machines Corporation | Identifying attribute propagation for multi-tier processing |
-
2008
- 2008-03-30 EP EP20080738151 patent/EP2283409A4/en not_active Withdrawn
- 2008-03-30 CN CN200880128473.2A patent/CN101983366B/en not_active Expired - Fee Related
- 2008-03-30 CA CA2720026A patent/CA2720026A1/en not_active Abandoned
- 2008-03-30 US US12/934,657 patent/US8892726B2/en not_active Expired - Fee Related
- 2008-03-30 WO PCT/IL2008/000439 patent/WO2009122390A2/en active Application Filing
Patent Citations (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US6714976B1 (en) | 1997-03-20 | 2004-03-30 | Concord Communications, Inc. | Systems and methods for monitoring distributed applications using diagnostic information |
US7051339B2 (en) | 2001-06-29 | 2006-05-23 | Goldman, Sachs & Co. | System and method to measure latency of transaction information flowing through a computer system |
US20060015512A1 (en) | 2004-06-04 | 2006-01-19 | Optier Ltd. | System and method for performance management in a multi-tier computing environment |
Non-Patent Citations (1)
Title |
---|
See also references of EP2283409A4 |
Also Published As
Publication number | Publication date |
---|---|
EP2283409A4 (en) | 2012-04-04 |
WO2009122390A3 (en) | 2010-02-25 |
EP2283409A2 (en) | 2011-02-16 |
US20110035493A1 (en) | 2011-02-10 |
CA2720026A1 (en) | 2009-10-08 |
CN101983366B (en) | 2014-02-12 |
CN101983366A (en) | 2011-03-02 |
US8892726B2 (en) | 2014-11-18 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US8892726B2 (en) | Apparatus and method for tracking requests in a multi threaded multi tier computerized environment | |
EP2183669B1 (en) | Apparatus and method for tracking transaction related data | |
US9342431B2 (en) | Technique to generically manage extensible correlation data | |
US9015278B2 (en) | Transaction correlation using three way handshake | |
US10212063B2 (en) | Network aware distributed business transaction anomaly detection | |
EP1366419B1 (en) | System for embedding correlated performance measurements | |
EP1603307B1 (en) | System and method for performance managment in a multi-tier computing environment | |
US8589537B2 (en) | Methods and computer program products for aggregating network application performance metrics by process pool | |
US9231858B1 (en) | Completeness detection of monitored globally distributed synchronous and asynchronous transactions | |
KR100943110B1 (en) | Trading system | |
US9015731B2 (en) | Event handling system and method | |
US20170126789A1 (en) | Automatic Software Controller Configuration based on Application and Network Data | |
US20170126580A1 (en) | Tracking Contention in a Distributed Business Transaction | |
US20170222893A1 (en) | Distributed Business Transaction Path Network Metrics | |
US9577900B1 (en) | Application centric network experience monitoring | |
US20130246359A1 (en) | Computer product, verification support method, and verification support apparatus | |
US20170222904A1 (en) | Distributed Business Transaction Specific Network Data Capture | |
CN109842465A (en) | Data transmission method, data end equipment |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
WWE | Wipo information: entry into national phase |
Ref document number: 200880128473.2 Country of ref document: CN |
|
121 | Ep: the epo has been informed by wipo that ep was designated in this application |
Ref document number: 08738151 Country of ref document: EP Kind code of ref document: A2 |
|
WWE | Wipo information: entry into national phase |
Ref document number: 2034/MUMNP/2010 Country of ref document: IN |
|
REEP | Request for entry into the european phase |
Ref document number: 2008738151 Country of ref document: EP |
|
WWE | Wipo information: entry into national phase |
Ref document number: 2720026 Country of ref document: CA Ref document number: 2008738151 Country of ref document: EP |
|
NENP | Non-entry into the national phase |
Ref country code: DE |
|
WWE | Wipo information: entry into national phase |
Ref document number: 12934657 Country of ref document: US |