🔗 ID-Based Correlation and End-to-End Transaction Tracing
ID-Based Correlation lets GermainUX trace a transaction across browsers, networks, backend services, integrations, messaging systems, and databases.
A unique correlation ID is created at the transaction’s entry point and propagated through each monitored layer. GermainUX components attach that ID to the data they collect, making it possible to reconstruct the complete transaction from beginning to end.
💼 Common Use Cases
🖱️ User Click Tracing
GermainUX can trace a user interaction through every downstream transaction it triggers:
User click → Browser request → Network → API → Backend service → Integration → Database or messaging system
For example, a single click may trigger:
|
Action |
|
|---|---|
|
1 |
An outbound browser request |
|
2 |
An inbound API call |
|
3 |
Several backend methods |
|
4 |
Additional service requests |
|
5 |
SQL queries |
|
6 |
Messages sent through a queue |
GermainUX injects a correlation ID at the initial user interaction or browser request. Each monitored service retrieves the ID, applies it to the collected events and transactions, and passes it to downstream services.
This provides a connected view of what the user experienced and what occurred within the supporting technology.
⚙️ Service Transaction Tracing
ID-Based Correlation can also begin at a service, API, message, or other non-user entry point.
GermainUX components—including RUM JS, RUM Browser Extension, monitoring agents, and Engine—can propagate and collect correlation IDs across distributed applications and services.
This helps teams trace:
|
Trace Type |
|---|
|
Service-to-service API calls |
|
Distributed application transactions |
|
Asynchronous messages |
|
Integration workflows |
|
Scheduled or automated processes |
|
Database operations |
🏗️ Example: AngularJS, Node.js, Java, SQL, and MQ
Consider a multi-tier web application with the following architecture:
|
Step |
Component Interaction |
|---|---|
|
1 |
A user interacts with an AngularJS application in a browser. |
|
2 |
The browser sends a request to a Node.js service. |
|
3 |
Node.js calls a Java backend service. |
|
4 |
The Java service executes SQL queries and sends messages through MQ. |
GermainUX traces the transaction as follows:
|
Trace Step |
Action |
|---|---|
|
1 |
RUM JS generates a unique correlation ID and adds it to the browser’s outbound request. |
|
2 |
The Node.js agent reads the ID from the inbound request. |
|
3 |
The Node.js agent applies the ID to the transactions it records and propagates it to the Java service. |
|
4 |
The Java agent retrieves the ID and applies it to the inbound request, method executions, SQL queries, and MQ operations. |
|
5 |
When supported, the Java agent adds the correlation ID to outbound requests or messages so downstream monitored services can continue the trace. |
The result is an end-to-end transaction that connects the user interaction with every monitored downstream operation.
🚀 Deployment
1️⃣ Deploy RUM JS
Deploy GermainUX monitoring in the AngularJS application.
See User Monitoring and Session Replay.
Once installed, RUM JS:
|
Capability |
|---|
|
Captures user navigation and interactions. |
|
Monitors outbound browser requests. |
|
Generates and injects correlation IDs into supported XHR requests. |
|
Associates the browser requests with the user activity that triggered them. |
2️⃣ Deploy the Node.js Agent
Deploy the GermainUX Node.js Agent.
The agent instruments supported inbound and outbound HTTP requests. It retrieves correlation IDs from incoming requests, applies them to the collected Node.js data, and propagates them to downstream services.
The Node.js Agent can also collect application metrics and generate custom transactions, events, and metrics through its APIs.
3️⃣ Deploy the Java Agent
Deploy the GermainUX Java Agent with each Java service included in the trace.
The Java Agent provides preconfigured instrumentation for:
|
Interface |
Monitoring |
|---|---|
|
Inbound HTTP |
Servlet and Filter API requests |
|
Outbound HTTP |
Requests made through supported HTTP clients, including |
|
SQL |
JDBC queries and associated performance data |
|
Messaging |
JMS operations and messages |
|
Custom code |
Configured Java classes and methods |
When an inbound request contains a GermainUX correlation ID, the Java Agent applies it to the transactions and events generated within that request’s execution context.
For example:
|
Scenario |
|---|
|
If the request executes a SQL statement, GermainUX records the query and its performance data with the same correlation ID. |
|
If the request sends a JMS message, GermainUX records the messaging operation and can add the correlation ID to the message for downstream tracing. |
|
If another monitored service consumes the message, its activity can be connected to the same end-to-end transaction. |
🔍 Trace Completeness
The most complete traces are produced when GermainUX can monitor each significant application or service in the transaction path.
If an intermediate component is not monitored or does not propagate the correlation ID, GermainUX may still display the data collected before and after that component, but the complete relationship may not be established automatically.
Component: Engine
Service: Analytics
Feature Availability: 8.6.0 or later