Support Center Home


Distributed Tracing Overview

Application trace data can help you identify where an issue is occurring in an application’s communication while the application is running. The trace data contains information about each step—or span—of the communication process, such as how long a request took, which components the request interacted with, and any latency introduced in each step. Distributed Tracing is LogicMonitor’s ability to gather this distributed collection of data from your application infrastructure into one central location.

You can monitor the end-to-end communication as the requests flow through the distributed services in your environment and view the trace data directly in your LogicMonitor portal along with relevant metrics and contextual logs. In addition, you can configure alerts to notify you when any component of the process is not performing. For example, after receiving an alert that there is a slow database query for an application, you can use LogicMonitor to pinpoint where in the database the issue is occurring.

LogicMonitor’s Distributed Tracing is an OpenTelemetry-based integration which enables you to forward trace data from instrumented applications and monitor the end-to-end requests as they flow through the distributed services in you environment.

Getting Started with Distributed Tracing

To get started with LogicMonitor’s Distributed Tracing, you’ll first need to instrument at least one application to forward application trace data as spans (operations) to a LogicMonitor OpenTelemetry Collector. Once LogicMonitor is receiving your application’s trace data, you will be able to view and investigate the metrics and operations using the Traces page.

The Traces page, showing the latency graph and table of operations.

Sending Traces to LogicMonitor

There are two steps necessary to send application traces to LogicMonitor:

1. Deploy the LogicMonitor OpenTelemetry Collector on an application host to forward the application’s trace data to LogicMonitor. You can add an OpenTelemetry Collector through Exchange > OpenTelemetry Collectors > Add. See Installing an OpenTelemetry Collector.

2. Instrument your applications to emit OpenTelemetry-compliant traces. You can do this using OpenTelemetry client libraries for automatic instrumentation (recommended), or using the OpenTelemetry API and SDK for manual instrumentation. The following table provides language specific guidelines for application instrumentation:

LanguageDescription
JavaAutomatic instrumentation instructions are available within LogicMonitor from Traces > Onboarding > Java > Automatic Instrumentation. See Instrumenting a Java Application
PythonAutomatic instrumentation instructions are available within LogicMonitor from Traces > Onboarding > Python > Automatic Instrumentation. See Instrumenting a Python Application
.NETAt this time, LogicMonitor does not have an in-app guided experience for instrumenting .NET applications.
See the following for more information about instrumenting .NET applications:
– OpenTelemetry’s .NET documentation
Forwarding Traces from Instrumented Applications support article
– LogicMonitor’s DotNet Application Instrumentation for Distributed Traces blog post
GoAt this time, LogicMonitor does not have an in-app guided experience for instrumenting Go applications.
See the following for more information about instrumenting Go applications:
– OpenTelemetry’s Go documentation
Forwarding Traces from Instrumented Applications support article
– LogicMonitor’s Golang Application Instrumentation for Distributed Traces blog post
PHPAt this time, LogicMonitor does not have an in-app guided experience for instrumenting PHP applications.
See the following for more information about instrumenting PHP applications:
– OpenTelemetry’s PHP documentation
Forwarding Traces from Instrumented Applications support article
RubyAt this time, LogicMonitor does not have an in-app guided experience for instrumenting Ruby applications.
See the following for more information about instrumenting Ruby applications:
– OpenTelemetry’s Ruby documentation
Forwarding Traces from Instrumented Applications support article
– LogicMonitor’s Ruby Application Manual Instrumentation for Distributed Traces blog post
Javascript/Node.jsAt this time, LogicMonitor does not have an in-app guided experience for instrumenting Javascript applications.
See the following for more information about instrumenting Javascript/Node.js applications:
– OpenTelemetry’s Javascript documentation
Forwarding Traces from Instrumented Applications support article
– LogicMonitor’s NodeJS Application Manual Instrumentation for Distributed Traces blog post
C++At this time, LogicMonitor does not have an in-app guided experience for instrumenting C++ applications.
See the following for more information about instrumenting C++ applications:
– OpenTelemetry’s C++ documentation
Forwarding Traces from Instrumented Applications support article
FlaskAt this time, LogicMonitor does not have an in-app guided experience for instrumenting Flask applications. 
See the following for more information about instrumenting Flask applications:
Forwarding Traces from Instrumented Applications support article
– LogicMonitor’s Flask Application Manual Instrumentation for Distributed Traces blog post

Viewing Traces in LogicMonitor

After you install at least one of LogicMonitor’s Collectors in your environment and instrument applications to emit and forward traces, you can see and interact with these traces and the operations that make them up within LogicMonitor.

1. Operations will be mapped to existing resources or new resources will be automatically created if they do not already exist. You will see trace metrics start to display at the resource-level. For the best results, we recommend that you monitor the underlying infrastructure for your applications through the proper modules (LM Cloud, LM Container, and traditional compute based infrastructure). See Viewing Traces for a Resource.

2. Services will be automatically created to group underlying resources and display service-level operation metrics. See Viewing Traces for a Service.

3. Service operations and end-to-end traces will become accessible from the Traces page in LogicMonitor, allowing you to proactively identify slow operations as areas for optimization and troubleshoot issues more quickly. See Using the Traces page.

In This Article