@launchdarkly/observability + @launchdarkly/session-replay
    Preparing search index...

    Interface Observe

    interface Observe {
        recordCount: (metric: OTelMetric) => void;
        recordError: (
            error: Error,
            message?: string,
            payload?: { [key: string]: string },
            source?: string,
            type?: ErrorMessageType,
        ) => void;
        recordGauge: (metric: OTelMetric) => void;
        recordHistogram: (metric: OTelMetric) => void;
        recordIncr: (metric: Omit<OTelMetric, "value">) => void;
        recordLog: (
            message: any,
            level:
                | "error"
                | "assert"
                | "count"
                | "countReset"
                | "debug"
                | "dir"
                | "dirxml"
                | "group"
                | "groupCollapsed"
                | "groupEnd"
                | "info"
                | "log"
                | "table"
                | "time"
                | "timeEnd"
                | "timeLog"
                | "trace"
                | "warn",
            metadata?: Attributes,
        ) => void;
        recordUpDownCounter: (metric: OTelMetric) => void;
        startManualSpan: {
            <F extends (span: Span) => ReturnType<F>>(
                name: string,
                fn: F,
            ): ReturnType<F>;
            <F extends (span: Span) => ReturnType<F>>(
                name: string,
                options: SpanOptions,
                fn: F,
            ): ReturnType<F>;
            <F extends (span: Span) => ReturnType<F>>(
                name: string,
                options: SpanOptions,
                context: Context,
                fn: F,
            ): ReturnType<F>;
        };
        startSpan: {
            <F extends (span?: Span) => ReturnType<F>>(
                name: string,
                fn: F,
            ): ReturnType<F>;
            <F extends (span?: Span) => ReturnType<F>>(
                name: string,
                options: SpanOptions,
                fn: F,
            ): ReturnType<F>;
            <F extends (span?: Span) => ReturnType<F>>(
                name: string,
                options: SpanOptions,
                context: Context,
                fn: F,
            ): ReturnType<F>;
        };
        getHooks(metadata: LDPluginEnvironmentMetadata): Hook[];
        register(
            client: LDClientMin,
            environmentMetadata: LDPluginEnvironmentMetadata,
        ): void;
    }
    Index

    Properties

    recordCount recordError recordGauge recordHistogram recordIncr recordLog recordUpDownCounter startManualSpan startSpan

    Methods

    getHooks? register

    Properties

    recordCount: (metric: OTelMetric) => void

    Record arbitrary metric values via as a Counter. A Counter efficiently records an increment in a metric, such as number of cache hits. Values with the same metric name and attributes are aggregated via the OTel SDK. See https://opentelemetry.io/docs/specs/otel/metrics/data-model/ for more details.

    recordError: (
        error: Error,
        message?: string,
        payload?: { [key: string]: string },
        source?: string,
        type?: ErrorMessageType,
    ) => void

    Calling this method will report an error in Highlight and map it to the current session being recorded. A common use case for H.error is calling it right outside of an error boundary.

    https://docs.highlight.run/grouping-errors for more information.

    recordGauge: (metric: OTelMetric) => void

    Record arbitrary metric values via as a Gauge. A Gauge records any point-in-time measurement, such as the current CPU utilization %. Values with the same metric name and attributes are aggregated via the OTel SDK. See https://opentelemetry.io/docs/specs/otel/metrics/data-model/ for more details.

    recordHistogram: (metric: OTelMetric) => void

    Record arbitrary metric values via as a Histogram. A Histogram efficiently records near-by point-in-time measurement into a bucketed aggregate. Values with the same metric name and attributes are aggregated via the OTel SDK. See https://opentelemetry.io/docs/specs/otel/metrics/data-model/ for more details.

    recordIncr: (metric: Omit<OTelMetric, "value">) => void

    Record arbitrary metric values via as a Counter. A Counter efficiently records an increment in a metric, such as number of cache hits. Values with the same metric name and attributes are aggregated via the OTel SDK. See https://opentelemetry.io/docs/specs/otel/metrics/data-model/ for more details.

    recordLog: (
        message: any,
        level:
            | "error"
            | "assert"
            | "count"
            | "countReset"
            | "debug"
            | "dir"
            | "dirxml"
            | "group"
            | "groupCollapsed"
            | "groupEnd"
            | "info"
            | "log"
            | "table"
            | "time"
            | "timeEnd"
            | "timeLog"
            | "trace"
            | "warn",
        metadata?: Attributes,
    ) => void
    recordUpDownCounter: (metric: OTelMetric) => void

    Record arbitrary metric values via as a UpDownCounter. A UpDownCounter efficiently records an increment or decrement in a metric, such as number of paying customers. Values with the same metric name and attributes are aggregated via the OTel SDK. See https://opentelemetry.io/docs/specs/otel/metrics/data-model/ for more details.

    startManualSpan: {
        <F extends (span: Span) => ReturnType<F>>(
            name: string,
            fn: F,
        ): ReturnType<F>;
        <F extends (span: Span) => ReturnType<F>>(
            name: string,
            options: SpanOptions,
            fn: F,
        ): ReturnType<F>;
        <F extends (span: Span) => ReturnType<F>>(
            name: string,
            options: SpanOptions,
            context: Context,
            fn: F,
        ): ReturnType<F>;
    }

    Starts a new span for tracing in Highlight. The span will be ended when the end() is called on the span. It returns whatever is returned from the callback function.

    H.startManualSpan('span-name', options, (span) => {
      span.addEvent('event-name', { key: 'value' })
      span.setAttribute('key', 'value')
      await someAsyncFunction()
      span.end()
    })

    const span = H.startManualSpan('span-name', (s) => s)
    span.addEvent('event-name', { key: 'value' })
    await someAsyncFunction()
    span.end()

    The name of the span.

    Options for the span.

    The context for the span.

    The function to run in the span.

    startSpan: {
        <F extends (span?: Span) => ReturnType<F>>(
            name: string,
            fn: F,
        ): ReturnType<F>;
        <F extends (span?: Span) => ReturnType<F>>(
            name: string,
            options: SpanOptions,
            fn: F,
        ): ReturnType<F>;
        <F extends (span?: Span) => ReturnType<F>>(
            name: string,
            options: SpanOptions,
            context: Context,
            fn: F,
        ): ReturnType<F>;
    }

    Starts a new span for tracing in Highlight. The span will be ended when the callback function returns.

    H.startSpan('span-name', callbackFn)

    H.startSpan('span-name', options, callbackFn)

    H.startSpan('span-name', options, context, callbackFn)

    H.startSpan('span-name', async (span) => {
      span.setAttribute('key', 'value')
      await someAsyncFunction()
    })

    The name of the span.

    Options for the span.

    The context for the span.

    The function to run in the span.

    Methods

    • Parameters

      • metadata: LDPluginEnvironmentMetadata

      Returns Hook[]

    • Parameters

      • client: LDClientMin
      • environmentMetadata: LDPluginEnvironmentMetadata

      Returns void

    Settings

    Member Visibility

    On This Page

    Properties
    Methods