eBusiness Transaction Analysis Software
`that Improves Reliability, Performance, and Quality
`
`A Technical Description for Software Developers and Development Managers
`
`HP_1008_0001
`
`

`
`eSleuth White Paper
`
`Build eBusiness Systems with Confidence
`
`Build eBusiness Systems with Confidence
`You’ve invested heavily in high-availability equipment and middleware to provide reliable software communications. But
`one thing worse than your eBusiness system going down is your eBusiness system staying up and silently mishandling your
`business transactions.
`
`eSleuth™ is transaction analysis software that ensures your eBusiness information gets to the right place, at the right time,
`with the right content. eSleuth detects and helps alleviate information flow failures in MQSeries-based eBusiness systems
`running across UNIX, Windows NT, Linux, and OS/390. Using eSleuth during eBusiness application development shortens
`the time to deployment of new eBusiness systems and improves their reliability, performance, and quality by ensuring that
`eBusiness transactions are completed successfully and efficiently.
`
`eSleuth Maximizes Your Middleware Investment
`With the phenomenal growth in eBusiness, middleware such as MQSeries has become the linchpin of the corporate
`computing environment. Yet, despite the pivotal role of middleware, solutions for analyzing inter-component events for the
`purpose of identifying and resolving logic flow problems and performance bottlenecks are sorely lacking. eSleuth fills this
`void by graphically analyzing eBusiness system transactions across system and application boundaries, enabling you to
`visually pinpoint information flow failures and performance bottlenecks. Only eSleuth lets you look inside your application
`to identify the exact logical cause of information flow failures.
`
`The complexity of eBusiness systems makes it virtually impossible to determine the cause of a failure. eSleuth provides a
`unified view of your complete eBusiness system, created from information gathered during application execution. This
`high-level view enables you to clearly see the interaction between components throughout your entire system, making it
`easy to see information flow failures and performance bottlenecks.
`
`Internet
`
`Web Server
`
`S
`
`CGI/
`ISAPI/
`NSAPI
`
`S
`
`S
`
`Web Server
`
`Hub
`
`Rack mount
`
`Repeater
`
`Router
`
`S
`
`Data Warehouse
`
`Remote Office
`/ Users
`
`eSleuth
`Analyzer Console
`
`Middleware
`Technologies
`(MQSeries)
`
`S
`
`ERP
`
`S
`
`Enterprise Data
`Legacy Appls
`
`S = Sensors
`
`Figure 1: eSleuth offers a single point of problem isolation across eBusiness environments by analyzing and
`correlating transactions for visual presentation.
`
`The initial version of eSleuth supports organizations using IBM MQSeries message-oriented middleware. Future versions
`will analyze additional technologies such as HTTP, CGI, CORBA, COM/DCOM, databases, TUXEDO, and Microsoft
`Message Queue (MSMQ).
`
`2
`
`Copyright ª
`
` 2000 Bristol Technology Inc.
`
`HP_1008_0002
`
`

`
`eSleuth White Paper
`
`Build eBusiness Systems with Confidence
`
`More Than Monitoring: Complete Transaction Analysis
`eSleuth enables you to identify problems during development and provides the information you need to resolve these
`problems—before your system goes into production. eSleuth traces MQSeries API (MQI) calls across programs and
`geographical locations and graphically displays the flow of messages between programs and queues. By analyzing the
`details of each API call, eSleuth enables you to drill down into application-specific data, down to data structure contents.
`
`While middleware monitoring tools alert you to MQSeries communication failures, eSleuth has some key features that
`distinguish it from existing middleware management and monitoring tools:
`
`•
`
`•
`
`eSleuth provides logical diagnostic information to developers (such as API calls, call arguments, return values, etc.),
`while management and monitoring tools focus on system data such as queue status.
`
`eSleuth correlates API calls made from different components in the system to form a complete transaction view;
`including graphical depiction of the entire system.
`
`eSleuth generates and stores information for each MQI call made by an eBusiness system. Even though MQI calls may
`occur asynchronously, on different hosts, and within different running programs, eSleuth correlates the calls that relate to
`the same business transaction in your application and graphically presents that information. For example, eSleuth connects
`the MQGET call that retrieves a message with the MQPUT call that sent it, enabling you to trace the logical flow within
`your application across program, execution thread, queue manager, or host boundaries.
`
`In addition, eSleuth translates MQI details into understandable values that you can interpret and act on immediately. It
`formats data structures (MQMD, MQPMO, etc.) and present the symbolic flag names (MQGMO_SYNCPOINT,
`MQOO_INPUT_SHARED, etc.) for MQI data values, even if your program is compiled with optimization. You can see the
`user data buffer within each message as well. Moreover, eSleuth allows you to control which MQI calls are reported to the
`eSleuth Analyzer by specifying filtering criteria. This filtering capability enables you to focus on problem areas.
`
`While message monitoring tools focus on MQSeries infrastructure, eSleuth looks within your application. So while a
`monitoring tool can alert you to an MQSeries-related problem, eSleuth lets you see the MQI call that caused the problem.
`eSleuth’s application focus also lets you see messages that only remain on the queue for a short time—or never arrive in the
`first place—that traditional monitoring tools might miss.
`
`Only Analyze the Data You Need to Solve a Specific Problem
`Through the use of eSleuth presentation filters, you can view the collected information in a variety of ways. From high-
`level views, you can drill down into more event details such as the MQ message descriptor and user data. Instead of simply
`seeing streams of numbers and return codes, eSleuth translates this information into understandable values. You can decide
`to view all the collected events as transactions. eSleuth automatically correlates the collected events into business
`transactions. In addition, you can view the events as they occurred sequentially from all the applications and hosts being
`monitored. You can narrow your search by time, MQI call, queue, queue manager, host, program, thread, and a number of
`other criteria. For more complex filtering requirements, you can even write your own custom filters using the VBScript
`interface built into eSleuth.
`
`Solve the Challenges of eBusiness Transaction Analysis
`The following table demonstrates how eSleuth addresses problems in testing and debugging an eBusiness transaction
`system.
`
`The Problem
`
`How eSleuth Addresses the Problem
`
`Development and diagnostic skills are required on many
`platforms.
`
`eSleuth provides a central transaction analyzer with a Microsoft
`Windows user interface. Working from a central console, you
`can view transactions being processed on local or remote
`heterogeneous computer systems.
`
`3
`
`Copyright ª
`
` 2000 Bristol Technology Inc.
`
`HP_1008_0003
`
`

`
`eSleuth White Paper
`
`How eSleuth Works
`
`Visualizing transaction flows through a complex
`eBusiness system is difficult.
`
`Tracing transactions into legacy or third party
`applications is impossible.
`
`Asynchronous systems process thousands of transactions
`per second
`
`Middleware technologies hide diagnostic information.
`
`Middleware monitoring does not provide enough
`information.
`
`eSleuth provides a component layout graphical view, providing
`a view of transactions occurring across different systems.
`eSleuth automatically determines the transaction flow by
`monitoring a running system; no developer interaction or code
`changes are required.
`
`By providing views of the MQSeries API calls and transactions
`resulting from these calls, eSleuth provides a glimpse inside the
`black boxes and sees what MQSeries API calls are being made
`(including the ability to see the API parameters). This is done
`without access or modification to the source code of these
`legacy applications and components.
`
`eSleuth’s ability to filter the information gathered and presented
`from the remote systems allows you to isolate only the data
`needed to identify problems that are occurring within
`transactions.
`
`Presentation filters within eSleuth enable you to view all of the
`middleware-specific data fields in addition to other information
`that is normally transparent to the developer.
`
`eSleuth provides a view showing all the MQSeries API calls
`made in the eBusiness system, in addition to the correlation of
`these API calls into transactions.
`
`The cause of performance bottlenecks is hard to pinpoint. With eSleuth, transaction path tracing is done at the API level
`within software components of the system. Event sequences can
`be analyzed at the thread level within these components. eSleuth
`maintains timestamp information on all gathered events,
`including corrections for clock skew between the nodes.
`
`How eSleuth Works
`eSleuth consists of two major components:
`
`• Platform- and technology-specific eSensors, which capture information about each MQI call
`• An Analyzer console, which stores captured transaction data, analyzes transactions, configures filters, and presents the
`results graphically
`
`eSensors
`eSleuth sensors are light-weight, non-intrusive monitors that trace API usage across middleware technology such as
`MQSeries. Available for all major platforms, eSensors are installed on each host in the eBusiness application environment
`to capture transaction data for each MQI call executed on that host.
`
`The type and amount of information captured by each eSensor is easily configured from the eSleuth Analyzer console. Data
`collection filters, configured through easy-to-use dialogs, control the data each eSensor collects. For example, you may
`only want the MQMD information on some hosts, MQMD information and user data on other hosts, or all details from all
`the hosts.
`
`Unlike many other debugging or application troubleshooting methods, you do not need access to the original application
`source code to install and use eSensors. The eSensors monitor your system unobtrusively—you do not have to change any
`code or rebuild your application. Once installed on the host, eSensors are able to collect information on every MQI call that
`is made. Even if you do not have source code to certain applications or if applications are compiled in non-debug mode,
`eSensors can still trace all the API calls.
`
`4
`
`Copyright ª
`
` 2000 Bristol Technology Inc.
`
`HP_1008_0004
`
`

`
`eSleuth White Paper
`
`How eSleuth Works
`
`Analyzer Console
`
`Configuration
`Management
`
`Data Collection
`Management
`
`Data Analysis
`
`Graphical
`Presentation
`Logic
`
`Transaction
`Database
`
`Communications
`
`eSensor
`
`Communications
`
`Data Collection
`Mgmt.
`
`S
`
`Local or Remote
`Server
`
`eSensors
`
`eSleuth
`Analyzer Console
`
`S
`
`Local or Remote
`Server
`
`Figure 2: eSensors relay transaction data to the Analyzer console for analysis, correlation, and visual presentation.
`
`eSleuth Analyzer
`The eSleuth analyzer console is the single point of interface for diagnosing problems in your MQSeries application. The
`analyzer console receives messages from the installed eSensors, processes them, and displays different views of this data to
`help you diagnose problems within your system. An embedded database is included with the console for easy setup and
`efficient, persistent storage of data received from eSensors.
`
`The eSleuth Analyzer console provides four primary views: the Component Layout, Event Timeline, Event List, and Event
`Details.
`
`Component Layout
`eSleuth’s unique Component Layout view (Figure 3) graphically displays the interaction between all components of your
`eBusiness system, including the message queues, hosts and programs. eSleuth builds this graph from data collected during
`program execution, so it an accurate and complete representation of how information actually flows throughout your
`eBusiness system. The thickness of the lines between components indicates performance characteristics of your system.
`Color coding makes error conditions easy to pinpoint at a glance. eSleuth’s powerful user interface makes it easy to
`customize this view or print it as a map of your entire eBusiness system.
`
`Event Timeline
`The Event Timeline view (Figure 4) correlates events across multiple hosts and operating systems into transactions. Color
`coding makes it easy to distinguish local or business transactions, and eSleuth’s graphical interface makes it easy to
`navigate between the events that make up a single transaction. You can apply presentation filters to display only the events
`and transactions applicable to any particular transaction for rapid analysis of transaction problems. No user interaction is
`required to generate these transactions—eSleuth automatically links together the messages that make up the same business
`transaction and displays them graphically.
`
`5
`
`Copyright ª
`
` 2000 Bristol Technology Inc.
`
`HP_1008_0005
`
`

`
`eSleuth White Paper
`
`How eSleuth Works
`
`Figure 3: The Component Layout view provides a high-level picture interactions between all components in your
`entire eBusiness system.
`
`Figure 4: The Event Timeline view correlates transactions across program and operating system boundaries.
`
`6
`
`Copyright ª
`
` 2000 Bristol Technology Inc.
`
`HP_1008_0006
`
`

`
`eSleuth White Paper
`
`How eSleuth Works
`
`Event Filtering and Drill Down Capabilities
`You can view all the recorded or real-time events occurring within your system through eSleuth’s Event List view (Figure
`5). In this view, all the data stored in the events database can be displayed and filtered, allowing you to restrict the view to
`only data that is relevant to the analysis of the problem.
`
`Figure 5: The Event List view provides details about selected transaction events.
`
`Easy-to-Read Event Details
`With the Event Details view (Figure 6), you can select an event and view more specific information on that event than in
`the Event List or Event Timeline views. The Event Details view interprets and displays all of the information in the MQMD
`header information, the dead letter queue header, and also user data in the message. No longer will you have to work your
`way through MQSeries header files to establish exactly what a return code value means – eSleuth understands the
`middleware technologies being monitored so it automatically describes the return code. So instead of seeing a reason code
`2024, you will see MQRC_SYNCPOINT_LIMIT_REACHED. By expanding the nodes in the data structure entries you
`can view additional details of structures that exist plus you can view the user data of the message and examine the contents
`in both hexadecimal and ASCII/EBCDIC format. Multiple event detail windows enable you to easily compare the fields of
`two or more messages.
`
`7
`
`Copyright ª
`
` 2000 Bristol Technology Inc.
`
`HP_1008_0007
`
`

`
`eSleuth White Paper
`
`Look at Your eBusiness Applications a New Way
`
`Figure 6: The Event Details view shows comprehensive information about transaction events in an easy-to-
`understand format.
`
`Look at Your eBusiness Applications a New Way
`From a big-picture view of your entire system to individual data structure contents, eSleuth lets you see exactly the
`information you need to improve reliability, performance, and quality for your eBusiness applications. To find out more
`about eSleuth and how it can help ensure that your eBusiness information gets to the right place, at the right time, with the
`right content, call the nearest Bristol office or visit us on the web at http://www.bristol.com.
`
`Availability
`eSleuth is currently available for Windows NT 4.0 or later, Sun Solaris 2.5.1 or later, HP-UX 10.20 or later, IBM AIX 4.2.1
`or later, and IBM OS/390 V2 R5 or later. Support is provided for MQSeries 5.0 or later (2.1 or later on OS/390) with CICS
`TSV 1.2 or later as a requirement on OS/390. Please visit http://www.bristol.com/esleuth for an updated list of supported
`platforms.
`
`About Bristol Technology
`Bristol Technology® delivers software development solutions that make eBusiness work. Our proven experience
`creating award-winning, multi-platform application development tools provides a strong foundation for our new
`line of eBusiness infrastructure products. These products enable developers to implement eBusiness solutions
`based on such technologies as MQSeries and XML faster, more reliably, and easier than ever.
`
`8
`
`Copyright ª
`
` 2000 Bristol Technology Inc.
`
`HP_1008_0008
`
`

`
`39 Old Ridgebury Road
`Danbury, CT 06810-5113 USA
`203-798-1007 (phone)
`203-798-1008 (fax)
`
`Plotterweg 2A
`3821 BB Amersfoort
`The Netherlands
`+31-33-450-5050 (phone)
`+31-33-450-5051 (fax)
`
`Email: info@bristol.com
`Web Site: http://www.bristol.com
`
` 2000 by Bristol Technology Inc. All rights reserved. Printed in the U.S.A. Part number: SO01000222
`
`Copyright ª
`eSleuth(cid:228)
` is a trademark and Bristol Technology(cid:210)
` is a registered trademark of Bristol Technology Inc.
`All other trademarks herein are the property of their respective holders.
`
`HP_1008_0009