Transaction Analyzer Models
SteelCentral Transaction Analyzer can generate a model of an application by analyzing a live network packet trace capture from the application. Based on the capture files, this module makes conjectures as to the actual message exchange pattern of the application, complete with message sizes, timing sequence, and dependencies. You can import Transaction Analyzer models into the discrete event simulation environment and play back the models to create the same traffic pattern as you captured in the live environment.
Note: This section pertains only to the DES features of Transaction Analyzer. Transaction Analyzer has other important features that are outside the scope of this document.
Advantages
A Transaction Analyzer model is as close as you can get to creating an exact model of your existing application. Because Transaction Analyzer makes no assumptions about the application behavior and plays back the messages exactly as it capture them in the live environment, the resulting traffic pattern very closely replicates the actual application behavior.
Transaction Analyzer models require minimal configuration, because, unlike the custom application model which requires you to configure the application behavior, a Transaction Analyzer model already contains the details of the application behavior. This reduces the possibility of user errors in configuration. Transaction Analyzer is also integrated with the Advanced Server Models.
Limitations
The starting point for Transaction Analyzer is an application packet trace capture from a live network; therefore, Transaction Analyzer can only be used for applications that are implemented and operational in the live network. Transaction Analyzer cannot be used for applications that are in the design phase or are not fully implemented.
Typical applications generate slightly different traffic each time a transaction is executed. For example, a database query may generate different traffic patterns, depending on the search criteria. A given trace represents one instance of the transaction and the traffic pattern associated with that instance and cannot encompass every possible variation.
You can measure throughput in a Transaction Analyzer file using the AppDoctor statistic “Network Throughput (Kbits/sec)”. You can also generate throughput statistics from a discrete event simulation. However, AppDoctor and a discrete simulation might produce different throughput results—even with the same network conditions and assumptions—because they interpret the size of ethernet packets differently.
Transaction Analyzer calculates the packet size as follows:
<size_of_ethernet_packet> = <header_size> + <data_size>
A discrete event simulation calculates the packet size as follows:
<size_of_ethernet_packet> = <preamble_size>
+ <header_size> + <CRC_size> + <data_size>
You can deploy one or more traces in a scenario (in the Project Editor, choose Protocols > Applications > Import from AppTransaction Xpert > as Discrete Traffic...). This operation creates a custom application that includes one task for each packet trace. These tasks will not reuse the same TCP connection during a simulation; each task initiates its own, separate TCP connection. If you want to simulate an application that uses the same TCP connection, you must capture the entire transaction in one capture operation. This will ensure that the entire transaction is modeled in one Transaction Analyzer model file (rather than in multiple files).
Use Cases
Transaction Analyzer is useful for creating an accurate representation of the traffic pattern of your existing application. It eliminates guesswork in reproducing traffic patterns, since it can deduce those patterns from the packet capture from your live network.
Transaction Whiteboard
Transaction Whiteboard (part of Transaction Analyzer) provides another way to generate an application model that can be used in simulations. With it, you can draw the traffic pattern on a network as a series of interdependent messages, then run a simulation using the resulting application model.
Note: You must have a license for Transaction Analyzer to edit Transaction Whiteboard files.
Transaction Whiteboard is a fully developed message editor, so you can
- Specify the message sizes
- Specify the processing time on the tier when a message is received
- Create connections on which the messages are sent
- Create message blocks, and so on
Note: This section pertains only to the DES features of Transaction Whiteboard. Transaction Whiteboard has several other important features that are outside the scope of this document.
One of the most powerful features of Transaction Whiteboard is that it provides a Python interface for embedding logic scripts in the model. The behavior of the model can be controlled dynamically at run time by introducing Python scripts at strategic places in the Transaction Whiteboard model.
Advantages
Transaction Whiteboard can be used to model applications that are in the design phase or have not yet been fully implemented. The full Python interpreter and the standard Python libraries are available for writing arbitrarily complex scripts. Since Transaction Whiteboard can also import Transaction Analyzer packet traces and render them editable, you can redesign and modify existing applications.
Limitations
Because Python is an interpreted language, executing the Python scripts in an Transaction Whiteboard model can potentially slow down a simulation. However, for most models, this might be negligible, because the time spent executing the Python scripts is relatively small compared to the overall simulation time. This limitation does not apply to models that do not contain any Python scripts.
Use Cases
Transaction Whiteboard is an application design environment for modeling and studying different application designs or design modifications, including application logic and module hierarchies, before implementing them.