#OpenTelemetry Integration

Ottrelite provides seamless integration with OpenTelemetry (OTEL), allowing you to use your existing OpenTelemetry instrumentation while leveraging Ottrelite's visualization backends for development-time analysis.

The integration works by providing Ottrelite-compatible TracerProvider and MeterProvider implementations that can export to both Ottrelite backends (for development visualization) and traditional OTEL collectors (for production monitoring).

#Supported platforms

#Installation

npm install @ottrelite/interop-otel

#Available classes

#TracerProvider

Ottrelite provides OttreliteTracerProvider that extends OpenTelemetry's standard TracerProvider with comprehensive Ottrelite integration:

Automatic Configuration:

• Resource metadata - Configures default resource to carry Ottrelite-specific metadata
• Trace context propagation - Registers W3C trace context and baggage propagators
• Context management - Sets up StackContextManager by default for proper span correlation

#MeterProvider

The OttreliteMeterProvider provides metrics collection with Ottrelite integration. It uses dynamic instrumentation by hooking into instrument creation methods and their return values, replacing properties on instances to call Ottrelite's logic before the original execution.

#Development Span Processor

The DevSpanProcessorInterceptor enables live span visualization during development. It intercepts the OpenTelemetry API to propagate all OTEL spans in real-time to Ottrelite's development backends, allowing you to see traces immediately in Tracy or platform profilers while maintaining your existing OTEL instrumentation.

#Configuration

Configure OpenTelemetry to work with Ottrelite's visualization backends:

import { resourceFromAttributes } from '@opentelemetry/resources';
import { SimpleSpanProcessor } from '@opentelemetry/sdk-trace-base';
import {
  ATTR_SERVICE_NAME,
  ATTR_SERVICE_VERSION,
} from '@opentelemetry/semantic-conventions';
import {
  DevSpanProcessorInterceptor,
  OttreliteExporterOTLP,
  OttreliteMeterProvider,
  OttreliteTracerProvider,
} from '@ottrelite/interop-otel';

// optional step: resource attributes; below: example options, this can be customized as needed
const resource = resourceFromAttributes({
  [ATTR_SERVICE_NAME]: appName,
  [ATTR_SERVICE_VERSION]: getVersion(),
  'device.id': getDeviceId(),
  'os.name': Platform.OS,
  'os.version': getSystemVersion(),
});

// Configure the OpenTelemetry TracerProvider to use Ottrelite's capabilities
const tracerProvider = new OttreliteTracerProvider({
  spanProcessors: [
    // Register the DevSpanProcessorInterceptor for live tracing in development
    new DevSpanProcessorInterceptor(),
  ],
  resource,
});

tracerProvider.register();

// Configure the OpenTelemetry MeterProvider to use Ottrelite's capabilities
const meterProvider = new OttreliteMeterProvider({
  resource,
});

meterProvider.register();

#Community Instrumentations

Ottrelite integrates with the OpenTelemetry JavaScript API, allowing you to use the same community instrumentations as you would with standard OpenTelemetry JS. This enables automatic instrumentation of various APIs and frameworks.

The example below shows common instrumentations for React Native apps. You can add more as needed, inspired by the OpenTelemetry demo React Native app.

import { registerInstrumentations } from '@opentelemetry/instrumentation';
import { FetchInstrumentation } from '@opentelemetry/instrumentation-fetch';
import { XMLHttpRequestInstrumentation } from '@opentelemetry/instrumentation-xml-http-request';

registerInstrumentations({
  instrumentations: [
    new FetchInstrumentation({
      clearTimingResources: false,
      propagateTraceHeaderCorsUrls: /.*/,
    }),
    new XMLHttpRequestInstrumentation({
      ignoreUrls: [/\/fetch-urls\/.*/],
    }),
  ],
});

#C++ Integration

The C++ integration enables OpenTelemetry spans from C++ code to be visualized in Ottrelite's backends. When you register the JavaScript TracerProvider and MeterProvider, Ottrelite automatically configures the global C++ OpenTelemetry providers to use the same exporters and visualization backends.

#Options

The Ottrelite.install method accepts C++ OTEL SDK configuration options:

• cppBatchLogRecordProcessorOptions - Configure log record batch processing
• cppMetricReaderOptions - Configure metrics export intervals and batching
• cppTraceBatchSpanProcessorOptions - Configure span batch processing

These options only affect C++ data export behavior; other language layers process spans according to their own configurations.