Runtime Tracing Extension Interface for Middleware Platforms
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Runtime tracing in software applications involving multiple tiers and systems is challenging due to the complexity of tracing execution across various layers.
Innovation Solution
A system and method for providing runtime tracing for web-based clients accessing a transactional middleware platform using an extension interface, which includes an extension server and class library to generate trace records from service call initiation to response, utilizing a trace generator to define trace filters and categorize trace points.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If runtime tracing is implemented in a multi-tier software application involving multiple systems, then monitoring and debugging capability is improved, but system complexity and difficulty of implementation increase
Solution Approach 1:
The patent segments the tracing system into distinct modular components: trace filters that categorize trace points by type, trace generators that create trace records, and trace managers that coordinate the tracing process across multiple tiers. This modular segmentation allows runtime tracing to be implemented in a multi-tier software application by distributing tracing functionality across different layers (web-based client, extension server, middleware platform) rather than requiring a monolithic tracing solution, thereby improving monitoring capability while managing system complexity through organized modularity
Solution Approach 2:
The patent introduces trace filters as intermediary components that sit between the various system tiers and the trace generation process. These filters categorize and filter trace points before they are recorded, acting as mediators that manage the flow of tracing information across the distributed system. The extension interface also serves as an intermediary layer that enables web-based clients to access the middleware platform while maintaining tracing capability, thus improving debugging capability without directly increasing core system complexity
2Loss of information
If end-to-end tracing is implemented across multiple layers, then traceability and event correlation are improved, but performance overhead and resource consumption increase
Solution Approach 1:
The patent implements partial action by allowing selective tracing through configurable trace filters. Instead of tracing all operations across every layer, administrators can specify which categories of trace points to monitor (e.g., only service call initiation, only response handling, or specific error types). This partial tracing approach maintains end-to-end traceability for selected operations while reducing the overall performance overhead by excluding unnecessary trace points from the tracing process
Solution Approach 2:
The patent enables dynamic control of tracing behavior through parameter changes in the trace filter configuration. By adjusting filter parameters to include or exclude specific trace point categories, the system can adapt the level of tracing detail to match current debugging needs. This allows the system to switch between high-traceability mode (when debugging is needed) and low-overhead mode (during normal operation), thus balancing traceability requirements against performance overhead
Data Source
AI summary
In accordance with an embodiment, described herein is a system and method for providing runtime tracing for a web-based client that accesses a transactional middleware platform using an extension interface. The extension interface provides an extension server and a class library to make application services in the transactional middleware platform available to web-based clients. A trace generator can be provided to compose a trace filter specifying categories of trace points, and to generate trace records based on the composed trace filter and trace points encountered at runtime. Code snippets can be inserted into each class in the class library for use in invoking the trace generator. At runtime, one or more objects instantiated from the class library can invoke the trace generator to generate trace records that track a particular web-based client end to end, from the time it starts a service call to the time it gets a response.