@relaybus/otel 0.0.0-stage → 0.0.0

package/dist/index.d.cts

@@ -0,0 +1,79 @@
+import { MeterProvider, TracerProvider, TextMapPropagator, Context, TextMapSetter, TextMapGetter } from '@opentelemetry/api';
+import { RelayBusObserver, RelayBusTracer } from '@relaybus/core';
+
+interface RelayBusOpenTelemetryOptions {
+    /** Default: the global meter provider (`metrics.getMeterProvider()`). */
+    readonly meterProvider?: MeterProvider;
+    /** Default: the global tracer provider (`trace.getTracerProvider()`). */
+    readonly tracerProvider?: TracerProvider;
+    /**
+     * Writes and reads the trace context of events. Default: W3C Trace Context (`traceparent`,
+     * `tracestate`). Pass `propagation` from `@opentelemetry/api` to use the SDK's global one.
+     */
+    readonly propagator?: TextMapPropagator;
+}
+/** What `relayBusOpenTelemetry` returns: pass both to the bus. */
+interface RelayBusOpenTelemetry {
+    /** Metrics; add it to `observers`. */
+    readonly observer: RelayBusObserver;
+    /** Spans and trace propagation; pass it as `tracer`. */
+    readonly tracer: RelayBusTracer;
+}
+/**
+ * OpenTelemetry metrics and traces for a relaybus.
+ *
+ * ```ts
+ * const otel = relayBusOpenTelemetry();
+ * const bus = new RelayBus({ store, observers: [otel.observer], tracer: otel.tracer, backlogInterval: '30s' });
+ * ```
+ */
+declare function relayBusOpenTelemetry(options?: RelayBusOpenTelemetryOptions): RelayBusOpenTelemetry;
+
+/** OpenTelemetry semantic convention attributes for messaging, and relaybus's own. */
+declare const ATTRIBUTES: {
+    readonly system: "messaging.system";
+    readonly destination: "messaging.destination.name";
+    readonly operationName: "messaging.operation.name";
+    readonly operationType: "messaging.operation.type";
+    readonly consumerGroup: "messaging.consumer.group.name";
+    readonly messageId: "messaging.message.id";
+    readonly conversationId: "messaging.message.conversation_id";
+    readonly batchCount: "messaging.batch.message_count";
+    readonly errorType: "error.type";
+    readonly eventType: "relaybus.event.type";
+    readonly deliveryKind: "relaybus.delivery.kind";
+    readonly deliveryAttempt: "relaybus.delivery.attempt";
+    readonly receiveOutcome: "relaybus.receive.outcome";
+    readonly failureStage: "relaybus.failure.stage";
+};
+/** Metric names: the messaging semantic conventions where they exist, else `relaybus.*`. */
+declare const METRICS: {
+    readonly operationDuration: "messaging.client.operation.duration";
+    readonly sentMessages: "messaging.client.sent.messages";
+    readonly consumedMessages: "messaging.client.consumed.messages";
+    readonly processDuration: "messaging.process.duration";
+    readonly invalidMessages: "relaybus.messages.invalid";
+    readonly published: "relaybus.events.published";
+    readonly claimedDeliveries: "relaybus.claim.deliveries";
+    readonly claimedLanes: "relaybus.claim.lanes";
+    readonly pending: "relaybus.deliveries.pending";
+    readonly oldestAge: "relaybus.deliveries.oldest_age";
+    readonly deadLettered: "relaybus.deliveries.dead_lettered";
+    readonly retried: "relaybus.deliveries.retried";
+    readonly leaseLost: "relaybus.lease.lost";
+    readonly endToEndLatency: "relaybus.end_to_end.latency";
+    readonly failures: "relaybus.failures";
+};
+
+/**
+ * The W3C Trace Context propagator (`traceparent`, `tracestate`), so relaybus propagates traces
+ * without `@opentelemetry/core`. Pass another one, such as the global `propagation`, as the
+ * `propagator` option of `relayBusOpenTelemetry` to use what the SDK configured.
+ */
+declare class W3CTraceContextPropagator implements TextMapPropagator {
+    inject(context: Context, carrier: unknown, setter: TextMapSetter): void;
+    extract(context: Context, carrier: unknown, getter: TextMapGetter): Context;
+    fields(): string[];
+}
+
+export { ATTRIBUTES, METRICS, type RelayBusOpenTelemetry, type RelayBusOpenTelemetryOptions, W3CTraceContextPropagator, relayBusOpenTelemetry };

package/dist/index.d.ts

@@ -0,0 +1,79 @@
+import { MeterProvider, TracerProvider, TextMapPropagator, Context, TextMapSetter, TextMapGetter } from '@opentelemetry/api';
+import { RelayBusObserver, RelayBusTracer } from '@relaybus/core';
+
+interface RelayBusOpenTelemetryOptions {
+    /** Default: the global meter provider (`metrics.getMeterProvider()`). */
+    readonly meterProvider?: MeterProvider;
+    /** Default: the global tracer provider (`trace.getTracerProvider()`). */
+    readonly tracerProvider?: TracerProvider;
+    /**
+     * Writes and reads the trace context of events. Default: W3C Trace Context (`traceparent`,
+     * `tracestate`). Pass `propagation` from `@opentelemetry/api` to use the SDK's global one.
+     */
+    readonly propagator?: TextMapPropagator;
+}
+/** What `relayBusOpenTelemetry` returns: pass both to the bus. */
+interface RelayBusOpenTelemetry {
+    /** Metrics; add it to `observers`. */
+    readonly observer: RelayBusObserver;
+    /** Spans and trace propagation; pass it as `tracer`. */
+    readonly tracer: RelayBusTracer;
+}
+/**
+ * OpenTelemetry metrics and traces for a relaybus.
+ *
+ * ```ts
+ * const otel = relayBusOpenTelemetry();
+ * const bus = new RelayBus({ store, observers: [otel.observer], tracer: otel.tracer, backlogInterval: '30s' });
+ * ```
+ */
+declare function relayBusOpenTelemetry(options?: RelayBusOpenTelemetryOptions): RelayBusOpenTelemetry;
+
+/** OpenTelemetry semantic convention attributes for messaging, and relaybus's own. */
+declare const ATTRIBUTES: {
+    readonly system: "messaging.system";
+    readonly destination: "messaging.destination.name";
+    readonly operationName: "messaging.operation.name";
+    readonly operationType: "messaging.operation.type";
+    readonly consumerGroup: "messaging.consumer.group.name";
+    readonly messageId: "messaging.message.id";
+    readonly conversationId: "messaging.message.conversation_id";
+    readonly batchCount: "messaging.batch.message_count";
+    readonly errorType: "error.type";
+    readonly eventType: "relaybus.event.type";
+    readonly deliveryKind: "relaybus.delivery.kind";
+    readonly deliveryAttempt: "relaybus.delivery.attempt";
+    readonly receiveOutcome: "relaybus.receive.outcome";
+    readonly failureStage: "relaybus.failure.stage";
+};
+/** Metric names: the messaging semantic conventions where they exist, else `relaybus.*`. */
+declare const METRICS: {
+    readonly operationDuration: "messaging.client.operation.duration";
+    readonly sentMessages: "messaging.client.sent.messages";
+    readonly consumedMessages: "messaging.client.consumed.messages";
+    readonly processDuration: "messaging.process.duration";
+    readonly invalidMessages: "relaybus.messages.invalid";
+    readonly published: "relaybus.events.published";
+    readonly claimedDeliveries: "relaybus.claim.deliveries";
+    readonly claimedLanes: "relaybus.claim.lanes";
+    readonly pending: "relaybus.deliveries.pending";
+    readonly oldestAge: "relaybus.deliveries.oldest_age";
+    readonly deadLettered: "relaybus.deliveries.dead_lettered";
+    readonly retried: "relaybus.deliveries.retried";
+    readonly leaseLost: "relaybus.lease.lost";
+    readonly endToEndLatency: "relaybus.end_to_end.latency";
+    readonly failures: "relaybus.failures";
+};
+
+/**
+ * The W3C Trace Context propagator (`traceparent`, `tracestate`), so relaybus propagates traces
+ * without `@opentelemetry/core`. Pass another one, such as the global `propagation`, as the
+ * `propagator` option of `relayBusOpenTelemetry` to use what the SDK configured.
+ */
+declare class W3CTraceContextPropagator implements TextMapPropagator {
+    inject(context: Context, carrier: unknown, setter: TextMapSetter): void;
+    extract(context: Context, carrier: unknown, getter: TextMapGetter): Context;
+    fields(): string[];
+}
+
+export { ATTRIBUTES, METRICS, type RelayBusOpenTelemetry, type RelayBusOpenTelemetryOptions, W3CTraceContextPropagator, relayBusOpenTelemetry };

package/dist/index.js

@@ -0,0 +1,472 @@
+import { trace, isSpanContextValid, createTraceState, metrics, SpanKind, context, defaultTextMapGetter, defaultTextMapSetter, SpanStatusCode } from '@opentelemetry/api';
+import { TRACEPARENT_HEADER, TRACESTATE_HEADER, traceContextOf, toErrorInfo } from '@relaybus/core';
+
+// src/relay-bus-open-telemetry.ts
+
+// src/semantic-conventions.ts
+var INSTRUMENTATION_SCOPE = "@relaybus/otel";
+var RELAYBUS_SYSTEM = "relaybus";
+var ATTRIBUTES = {
+  system: "messaging.system",
+  destination: "messaging.destination.name",
+  operationName: "messaging.operation.name",
+  operationType: "messaging.operation.type",
+  consumerGroup: "messaging.consumer.group.name",
+  messageId: "messaging.message.id",
+  conversationId: "messaging.message.conversation_id",
+  batchCount: "messaging.batch.message_count",
+  errorType: "error.type",
+  eventType: "relaybus.event.type",
+  deliveryKind: "relaybus.delivery.kind",
+  deliveryAttempt: "relaybus.delivery.attempt",
+  receiveOutcome: "relaybus.receive.outcome",
+  failureStage: "relaybus.failure.stage"
+};
+var METRICS = {
+  operationDuration: "messaging.client.operation.duration",
+  sentMessages: "messaging.client.sent.messages",
+  consumedMessages: "messaging.client.consumed.messages",
+  processDuration: "messaging.process.duration",
+  invalidMessages: "relaybus.messages.invalid",
+  published: "relaybus.events.published",
+  claimedDeliveries: "relaybus.claim.deliveries",
+  claimedLanes: "relaybus.claim.lanes",
+  pending: "relaybus.deliveries.pending",
+  oldestAge: "relaybus.deliveries.oldest_age",
+  deadLettered: "relaybus.deliveries.dead_lettered",
+  retried: "relaybus.deliveries.retried",
+  leaseLost: "relaybus.lease.lost",
+  endToEndLatency: "relaybus.end_to_end.latency",
+  failures: "relaybus.failures"
+};
+function errorType(error) {
+  return error.code ?? error.name;
+}
+
+// src/relay-bus-metrics-observer.ts
+var MILLISECONDS_PER_SECOND = 1e3;
+var DURATION_BUCKETS = [
+  5e-3,
+  0.01,
+  0.025,
+  0.05,
+  0.075,
+  0.1,
+  0.25,
+  0.5,
+  0.75,
+  1,
+  2.5,
+  5,
+  7.5,
+  10
+];
+var LATENCY_BUCKETS = [
+  5e-3,
+  0.01,
+  0.025,
+  0.05,
+  0.1,
+  0.25,
+  0.5,
+  1,
+  2.5,
+  5,
+  10,
+  30,
+  60,
+  300,
+  900,
+  3600
+];
+var COUNT_BUCKETS = [1, 2, 5, 10, 20, 50, 100, 200, 500, 1e3];
+function seconds(milliseconds) {
+  return milliseconds / MILLISECONDS_PER_SECOND;
+}
+function withError(attributes, error) {
+  return error === void 0 ? attributes : { ...attributes, [ATTRIBUTES.errorType]: errorType(error) };
+}
+function deliveryAttributes(delivery) {
+  return {
+    [ATTRIBUTES.system]: RELAYBUS_SYSTEM,
+    [ATTRIBUTES.destination]: delivery.event.type,
+    [ATTRIBUTES.consumerGroup]: delivery.handler
+  };
+}
+function createHistograms(meter) {
+  const histogram = (name, options) => meter.createHistogram(name, {
+    unit: options.unit,
+    description: options.description,
+    advice: { explicitBucketBoundaries: options.buckets }
+  });
+  return {
+    operationDuration: histogram(METRICS.operationDuration, {
+      unit: "s",
+      description: "Duration of publish, claim, send and receive operations.",
+      buckets: DURATION_BUCKETS
+    }),
+    processDuration: histogram(METRICS.processDuration, {
+      unit: "s",
+      description: "Duration of local handler runs.",
+      buckets: DURATION_BUCKETS
+    }),
+    claimedDeliveries: histogram(METRICS.claimedDeliveries, {
+      unit: "{delivery}",
+      description: "Deliveries one claim query returned.",
+      buckets: COUNT_BUCKETS
+    }),
+    claimedLanes: histogram(METRICS.claimedLanes, {
+      unit: "{lane}",
+      description: "Distinct leases (lanes) among the deliveries of one claim.",
+      buckets: COUNT_BUCKETS
+    }),
+    endToEndLatency: histogram(METRICS.endToEndLatency, {
+      unit: "s",
+      description: "Time from an event occurring to a handler or route starting on it.",
+      buckets: LATENCY_BUCKETS
+    })
+  };
+}
+function createInstruments(meter) {
+  const counter = (name, [unit, description]) => meter.createCounter(name, { unit, description });
+  return {
+    ...createHistograms(meter),
+    sentMessages: counter(METRICS.sentMessages, [
+      "{message}",
+      "Events a route attempted to send to a broker."
+    ]),
+    consumedMessages: counter(METRICS.consumedMessages, [
+      "{message}",
+      "Events received from a broker, by what receive did with them."
+    ]),
+    invalidMessages: counter(METRICS.invalidMessages, [
+      "{message}",
+      "Inbound messages a transport could not decode, so they never reached the bus."
+    ]),
+    published: counter(METRICS.published, ["{event}", "Events passed to publish."]),
+    deadLettered: counter(METRICS.deadLettered, ["{delivery}", "Deliveries moved to dead."]),
+    retried: counter(METRICS.retried, ["{delivery}", "Failed attempts rescheduled for a retry."]),
+    leaseLost: counter(METRICS.leaseLost, [
+      "{delivery}",
+      "Deliveries whose lease was lost while they ran."
+    ]),
+    failures: counter(METRICS.failures, [
+      "{failure}",
+      "Errors relaybus caught and reported, by stage."
+    ])
+  };
+}
+var RelayBusMetricsObserver = class {
+  #instruments;
+  #backlog;
+  constructor(meter) {
+    this.#instruments = createInstruments(meter);
+    meter.createObservableGauge(METRICS.pending, {
+      unit: "{delivery}",
+      description: "Deliveries waiting to run, at the last backlog reading."
+    }).addCallback((result) => {
+      if (this.#backlog !== void 0) {
+        result.observe(this.#backlog.pending);
+      }
+    });
+    meter.createObservableGauge(METRICS.oldestAge, {
+      unit: "s",
+      description: "How long the oldest due delivery had waited, at the last backlog reading."
+    }).addCallback((result) => {
+      if (this.#backlog !== void 0) {
+        result.observe(seconds(this.#backlog.oldestPendingAgeMs));
+      }
+    });
+  }
+  onPublishFinished(event) {
+    const types = new Set(event.eventTypes);
+    const base = {
+      [ATTRIBUTES.system]: RELAYBUS_SYSTEM,
+      [ATTRIBUTES.operationName]: "publish",
+      [ATTRIBUTES.operationType]: "create"
+    };
+    const [onlyType] = types;
+    this.#instruments.operationDuration.record(
+      seconds(event.durationMs),
+      withError(
+        types.size === 1 ? { ...base, [ATTRIBUTES.destination]: onlyType } : base,
+        event.error
+      )
+    );
+    for (const type of event.eventTypes) {
+      this.#instruments.published.add(
+        1,
+        withError(
+          { [ATTRIBUTES.system]: RELAYBUS_SYSTEM, [ATTRIBUTES.destination]: type },
+          event.error
+        )
+      );
+    }
+  }
+  onClaimFinished(event) {
+    const attributes = {
+      [ATTRIBUTES.system]: RELAYBUS_SYSTEM,
+      [ATTRIBUTES.operationName]: "claim",
+      [ATTRIBUTES.operationType]: "receive"
+    };
+    this.#instruments.operationDuration.record(
+      seconds(event.durationMs),
+      withError(attributes, event.error)
+    );
+    if (event.outcome === "success") {
+      this.#instruments.claimedDeliveries.record(event.claimed, attributes);
+      this.#instruments.claimedLanes.record(event.lanes, attributes);
+    }
+  }
+  onHandlerStarted(event) {
+    this.#instruments.endToEndLatency.record(seconds(event.endToEndLatencyMs), {
+      ...deliveryAttributes(event.delivery),
+      [ATTRIBUTES.deliveryKind]: event.kind
+    });
+  }
+  onHandlerFinished(event) {
+    if (event.kind === "handler") {
+      this.#instruments.processDuration.record(
+        seconds(event.durationMs),
+        withError(
+          {
+            ...deliveryAttributes(event.delivery),
+            [ATTRIBUTES.operationName]: "process",
+            [ATTRIBUTES.operationType]: "process"
+          },
+          event.error
+        )
+      );
+    }
+  }
+  onTransportSent(event) {
+    const attributes = withError(
+      {
+        [ATTRIBUTES.system]: event.system,
+        [ATTRIBUTES.destination]: event.destination,
+        [ATTRIBUTES.operationName]: "send",
+        [ATTRIBUTES.operationType]: "send"
+      },
+      event.error
+    );
+    this.#instruments.sentMessages.add(1, attributes);
+    this.#instruments.operationDuration.record(seconds(event.durationMs), attributes);
+  }
+  onReceiveFinished(event) {
+    const attributes = withError(
+      {
+        [ATTRIBUTES.system]: event.system ?? RELAYBUS_SYSTEM,
+        [ATTRIBUTES.operationName]: "receive",
+        [ATTRIBUTES.operationType]: "receive",
+        ...event.destination === void 0 ? {} : { [ATTRIBUTES.destination]: event.destination }
+      },
+      event.error
+    );
+    this.#instruments.consumedMessages.add(1, {
+      ...attributes,
+      [ATTRIBUTES.receiveOutcome]: event.outcome
+    });
+    this.#instruments.operationDuration.record(seconds(event.durationMs), attributes);
+  }
+  onInvalidMessage(event) {
+    this.#instruments.invalidMessages.add(
+      1,
+      withError(
+        { [ATTRIBUTES.system]: event.system, [ATTRIBUTES.destination]: event.destination },
+        event.error
+      )
+    );
+  }
+  onDeliveryRetryScheduled(event) {
+    this.#instruments.retried.add(1, withError(deliveryAttributes(event.delivery), event.error));
+  }
+  onDeliveryDead(event) {
+    this.#instruments.deadLettered.add(
+      1,
+      withError(deliveryAttributes(event.delivery), event.error)
+    );
+  }
+  onLeaseLost(event) {
+    this.#instruments.leaseLost.add(1, deliveryAttributes(event.delivery));
+  }
+  onBacklog(event) {
+    this.#backlog = event;
+  }
+  onFailure(event) {
+    this.#instruments.failures.add(
+      1,
+      withError({ [ATTRIBUTES.failureStage]: event.stage }, event.error)
+    );
+  }
+};
+async function endWhenSettled(span, work) {
+  try {
+    return await work;
+  } catch (error) {
+    const info = toErrorInfo(error);
+    span.recordException(error instanceof Error ? error : info.message);
+    span.setAttribute(ATTRIBUTES.errorType, errorType(info));
+    span.setStatus({ code: SpanStatusCode.ERROR, message: info.message });
+    throw error;
+  } finally {
+    span.end();
+  }
+}
+var RelayBusOpenTelemetryTracer = class {
+  #tracer;
+  #propagator;
+  constructor({ tracer, propagator }) {
+    this.#tracer = tracer;
+    this.#propagator = propagator;
+  }
+  /** A producer span, child of the caller's active span; its context goes into every event. */
+  publish(input, run) {
+    const types = [...new Set(input.eventTypes)];
+    const attributes = {
+      [ATTRIBUTES.system]: RELAYBUS_SYSTEM,
+      [ATTRIBUTES.operationName]: "publish",
+      [ATTRIBUTES.operationType]: "create",
+      ...types.length === 1 ? { [ATTRIBUTES.destination]: types[0] } : {},
+      ...input.eventTypes.length > 1 ? { [ATTRIBUTES.batchCount]: input.eventTypes.length } : {}
+    };
+    const name = types.length === 1 ? `publish ${types[0]}` : "publish";
+    return this.#runInSpan(
+      { name, kind: SpanKind.PRODUCER, attributes, parent: context.active() },
+      run
+    );
+  }
+  /**
+   * A producer span, child of the publish span whose context the stored event carries (and linked
+   * to it); the event goes to the broker with this span's context.
+   */
+  send(input, run) {
+    const { envelope } = input;
+    const parent = this.#extract(envelope.headers);
+    const published = trace.getSpanContext(parent);
+    const attributes = {
+      [ATTRIBUTES.system]: input.system,
+      [ATTRIBUTES.destination]: input.destination,
+      [ATTRIBUTES.operationName]: "send",
+      [ATTRIBUTES.operationType]: "send",
+      [ATTRIBUTES.messageId]: envelope.id,
+      [ATTRIBUTES.eventType]: envelope.type,
+      ...envelope.correlationId === null ? {} : { [ATTRIBUTES.conversationId]: envelope.correlationId }
+    };
+    return this.#runInSpan(
+      {
+        name: `send ${input.destination}`,
+        kind: SpanKind.PRODUCER,
+        attributes,
+        parent,
+        ...published === void 0 ? {} : { links: [{ context: published }] }
+      },
+      run
+    );
+  }
+  /** A consumer span, child of the trace context the event arrived with, active while the handler runs. */
+  process(input, run) {
+    const { delivery } = input;
+    const parent = this.#extract(delivery.event.headers);
+    const span = this.#tracer.startSpan(
+      `process ${delivery.event.type}`,
+      {
+        kind: SpanKind.CONSUMER,
+        attributes: {
+          [ATTRIBUTES.system]: RELAYBUS_SYSTEM,
+          [ATTRIBUTES.destination]: delivery.event.type,
+          [ATTRIBUTES.operationName]: "process",
+          [ATTRIBUTES.operationType]: "process",
+          [ATTRIBUTES.consumerGroup]: delivery.handler,
+          [ATTRIBUTES.messageId]: delivery.event.id,
+          [ATTRIBUTES.deliveryAttempt]: delivery.attempt
+        }
+      },
+      parent
+    );
+    return endWhenSettled(span, context.with(trace.setSpan(parent, span), run));
+  }
+  #extract(headers) {
+    return this.#propagator.extract(context.active(), headers, defaultTextMapGetter);
+  }
+  #runInSpan(span, run) {
+    const started = this.#tracer.startSpan(
+      span.name,
+      {
+        kind: span.kind,
+        attributes: span.attributes,
+        ...span.links === void 0 ? {} : { links: span.links }
+      },
+      span.parent
+    );
+    const active = trace.setSpan(span.parent, started);
+    const headers = {};
+    this.#propagator.inject(active, headers, defaultTextMapSetter);
+    return endWhenSettled(
+      started,
+      context.with(active, () => run(headers))
+    );
+  }
+};
+var HEX = 16;
+var FLAGS_DIGITS = 2;
+var DEFINED_FLAGS = 255;
+function firstValue(value) {
+  return Array.isArray(value) ? value[0] : value;
+}
+var W3CTraceContextPropagator = class {
+  // eslint-disable-next-line relaybus/max-two-params -- TextMapPropagator.inject signature
+  inject(context2, carrier, setter) {
+    const spanContext = trace.getSpanContext(context2);
+    if (spanContext === void 0 || !isSpanContextValid(spanContext)) {
+      return;
+    }
+    const flags = (spanContext.traceFlags & DEFINED_FLAGS).toString(HEX).padStart(FLAGS_DIGITS, "0");
+    setter.set(
+      carrier,
+      TRACEPARENT_HEADER,
+      `00-${spanContext.traceId}-${spanContext.spanId}-${flags}`
+    );
+    const traceState = spanContext.traceState?.serialize();
+    if (traceState !== void 0 && traceState.length > 0) {
+      setter.set(carrier, TRACESTATE_HEADER, traceState);
+    }
+  }
+  // eslint-disable-next-line relaybus/max-two-params -- TextMapPropagator.extract signature
+  extract(context2, carrier, getter) {
+    const traceparent = firstValue(getter.get(carrier, TRACEPARENT_HEADER));
+    const tracestate = firstValue(getter.get(carrier, TRACESTATE_HEADER));
+    const traceContext = traceparent === void 0 ? void 0 : traceContextOf(tracestate === void 0 ? { traceparent } : { traceparent, tracestate });
+    if (traceContext === void 0) {
+      return context2;
+    }
+    const [, traceId, spanId, flags] = traceContext.traceparent.split("-");
+    const spanContext = {
+      traceId,
+      spanId,
+      traceFlags: Number.parseInt(flags, HEX),
+      isRemote: true,
+      ...traceContext.tracestate === void 0 ? {} : { traceState: createTraceState(traceContext.tracestate) }
+    };
+    return trace.setSpanContext(context2, spanContext);
+  }
+  fields() {
+    return [TRACEPARENT_HEADER, TRACESTATE_HEADER];
+  }
+};
+
+// src/relay-bus-open-telemetry.ts
+function relayBusOpenTelemetry(options = {}) {
+  const meterProvider = options.meterProvider ?? metrics.getMeterProvider();
+  const tracerProvider = options.tracerProvider ?? trace.getTracerProvider();
+  return {
+    observer: new RelayBusMetricsObserver(meterProvider.getMeter(INSTRUMENTATION_SCOPE)),
+    tracer: new RelayBusOpenTelemetryTracer({
+      tracer: tracerProvider.getTracer(INSTRUMENTATION_SCOPE),
+      propagator: options.propagator ?? new W3CTraceContextPropagator()
+    })
+  };
+}
+
+export { ATTRIBUTES, METRICS, W3CTraceContextPropagator, relayBusOpenTelemetry };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map