Class SugaredTracer

Tracer provides an interface for creating Spans.

Since

1.0.0

Implements

Constructors

constructor

Properties

startActiveSpan startSpan

Methods

withActiveSpan withSpan

Constructors

constructor

Properties

startActiveSpan

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

Starts a new Span and calls the given function passing it the created span as first argument. Additionally the new span gets set in context and this context is activated for the duration of the function call.

Param: name

The name of the span

Param: options

SpanOptions used for span creation

Param: context

Context to use to extract parent

Param: fn

function called in the context of the span and receives the newly created span as an argument

Returns

return value of fn

Example

const something = tracer.startActiveSpan('op', span => {
      try {
        do some work
        span.setStatus({code: SpanStatusCode.OK});
        return something;
      } catch (err) {
        span.setStatus({
          code: SpanStatusCode.ERROR,
          message: err.message,
        });
        throw err;
      } finally {
        span.end();
      }
    });

Example

const span = tracer.startActiveSpan('op', span => {
      try {
        do some work
        return span;
      } catch (err) {
        span.setStatus({
          code: SpanStatusCode.ERROR,
          message: err.message,
        });
        throw err;
      }
    });
    do some more work
    span.end();

startSpan

startSpan: (name: string, options?: SpanOptions, context?: Context) => Span

Starts a new Span. Start the span without setting it on context.

This method do NOT modify the current Context.

Type declaration

    • (name: string, options?: SpanOptions, context?: Context): Span

    • Parameters

      • name: string

        The name of the span

      • Optionaloptions: SpanOptions

        SpanOptions used for span creation

      • Optionalcontext: Context

        Context to use to extract parent

      Returns Span

      Span The newly created span

Example

const span = tracer.startSpan('op');
    span.setAttribute('key', 'value');
    span.end();

Methods

withActiveSpan

  • withActiveSpan<F extends (span: Span) => ReturnType<F>>(
        name: string,
        fn: F,
    ): ReturnType<F>

    Starts a new Span and calls the given function passing it the created span as first argument. Additionally, the new span gets set in context and this context is activated for the duration of the function call. The span will be closed after the function has executed. If an exception occurs, it is recorded, the status is set to ERROR and the exception is rethrown.

    Type Parameters

    • F extends (span: Span) => ReturnType<F>

    Parameters

    • name: string

      The name of the span

    • fn: F

      function called in the context of the span and receives the newly created span as an argument

    Returns ReturnType<F>

    return value of fn

    Example

    const something = tracer.withActiveSpan('op', span => {
         // do some work
        });

    Example

    const something = await tracer.withActiveSpan('op', span => {
         // do some async work
        });
  • withActiveSpan<F extends (span: Span) => ReturnType<F>>(
        name: string,
        options: SugaredSpanOptions,
        fn: F,
    ): ReturnType<F>

    Starts a new Span and calls the given function passing it the created span as first argument. Additionally, the new span gets set in context and this context is activated for the duration of the function call. The span will be closed after the function has executed. If an exception occurs, it is recorded, the status is set to ERROR and the exception is rethrown.

    Type Parameters

    • F extends (span: Span) => ReturnType<F>

    Parameters

    • name: string

      The name of the span

    • options: SugaredSpanOptions

      SugaredSpanOptions used for span creation

    • fn: F

      function called in the context of the span and receives the newly created span as an argument

    Returns ReturnType<F>

    return value of fn

    Example

    const something = tracer.withActiveSpan('op', span => {
         // do some work
        });

    Example

    const something = await tracer.withActiveSpan('op', span => {
         // do some async work
        });
  • withActiveSpan<F extends (span: Span) => ReturnType<F>>(
        name: string,
        options: SugaredSpanOptions,
        context: Context,
        fn: F,
    ): ReturnType<F>

    Starts a new Span and calls the given function passing it the created span as first argument. Additionally, the new span gets set in context and this context is activated for the duration of the function call. The span will be closed after the function has executed. If an exception occurs, it is recorded, the status is set to ERROR and the exception is rethrown.

    Type Parameters

    • F extends (span: Span) => ReturnType<F>

    Parameters

    • name: string

      The name of the span

    • options: SugaredSpanOptions

      SugaredSpanOptions used for span creation

    • context: Context

      Context to use to extract parent

    • fn: F

      function called in the context of the span and receives the newly created span as an argument

    Returns ReturnType<F>

    return value of fn

    Example

    const something = tracer.withActiveSpan('op', span => {
         // do some work
        });

    Example

    const something = await tracer.withActiveSpan('op', span => {
         // do some async work
        });

withSpan

  • withSpan<F extends (span: Span) => ReturnType<F>>(
        name: string,
        fn: F,
    ): ReturnType<F>

    Starts a new Span and ends it after execution of fn without setting it on context. The span will be closed after the function has executed. If an exception occurs, it is recorded, the status is et to ERROR and rethrown.

    This method does NOT modify the current Context.

    Type Parameters

    • F extends (span: Span) => ReturnType<F>

    Parameters

    • name: string

      The name of the span

    • fn: F

      function called in the context of the span and receives the newly created span as an argument

    Returns ReturnType<F>

    Span The newly created span

    Example

    const something = tracer.withSpan('op', span => {
         // do some work
        });

    Example

    const something = await tracer.withSpan('op', span => {
         // do some async work
        });
  • withSpan<F extends (span: Span) => ReturnType<F>>(
        name: string,
        options: SugaredSpanOptions,
        fn: F,
    ): ReturnType<F>

    Starts a new Span and ends it after execution of fn without setting it on context. The span will be closed after the function has executed. If an exception occurs, it is recorded, the status is et to ERROR and rethrown.

    This method does NOT modify the current Context.

    Type Parameters

    • F extends (span: Span) => ReturnType<F>

    Parameters

    • name: string

      The name of the span

    • options: SugaredSpanOptions

      SugaredSpanOptions used for span creation

    • fn: F

      function called in the context of the span and receives the newly created span as an argument

    Returns ReturnType<F>

    Span The newly created span

    Example

    const something = tracer.withSpan('op', span => {
         // do some work
        });

    Example

    const something = await tracer.withSpan('op', span => {
         // do some async work
        });
  • withSpan<F extends (span: Span) => ReturnType<F>>(
        name: string,
        options: SugaredSpanOptions,
        context: Context,
        fn: F,
    ): ReturnType<F>

    Starts a new Span and ends it after execution of fn without setting it on context. The span will be closed after the function has executed. If an exception occurs, it is recorded, the status is et to ERROR and rethrown.

    This method does NOT modify the current Context.

    Type Parameters

    • F extends (span: Span) => ReturnType<F>

    Parameters

    • name: string

      The name of the span

    • options: SugaredSpanOptions

      SugaredSpanOptions used for span creation

    • context: Context

      Context to use to extract parent

    • fn: F

      function called in the context of the span and receives the newly created span as an argument

    Returns ReturnType<F>

    Span The newly created span

    Example

    const something = tracer.withSpan('op', span => {
         // do some work
        });

    Example

    const something = await tracer.withSpan('op', span => {
         // do some async work
        });
  • withSpan<F extends (span: Span) => ReturnType<F>>(
        name: string,
        options: SugaredSpanOptions,
        context: Context,
        fn: F,
    ): ReturnType<F>

    Starts a new Span and ends it after execution of fn without setting it on context. The span will be closed after the function has executed. If an exception occurs, it is recorded, the status is et to ERROR and rethrown.

    This method does NOT modify the current Context.

    Type Parameters

    • F extends (span: Span) => ReturnType<F>

    Parameters

    • name: string

      The name of the span

    • options: SugaredSpanOptions

      SugaredSpanOptions used for span creation

    • context: Context

      Context to use to extract parent

    • fn: F

      function called in the context of the span and receives the newly created span as an argument

    Returns ReturnType<F>

    Span The newly created span

    Example

    const something = tracer.withSpan('op', span => {
         // do some work
        });

    Example

    const something = await tracer.withSpan('op', span => {
         // do some async work
        });

Settings

Member Visibility

On This Page

Constructors
Properties
Methods