Lightrun Dynamic Traces
Lightrun Dynamic Traces help developers troubleshoot application flows more efficiently by capturing context-specific, granular data from multiple points within the same execution flow. They ensure that all snapshots belong to the same request or transaction, enabling seamless tracing across different code areas (e.g., from a REST API through service logic). This approach accelerates root cause analysis for complex issues, such as conditional flows, branching logic, and shared code areas.
- Capture highly granular data within the same application flow within your IDE.
- Effortlessly correlate snapshot hits to track a request’s flow with clarity.
- Set specific entry conditions to trace only relevant flows or requests.
- Easily pinpoint the flow branch relevant for the issue under investigations
A Full Debugging Workflow - With Context
With Dynamic traces, developers gain an efficient pane of glass of visibility into entire application flows from the basic ones to the most complex ones. Dynamic tracing better supports the use case of debugging an application flow by enabling users to create relations, group and share data between multiple actions.
Specifically, developer can utilize traces across the following use cases:
- Tracing an application flow:
With Traces, developers can effortlessly track execution across different classes and method, while automatically ensuring that all snapshot hits belong to the same request or transaction. This eliminates the need for manual correlation, which can be complex and error-prone, especially when no explicit correlation parameters exist. - Conditional tracing of a flow:
With Traces, developers can easily troubleshoot bugs that occur only in specific executions of a flow. By setting a condition at the start of the flow, the Dynamic Trace ensures that all subsequent snapshot hits in this trace correlate to the specific execution flow the developer needs to investigate. - Tracing flow branches:
With Traces, developers can easily identify which branch of a flow leads to a problem, even when multiple branches converge at the same point. This enables quick pinpointing of the exact path causing the issue. - Tracing shared code
With Traces, developers can quickly isolate issues in shared services (methods, classes) that only occur when invoked by a specific flow, without the need to sift through numerous isolated, standalone snapshot hits to find the ones tied to the relevant flow.
Lightrun Dynamic Traces : Core Benefit and Architecture
The Lightrun platform provides a wide range of benefits, including enhanced developer productivity, reduced MTTR for complex issues, and lower observability costs. Specifically, Dynamic Tracing enables developers to debug complex, flow-related bugs more effectively. Unlike isolated snapshots, Dynamic Tracing allows for real-time issue resolution within flows, making it significantly easier and more time-efficient to troubleshoot hard-to-diagnose incidents.
See It For Yourself
We offer a fully-featured version of Lightrun on Kubernetes in our Playground.