Monitoring and observability

Cline Enterprise includes two complementary monitoring capabilities: built-in opt-in telemetry for anonymous usage tracking, and OpenTelemetry (OTLP) export for organizations that need to integrate with their own observability infrastructure.

Monitoring options

Built-in telemetry

Anonymous usage tracking built into Cline. Captures feature usage, task completion rates, and error occurrences. No additional infrastructure required.

OpenTelemetry export

Export metrics and logs to your own observability platforms via OTLP. Integrates with Datadog, Grafana, New Relic, Splunk, and any OTLP-compatible backend.

Built-in telemetry

Cline includes opt-in telemetry to help understand usage patterns. All data is anonymous.

What is collected

Feature usage

Tools executed (for example, read_file, execute_command)
Slash commands used
Workflows triggered
Settings changed

Task metrics

Task started and completed events
Mode switches (Plan / Act)
Checkpoint usage
Task duration

Error events

API failures
Tool execution errors
System errors and frequencies

What is never collected

Cline telemetry never includes:

Code or file contents
File paths or names
Command arguments or parameters
Conversation content
API keys or credentials
Personal information

User controls

Individual users enable or disable telemetry in Cline Settings → Cline Telemetry. Changes take effect immediately.

Enterprise default configuration

Administrators can set the default telemetry state via remote configuration:

{
  "telemetryEnabled": true
}

Even when the enterprise default is enabled, individual users can disable Cline telemetry in their local settings.

OpenTelemetry export

For organizations with existing observability infrastructure, Cline supports OpenTelemetry Protocol (OTLP) export of metrics and logs.

OpenTelemetry integration is optional. It requires additional configuration and is intended for organizations with existing observability tooling. Most users do not need this feature.

What is exported

Data type	Examples
Metrics	Feature usage counts, task execution metrics, error rates, performance measurements
Logs	System events, error logs with context, operational information

Exported data is already anonymous and does not include code content, file paths, or sensitive information. However, you are responsible for securing the data once it reaches your systems.

Export protocols

Cline supports three OTLP export protocols:

Protocol	Notes
gRPC	Default. Recommended for most deployments.
HTTP/protobuf	Use when gRPC is blocked by a proxy or firewall.
HTTP/JSON	Use for maximum compatibility.

What is not yet supported

Distributed tracing
Custom instrumentation API
Sampling configuration (defaults are used)

Configuring OpenTelemetry

OpenTelemetry is configured from the Cline dashboard at app.cline.bot under Organization Settings.

Enable OpenTelemetry

In the Organization Settings page, find the OpenTelemetry section and toggle it on.

Configure the OTLP endpoint and protocol

Enter your OTLP collector endpoint URL and select a protocol (gRPC, HTTP/protobuf, or HTTP/JSON).If you are using gRPC, you can opt out of TLS for internal collector endpoints.

Enable metrics and/or logs

Toggle on at least one of Metrics or Logs. Both can be enabled simultaneously.

Configure advanced options (optional)

Advanced settings allow you to:

Set separate endpoints for metrics and logs
Adjust the metrics export interval
Configure log batch size, batch timeout, and maximum queue size

Add authentication headers (if required)

If your OTLP collector requires authentication, add key-value pairs in the Headers section. This is how you pass API keys or bearer tokens to platforms like Datadog or New Relic.

Integration examples

Datadog
Grafana Cloud
New Relic
Self-hosted collector

Datadog accepts OTLP data through its agent or through the Datadog OTLP ingestion endpoint.Endpoint: https://otlp.datadoghq.com:4317 (gRPC) or https://otlp.datadoghq.com:443/api/v1/otlp (HTTP)Required header:

DD-API-KEY: <your-datadog-api-key>

Set the protocol to gRPC and add the DD-API-KEY header in the Headers section of the Cline OpenTelemetry settings.

Grafana Cloud exposes an OTLP endpoint for each stack.Endpoint: Available in your Grafana Cloud stack details under OpenTelemetry.Required header:

Authorization: Bearer <grafana-cloud-token>

Use HTTP/protobuf or gRPC protocol and add the Authorization header in the Cline OpenTelemetry settings.

New Relic supports OTLP ingest natively.Endpoint: https://otlp.nr-data.net:4317 (gRPC) or https://otlp.nr-data.net:4318/v1/metrics (HTTP)Required header:

api-key: <your-new-relic-license-key>

Set the protocol to gRPC and add the api-key header in the Cline OpenTelemetry settings.

Point Cline at your OpenTelemetry Collector instance:Endpoint: http://your-collector:4317 (gRPC) or http://your-collector:4318 (HTTP)For internal collectors without TLS, opt out of TLS in the gRPC settings. No authentication headers are required if your collector is on a private network.Example collector configuration for forwarding to multiple backends:

receivers:
  otlp:
    protocols:
      grpc:
        endpoint: 0.0.0.0:4317
      http:
        endpoint: 0.0.0.0:4318

exporters:
  datadog:
    api:
      key: ${DD_API_KEY}
  prometheusremotewrite:
    endpoint: http://prometheus:9090/api/v1/write

service:
  pipelines:
    metrics:
      receivers: [otlp]
      exporters: [datadog, prometheusremotewrite]
    logs:
      receivers: [otlp]
      exporters: [datadog]

Testing your configuration

After saving the configuration:

Sign in to Cline and perform a few actions in a task.
Wait for the configured export interval (default: 60 seconds for metrics).
Verify that data has arrived in your collector or observability platform.

If no data arrives: Enable debug logging by launching VS Code from the terminal with:

TEL_DEBUG_DIAGNOSTICS=true code .

This outputs detailed information about configuration, exporter initialization, connection attempts, and export results. Alternatively, open the VS Code webview developer tools to see OTLP export errors in the console.

Troubleshooting

Connection errors

Verify the endpoint is reachable:

curl -v https://your-otlp-endpoint:4317

If the endpoint does not use TLS, opt out of TLS in the gRPC settings.
Verify that authentication headers (API keys, bearer tokens) are correct.

No data in observability platform

Confirm at least one of Metrics or Logs is enabled.
Check that the export interval has elapsed before expecting data.
Enable debug mode (TEL_DEBUG_DIAGNOSTICS=true) and look for export errors.
Verify your collector or platform is accepting data from the Cline client IP.

Authentication failures

Double-check that the header key name matches exactly what your platform expects (for example, DD-API-KEY vs api-key).
Verify the API key or token has not expired.
Confirm the key has write/ingest permissions in your observability platform.

Best practices

Start with metrics only. Add logs once you have confirmed metrics are flowing correctly.
Test before production. Verify data reaches your collector before enabling for your full team.
Monitor ingestion costs. Be aware of data ingestion pricing in your observability platform, especially when enabling detailed log export.
Secure your headers. API keys in the Headers section are stored in your organization’s remote configuration. Rotate them according to your key management policies.

Enterprise

​Monitoring options

Built-in telemetry

OpenTelemetry export

​Built-in telemetry

​What is collected

​What is never collected

​User controls

​Enterprise default configuration

​OpenTelemetry export

​What is exported

​Export protocols

​What is not yet supported

​Configuring OpenTelemetry

​Integration examples

​Testing your configuration

​Troubleshooting

​Best practices

Build docs developers (and LLMs) love

Monitoring options

Built-in telemetry

What is collected

What is never collected

User controls

Enterprise default configuration

OpenTelemetry export

What is exported

Export protocols

What is not yet supported

Configuring OpenTelemetry

Integration examples

Testing your configuration

Troubleshooting

Best practices