Additional span attributes to publish as part of each span, specified as key/value pairs. You can use environment variables as values. Environment variables must start and end with a percent sign (e.g., %MyEnvVar%), and can contain a fallback value (e.g., %MyEnvVar?literalDefaultValue%).

Additional attributes to publish as part of the OTEL resource definition, specified as key/value pairs. You can use environment variables as values. Environment variables must start and end with a percent sign (e.g., %MyEnvVar%), and can contain a fallback value (e.g., %MyEnvVar?literalDefaultValue%).

Whether to add resource attributes to span attributes.

Whether the clickstream trace will be enabled. false - clickstream trace is disabled. true - same as sibling nested - clickstream trace is enabled and each subsequent span is a child span of the previous one. sibling - clickstream trace is enabled and each subsequent span is a child of the same initial span.

If true, the application will create a span with the name interopio.api.application.close when it's being closed. This functionality requires close handlers to be enabled in the application configuration.

Compression algorithm to use when exporting trace.

Maximum number of concurrent trace export requests.

If an OTEL TraceProvider isn't provided to the library, it will initialize its own.

If 'console' is 'true', TracerProvider will have a ConsoleTraceExporter.

Allows specifying a constructor callback for creating the ContextManager instance.

If true or a string, span hits are published as a counter metric. If a string value is specified, this will be the name of the metric. Otherwise, the default "insights_trace_count" is used. Set to false or null to disable the metric. Spans opt in through the countMetric span creation option (see 'filters' and 'defaults').

This property is for internal use only.

Default settings if appropriate entries aren't found in 'filters' and 'sampling' collections.

If true or a string, span durations are published as a histogram metric. If a string value is specified, this will be the name of the metric. Otherwise, the default "insights_trace_duration" is used. Set to false or null to disable the metric. Spans opt in through the durationMetric span creation option (see 'filters' and 'defaults').

Whether tracing functionality is enabled. If disabled, API is still usable, but methods are no-ops.

If an OTEL TraceProvider isn't provided to the library, it will initialize its own.

If 'url' is specified, TracerProvider will have an OTLPTraceExporter with 'url' as detination URL and 'exporterSettings' as additional config.

Array of filter entries used to determine whether a particular operation will create a tracing span, and what verbosity level will apply to attributes added to that span.

If no matching filter entry is found, the settings from 'default' are used.

Additional headers to send in HTTP requests, e.g. when using HTTP exporters.

If true, the library will use both the ContextManager provided by the OTEL SDK and the Traces.currentTracingState property to resolve the current context. See the documentation of the useOTELContextManager property for more details.

If true, io.Insights will instrument and trace the application initialization process automatically.

If true, io.Insights will instrument and trace the application startup process automatically: a root "interopio.api.appStartup" span starting at the runtime's time origin, under which spans created during the startup window are nested (via the propagation defaults). In browsers the root carries child spans and KPIs reconstructed from the performance timeline (navigation phases, paints, long tasks, startup-window web vitals, lifecycle transitions).

Also works in NodeJS: the root span opens at process start and the startup window nesting applies, but the browser performance-timeline children are not produced. The window closes on startupParentSpanTimeoutMs or an explicit startupTraceFinished() call ("loader" mode behaves as "any" in Node - there is no loader signal). When the platform provides a root propagation info, the startup span is parented under it.

If true, io.Insights will instrument and trace the steps of the document load process automatically

If true (or a configuration object with enabled), uncaught errors and unhandled promise rejections are published as error spans ("interopio.api.instrumentation.error" / ".unhandledRejection"), including errors buffered before initialization by the pre-init recorder. Capped per session to guard against error storms. When enabled, the app startup trace defers its own error capture to this instrumentation, and the pre-init recorder (when installed) captures errors from page start - opt out of that with the configuration object's preInit: false.

Also works in NodeJS, via process.uncaughtExceptionMonitor - a behavior-preserving hook: the process still crashes exactly as it would have. The span processors are force-flushed immediately, so the crash span is exported whenever anything keeps the process alive past the crash (an application 'uncaughtException' handler, a graceful shutdown); on a hard crash the export cannot complete and the span is lost with the process. Under Node's default unhandled-rejections=throw mode, crash-grade unhandled rejections are reported too; non-crashing rejection observation is deliberately not done in Node, because subscribing to process.unhandledRejection would suppress Node's default crash semantics.

If true (or a configuration object), event loop responsiveness is instrumented: slow input events (Event Timing API) and main-thread-blocking long frames (Long Animation Frames API, falling back to Long Tasks) are published as spans ("interopio.api.instrumentation.inputDelay" / ".eventLoopBlocking"), with the input-delay spans carrying the same element-describing attributes as the clickstream spans. Optional histogram metrics can be enabled via the configuration object. Entries recorded before initialization are replayed from the performance buffers.

If true, in-page (SPA) navigations - history pushState/replaceState, popstate and hashchange - are published as spans ("interopio.api.instrumentation.navigation") with the sanitized from/to URLs. Same-URL state updates are not reported.

If true (or a configuration object with enabled: true), io.Insights will instrument and trace XMLHttpRequest and fetch() requests automatically. When enabled, the pre-init recorder (when installed) also captures requests from page start - opt out of that with the configuration object's preInit: false.

If true (or a configuration object), resource loads (scripts, stylesheets, images, fonts, ...) are published as spans ("interopio.api.instrumentation.resource") with their real timings from the resource timing buffer, including resources loaded before initialization, a cacheState attribute ("hit", "revalidated", "network", or "unknown" - cross-origin resources without a Timing-Allow-Origin header withhold cache provenance), and the nonzero connection-phase timings (dns/connect/tls/ttfb). By default fetch/XHR resources are excluded (the request instrumentation covers them in more detail; see skipRequests), as are telemetry uploads. Optional histogram/counter metrics can be enabled via the configuration object. When enabled, the app startup trace defers its slowest-resource child spans to this instrumentation.

If true (or a configuration object), WebSocket connections are instrumented: each connection is published as a span ("interopio.api.instrumentation.webSocket") covering its whole lifetime - construction until close - with the connect duration, negotiated protocol, close code/reason/wasClean, and message/byte totals in both directions. Abnormal closures (code 1006) and connection failures mark the span as ERROR. Optional message/byte counters and a connect-duration histogram can be enabled via the configuration object. Telemetry endpoints are never instrumented; the io.Connect gateway connection is tracked by default (its lifecycle is platform-health telemetry - exclude it with ignoreGateway), and ignorePattern can exclude other infrastructure sockets.

When the pre-init module (early.js) is loaded, sockets are tracked from page start: connections that closed before initialization become retroactive spans, and connections still open are adopted with spans starting at their true construction time and counters carried across - a socket opened at bootstrap is fully observed. Without the pre-init module, sockets constructed before initialization are not observed at all.

If true (or a configuration object), session-level Web Vitals are tracked: CLS (cumulative layout shift, session-window algorithm), INP (interaction to next paint, the web-vitals estimation over Event Timing entries) and the final LCP. A "interopio.api.instrumentation.webVitals" span with the current values is published each time the page becomes hidden (when the values changed), and optional histogram metrics record one terminal sample per page at pagehide. Complements the startup trace's perf.vitals, which cover only the startup window - CLS accumulates and INP is defined over the whole session.

Whether to keep the connection alive when sending traces.

Maximum length for parent operation names in span hierarchies.

Configuration for the batch span processor buffer settings.

Allows specifying a constructor callback for creating the TextMapPropagator instance.

Interval in milliseconds between trace export batches.

If true or a string, span results (status codes) are published as a counter metric. If a string value is specified, this will be the name of the metric. Otherwise, the default "insights_trace_result" is used. Set to false or null to disable the metric. Spans opt in through the resultMetric span creation option (see 'filters' and 'defaults').

Property for internal use.

Allows specifying a constructor callback for creating the Sampler instance.

Array of sampling setting entries used to determine whether a span will be sampled.

If no matching sampling setting entry is found, the settings from 'defaults' are used.

Allows specifying a constructor callback for creating the SpanExporter instances.

Allows specifying a constructor callback for creating the SpanProcessor instances.

Overrides the properties of the top-level ssoAuth for the traces export requests; the ones that aren't specified here are taken from it.

When will the application startup span be considered completed, so that further spans are added under it.

• explicit - when Traces.instance.startupTraceFinished() is called by the application code
• timeout - same as "explicit" OR when startupParentSpanTimeoutMs have elapsed and the DOMContentLoaded event has fired
• loader - same as "explicit" OR when the loading animation of the window has completed
• any - when any of the above conditions are met

In NodeJS there is no loader signal (or DOM readiness): "loader" behaves as "any", and the timeout counts alone.

If non-zero, how long after application startup will any traced operations automatically be nested under the application startup trace. The timeout is counted from the moment the io.Connect API begins initializing. Without a timeout the startup window only closes on an explicit startupTraceFinished() call (or the loader signal in io.Connect Desktop windows) - the root span stays open, and unexported, until then.

Maximum time the OTLP exporter will wait for each batch export.

Allows specifying a constructor callback for creating the tracerProvider instance.

OTEL TracerConfig - provides an interface for configuring a Basic Tracer.

If an OTEL TraceProvider isn't provided to the library, it will initialize its own.

If 'url' is specified, TracerProvider will have an OTLPTraceExporter using this destination URL.

If true, use a predefined list of filters for well-known platform traces.

If true, the library will use the ContextManager provided by the active OTEL SDK to manage and derive propagation information to ensure spans created across asynchronous operations are properly nested.

Otherwise, use Traces.currentTracingState to set and retrieve propagation info across asynchronous operations manually.

See https://opentelemetry.io/docs/languages/js/propagation/ and https://opentelemetry.io/docs/languages/js/context/#context-manager for more information.

Whether the user journey trace will be enabled. false - User Journey trace is disabled. nested - User Journey trace is enabled and each subsequent span is a child span of the previous one. sibling - User Journey trace is enabled and each subsequent span is a child of the same initial span.