OpenTelemetry

Starting from version 3.5, the Toolbox App can export OpenTelemetry traces to an external OTLP collector over HTTP. Only remote development flows are instrumented: connections to remote environments and connections of remote development clients. No other Toolbox App activity is reported. To collect telemetry from inside the remote development IDE, install the OpenTelemetry Diagnostic plugin.

Traces are sent to the v1/traces path of the configured endpoint. Every span carries the service.name resource attribute set to JetBrains Toolbox and the service.version attribute set to the build number. The Toolbox App sets both attributes itself, so the collector receives the following resource:

        {
            "resource": {
                "attributes": {
                    "service.name": "JetBrains Toolbox",
                    "service.version": "2.9.0.40010"
                }
            }
        }
    

Configuration

The export is disabled until an endpoint is configured. Use one of the following options:

Settings file

Set the endpoint in the telemetry section of the .settings.json file:

                    {
                        "telemetry": {
                            "otlp_http_endpoint": "https://collector.example.com/"
                        }
                    }
                

The file is located in the Toolbox App data directory:

%LOCALAPPDATA%\JetBrains\Toolbox\.settings.json

~/Library/Application Support/JetBrains/Toolbox/.settings.json

~/.local/share/JetBrains/Toolbox/.settings.json

Environment variables

OTEL_EXPORTER_OTLP_ENDPOINT — base URL of the OTLP/HTTP collector.
OTEL_EXPORTER_OTLP_HEADERS — comma-separated key=value pairs added to every export request, for example, for authentication.
OTEL_RESOURCE_ATTRIBUTES — comma-separated key=value pairs added as resource attributes, for example, user.login=jdoe.

The Toolbox App reads these variables from its process environment at startup. An app started from Dock, Finder, or the Start menu does not inherit variables exported in a shell profile, so either start the Toolbox App from a shell that has them, set them system-wide for your operating system, or use the settings file instead.

OTEL_EXPORTER_OTLP_ENDPOINT takes precedence over the setting in the .settings.json file. Custom and self-signed certificates configured for the Toolbox App are reused for the connection to the collector. For details, see Add self-signed certificate.

Remote development spans

Each span listed below covers one operation of a remote development connection and is marked as failed when that operation fails. Spans that cover the whole lifetime of a connection are missing if the Toolbox App is terminated while the connection is still open.

Client connection

remdev.client.connection

A remote development client is attempting to connect to a remote environment.

remdev.client.connection.inner

A specific connection attempt. Attributes: providerId, environmentId, and targetIde identify the connection target.

Events:

provider.not.found — the requested plugin is not installed, for example, it was removed while the client was running.
environment.not.found — the requested environment is not available, for example, it was removed on the provider side.

remdev.client.connection.with.env

The remote environment is found, and the connection to it is in progress.

Events:

remote.env.connected — the connection to the remote Toolbox Agent is established.
remote.ide.not.in.rd.mode — the remote IDE is running, but not in the remote development host mode.
multiple.remote.ides — several remote IDEs are running, and the Toolbox App cannot choose which one to connect to. Usually a misconfigured host machine.
new.link.sent — an updated join link is sent to the client.

remdev.forward.ide.port

The port forwarding step. Attributes: previous.forwarding.closed, local.port, remote.port, and remote.host.

Environment connection

remdev.environment.connection

A connection attempt to a remote environment, either for the Toolbox App itself or for a client connection. Covers the whole lifetime of the connection.

Events:

before.connect.hook.rejected — a plugin rejected the connection.
connection.success — the environment is connected.
user.cancelled — the user canceled the connection.
redeploy — the Toolbox Agent has to be deployed again, which leads to another connection attempt.
connection.failed — the connection attempt failed.

remdev.environment.connect.impl

A single connection attempt, without the following connection lifetime. Attributes: providerId and environmentId.

Events:

connection.failed with the fail.reason attribute. The reason is an internal enum value, not a raw exception.

remdev.environment.connect.getRpcClient

Connecting to the remote Toolbox Agent. Contains the following child spans:

remdev.environment.connect.sshConnect — establishing the SSH connection.
remdev.environment.connect.deployAgent — deploying and launching the remote Toolbox Agent.

remdev.environment.connect.establishRpcConnection

Connecting to the deployed remote Toolbox Agent.

IDE telemetry with the OpenTelemetry Diagnostic plugin

The Toolbox App reports only its own connection flows. To also collect telemetry from inside the remote development IDE, install the OpenTelemetry Diagnostic (Remote Development) plugin (com.jetbrains.otp.diagnostic). It works only in remote development mode and must be installed on both the frontend (JetBrains Client) and the backend (remote IDE). Frontend and backend events are then unified under a single session span.

Configuration

Configure the plugin on the backend only. The backend propagates the OTLP connection configuration to the frontend over encrypted RPC, so the frontend needs no separate setup.

Every option below is available both as an environment variable and as a system property. The property name is the variable name in lowercase with dots instead of underscores, for example, otel.exporter.otlp.endpoint for OTEL_EXPORTER_OTLP_ENDPOINT. Pass system properties in the VM options of the backend IDE. If both are set, the system property wins.

OTEL_EXPORTER_OTLP_HEADERS: Required. Comma-separated key=value pairs, for example authorization=Bearer <token>. Signal-specific OTEL_EXPORTER_OTLP_TRACES_HEADERS and OTEL_EXPORTER_OTLP_METRICS_HEADERS override common headers with the same key.
OTEL_EXPORTER_OTLP_ENDPOINT: Optional. Defaults to http://localhost.
OTEL_EXPORTER_OTLP_PROTOCOL: Optional. Either http/protobuf (default) or grpc.
RDCT_COMMON_SPAN_ATTRIBUTES and RDCT_COMMON_METRIC_ATTRIBUTES: Optional. Comma-separated key=value pairs added to every exported span, or to metrics only. The plugin also adds plugin.version, idea.version, and idea.build automatically.

In Settings | Tools | OpenTelemetry Diagnostic, you can limit which spans are exported and toggle metrics and on-demand performance reports. These settings are synced from the frontend to the backend.

Spans

remote-dev-session: The whole remote development session, from client connection to session end. Attribute: session.id. This span can stay open for hours or days.
session-metadata: A short-lived span emitted at session start, so that a running session can be found before remote-dev-session closes. Attributes: session.trace_id, session.span_id, session.id, and host.name.
application-idle: A fallback parent for events that occur before the first session starts.
connection-dropped-reconnecting: A connection drop and the following reconnection, which measures reconnection latency. Attributes: project and reconnection.throttled.drop_count. Repeated drops are throttled by an adaptive cooldown, so not every flap produces a span.
ui-thread-freeze: A UI freeze reported by the platform, backdated to the actual freeze start.
ide-exception.<ExceptionClass>: An error logged by the IntelliJ Platform with a throwable. Attributes include exception.type, exception.message, exception.stacktrace, and the blamed plugin.

Except for remote-dev-session, all spans are short-lived and are parented to the current session span.

10 September 2026