Request Tracing Service
The Request Tracing Service provides tracing facilities for multiple protocols and process communications done by the components of deployed applications.
The service helps users to detect application slowness and performance degradation by logging requests that exceed a given threshold. The trace data from long-running requests gives insight to solving bottlenecks and other performance issues.
|The service is available in both Payara Server and Payara Micro, though the service configuration is different in Payara Micro.|
The following types of requests are traced if the service is enabled:
JAX-RS endpoints (*)
JAX-RS client calls (*)
MicroProfile REST Client calls (*)
Servlets (HTTP requests)
SOAP Web Services (*)
EJB timers execution
Inbound JMS messages received by an MDB
JBatch jobs creation
Tasks executed by injected Managed Executors.
Remote Invocations of EJBs (*)
|Traces of request types marked in (*) are using higher-level APIs and are also available as OpenTelemetry Spans.|
Traces have form of nested spans following the model found in other tracing APIs such as OpenTelemetry and OpenTracing.
The OpenTracing specification, found here, gives a more detailed description of what Spans are and the general trace format. Alternatively you can view a short summary here.
The Request Tracing has the concept of sample rates, affording you extra options to limit the amount of traces processed. In Payara 6.2023.5, there are two offerings: flat probability, and an adaptive solution. The flat probability sampling simply applies a percentage chance that a trace will not be traced. The adaptive solution allows you to configure a target number of traces to sample over a given time period (e.g. sample 6 traces every 10 minutes).
An option to perform this sampling before or after the threshold checks is offered, allowing you to either determine if a trace should be sampled at its inception, or only after determining that a trace has breached your configured thresholds respectively.
As Platform offers support for MicroProfile Telemetry, it is possible to manually instrument your application code for creating spans.
In a practical sense, this means that you can instrument your code using either
@WithSpan annotation, or by injecting and using an OpenTelemetry Tracer via CDI. For full details, see the Platform’s OpenTelemetry documentation.
In-line with our support for MicroProfile OpenTracing, Payara Server and Payara Micro have support for OpenTracing.io code instrumentation.
Since OpenTracing is just a wrapper around OpenTelemetry, it is advised to use OpenTelemetry APIs instead.