@logbrew/sdk 0.1.38 → 0.1.39

package/types/issues.d.ts

@@ -0,0 +1,249 @@
+import type { Metadata, SeverityInput, TelemetryContext } from "./telemetry.js";
+import type { LogBrewClient } from "./client.js";
+import type { LogCorrelationTraceContext } from "./trace-context.js";
+
+/** Privacy-bounded generated JavaScript frame attached to an issue. */
+type IssueStackFrame = {
+  /** Query-free generated filename or URL with local absolute prefixes removed. */
+  filename: string;
+  /** One-based generated source line. */
+  line: number;
+  /** One-based generated source column. */
+  column: number;
+  /** Optional bounded function or method identity. */
+  function?: string;
+  /** Optional bounded module, package, or namespace identity. */
+  module?: string;
+  /** Whether application code classified this frame as app-owned. */
+  inApp?: boolean;
+  /** Optional release-artifact Debug ID matched to this generated file. */
+  debugId?: string;
+};
+
+/** Runtime path that captured an exception and whether it escaped that path. */
+type IssueExceptionMechanism = {
+  /** Stable low-cardinality capture mechanism, such as `react.error_boundary`. */
+  type: string;
+  /** False when the exception escaped the capture boundary. */
+  handled: boolean;
+};
+
+/** Structured exception identity attached to an issue. */
+type IssueException = {
+  /** Bounded runtime exception class or error type. */
+  type: string;
+  /** Capture mechanism when the SDK can determine it. */
+  mechanism?: IssueExceptionMechanism;
+};
+
+type IssueExceptionRelationship =
+  | "reported"
+  | "cause"
+  | "context"
+  | "aggregate_member"
+  | "suppressed";
+
+type IssueExceptionMessageState = "captured" | "truncated" | "redacted" | "not_captured";
+
+type IssueExceptionStackFramesState = "captured" | "truncated" | "not_captured";
+
+/** One parent-first runtime exception with its own message and structured stack state. */
+type IssueExceptionChainEntry = {
+  /** Contiguous zero-based node identity. */
+  id: number;
+  /** Earlier parent node. Omitted only for the reported root exception. */
+  parentId?: number;
+  relationship: IssueExceptionRelationship;
+  type: string;
+  /** Bounded message only when messageState is captured or truncated. */
+  message?: string;
+  messageState: IssueExceptionMessageState;
+  module?: string;
+  mechanism?: IssueExceptionMechanism;
+  /** This exact exception's bounded structured frames. */
+  stackFrames?: IssueStackFrame[];
+  stackFramesState: IssueExceptionStackFramesState;
+};
+
+/** At most eight parent-first runtime exceptions. */
+type IssueExceptionChain = {
+  entries: IssueExceptionChainEntry[];
+  /** True when a cycle or node cap omitted additional exceptions. */
+  truncated: boolean;
+};
+
+type IssueBreadcrumbLevel = "debug" | "info" | "warning" | "error" | "critical";
+
+type IssueBreadcrumbLevelInput = IssueBreadcrumbLevel | "trace" | "log" | "warn" | "fatal";
+
+type IssueBreadcrumbDataValue = string | number | boolean | null;
+
+/** One privacy-bounded step that happened before an issue. */
+type IssueBreadcrumb = {
+  /** RFC 3339 timestamp with an explicit timezone. */
+  timestamp: string;
+  /** Optional stable breadcrumb kind, such as `navigation` or `http`. */
+  type?: string;
+  /** Required low-cardinality source category. */
+  category: string;
+  level?: IssueBreadcrumbLevel;
+  /** Optional bounded display-safe description. */
+  message?: string;
+  /** At most eight flat primitive fields. Never include authentication material or raw request data. */
+  data?: Record<string, IssueBreadcrumbDataValue>;
+};
+
+/** Input accepted by `addBreadcrumb`; the client supplies the current timestamp when omitted. */
+type IssueBreadcrumbInput = Omit<IssueBreadcrumb, "timestamp" | "level"> & {
+  timestamp?: string;
+  level?: IssueBreadcrumbLevelInput;
+};
+
+/** App-reported code location that narrows the smallest likely fix area. */
+type IssueLikelyFixArea = {
+  component?: string;
+  module?: string;
+  function?: string;
+  /** Safe repository-relative source path. */
+  file?: string;
+  line?: number;
+  column?: number;
+  inApp?: boolean;
+};
+
+/** App-reported user impact without user identities or raw request data. */
+type IssueImpactEvidence = {
+  affectedUserSegment?: string;
+  failedAction?: string;
+  userVisibleOutcome?: string;
+};
+
+/** Explicit diagnostic evidence for cause, fix area, impact, and capture limitations. */
+type IssueDiagnosticEvidence = {
+  /** App-owned hypothesis. LogBrew presents it as reported, never proven. */
+  likelyRootCause?: string;
+  likelyFixArea?: IssueLikelyFixArea;
+  impact?: IssueImpactEvidence;
+  /** Unique bounded field names whose values were captured. */
+  capturedFields?: string[];
+  missingFields?: string[];
+  redactedFields?: string[];
+  truncatedFields?: string[];
+};
+
+type NativeStackArchitecture = "arm" | "arm64" | "arm64e" | "x86" | "x86_64";
+
+type NativeStackFrame = {
+  imageUuid: string;
+  architecture: NativeStackArchitecture;
+  instructionOffset: string;
+};
+
+/** Public issue event attributes. */
+type IssueAttributes = {
+  title: string;
+  level: SeverityInput;
+  message?: string;
+  exception?: IssueException;
+  /** Parent-first runtime exception evidence; the first node agrees with legacy exception/stackFrames. */
+  exceptionChain?: IssueExceptionChain;
+  /** Ordered privacy-bounded generated frames, capped at 32. */
+  stackFrames?: IssueStackFrame[];
+  /** Ordered native image-relative frames for exact release symbolication, capped at 32. */
+  nativeStackFrames?: NativeStackFrame[];
+  /** Oldest-to-newest issue history, capped at the most recent 64 entries. */
+  breadcrumbs?: IssueBreadcrumb[];
+  /** True when older or invalid history was omitted before capture. */
+  breadcrumbsTruncated?: boolean;
+  /** App-reported diagnostic evidence, validated and labeled separately from observed facts. */
+  evidence?: IssueDiagnosticEvidence;
+  metadata?: Metadata;
+  context?: TelemetryContext;
+};
+
+/** Options for creating privacy-bounded issue attributes from a JavaScript error. */
+type JavaScriptErrorIssueOptions = {
+  title?: string;
+  level?: SeverityInput;
+  message?: string;
+  metadata?: Metadata;
+  /** Stable low-cardinality capture mechanism. Defaults to `javascript.error`. */
+  mechanism?: string;
+  /** Whether the error was handled by the capture boundary. Defaults to true. */
+  handled?: boolean;
+  /** Metadata source label. Defaults to `javascript.error`. */
+  source?: string;
+  /** Active trace copied into primitive correlation metadata. */
+  trace?: LogCorrelationTraceContext | null;
+  /** Release name associated with the runtime error. */
+  release?: string;
+  /** Environment associated with the runtime error. */
+  environment?: string;
+  /** Service associated with the runtime error. */
+  service?: string;
+  /** Runtime label such as `browser`, `node`, or `react-native`. */
+  runtime?: string;
+  /** Platform label such as `web`, `ios`, or `android`. */
+  platform?: string;
+  /** Map of sanitized frame filenames or minified URLs to release-artifact Debug IDs. */
+  debugIdMap?: Record<string, string>;
+  /** Optional stable app-owned grouping fingerprint. Keep it safe and low-cardinality. */
+  fingerprint?: string;
+  /** App-reported cause, fix-area, impact, and explicit evidence-state receipt. */
+  evidence?: IssueDiagnosticEvidence;
+  /** Include raw stack text only when the app has explicitly approved it. Defaults to false. */
+  includeErrorStack?: boolean;
+};
+
+/** Options for automatic browser breadcrumbs. Every source defaults to true. */
+type BrowserBreadcrumbOptions = {
+  console?: boolean;
+  network?: boolean;
+  navigation?: boolean;
+  /** URLs whose requests are not recorded, such as the LogBrew ingest endpoint. */
+  ignoredUrls?: string[];
+};
+
+/**
+ * Record console calls, fetch and XHR requests, and route changes in a browser window as issue
+ * breadcrumbs on the client. The wrappers only observe calls. Returns an uninstall function.
+ */
+declare function installBrowserBreadcrumbs(
+  browserWindow: unknown,
+  client: LogBrewClient,
+  options?: BrowserBreadcrumbOptions
+): () => void;
+
+/**
+ * Convert a JavaScript Error-like value into safe issue attributes with optional source-map Debug ID metadata.
+ * Parent-first cause and AggregateError evidence is bounded to the public exception-chain contract.
+ */
+declare function createIssueAttributesFromError(
+  error: unknown,
+  options?: JavaScriptErrorIssueOptions
+): IssueAttributes;
+
+export type {
+  BrowserBreadcrumbOptions,
+  IssueAttributes,
+  IssueBreadcrumb,
+  IssueBreadcrumbDataValue,
+  IssueBreadcrumbInput,
+  IssueBreadcrumbLevel,
+  IssueBreadcrumbLevelInput,
+  IssueDiagnosticEvidence,
+  IssueException,
+  IssueExceptionChain,
+  IssueExceptionChainEntry,
+  IssueExceptionMechanism,
+  IssueExceptionMessageState,
+  IssueExceptionRelationship,
+  IssueExceptionStackFramesState,
+  IssueImpactEvidence,
+  IssueLikelyFixArea,
+  IssueStackFrame,
+  JavaScriptErrorIssueOptions,
+  NativeStackArchitecture,
+  NativeStackFrame
+};
+export { createIssueAttributesFromError, installBrowserBreadcrumbs };

package/types/logging.d.ts

@@ -0,0 +1,175 @@
+import type { LogAttributes, Metadata } from "./telemetry.js";
+import type { Transport, TransportResponse } from "./delivery.js";
+import type { LogBrewClient } from "./client.js";
+import type { LogCorrelationTraceContext } from "./trace-context.js";
+
+/** Console method names supported by the opt-in console capture helper. */
+type ConsoleMethodName = "debug" | "info" | "log" | "warn" | "error";
+
+/** Minimal console-like target accepted by the opt-in console capture helper. */
+type ConsoleLike = Partial<Record<ConsoleMethodName, (...args: unknown[]) => void>>;
+
+/** Configuration for opt-in console capture. */
+type ConsoleCaptureConfig = {
+  client: LogBrewClient;
+  console?: ConsoleLike;
+  levels?: ConsoleMethodName[];
+  logger?: string;
+  metadata?: Metadata;
+  transport?: Transport;
+  flushOnCapture?: boolean;
+  includeErrorStack?: boolean;
+  timestamp?: () => string;
+  eventIdPrefix?: string;
+  onError?: (error: unknown) => void;
+};
+
+/** Handle returned by opt-in console capture installation. */
+type ConsoleCaptureHandle = {
+  flush(): Promise<TransportResponse | null>;
+  uninstall(): void;
+};
+
+/** Pino JSON log record shape accepted by the optional Pino destination helper. */
+type PinoLogRecord = Record<string, unknown> & {
+  level?: string | number;
+  time?: string | number;
+  timestamp?: string | number;
+  msg?: unknown;
+  message?: unknown;
+  err?: unknown;
+  error?: unknown;
+};
+
+/** Configuration for the dependency-free Pino destination adapter. */
+type PinoDestinationConfig = {
+  client: LogBrewClient;
+  logger?: string;
+  metadata?: Metadata;
+  traceProvider?: () => LogCorrelationTraceContext | null | undefined;
+  transport?: Transport;
+  flushOnWrite?: boolean;
+  includeErrorStack?: boolean;
+  timestamp?: () => string;
+  eventIdPrefix?: string;
+  onError?: (error: unknown) => void;
+};
+
+/** Stream-like destination returned for use as Pino's output destination. */
+type PinoDestinationHandle = {
+  write(chunk: unknown): boolean;
+  flush(): Promise<TransportResponse | null>;
+  end(): Promise<TransportResponse | null>;
+};
+
+/** Winston info object shape accepted by the optional Winston transport helper. */
+type WinstonLogInfo = Record<string, unknown> & {
+  level?: string;
+  message?: unknown;
+  timestamp?: string | number | Date;
+  time?: string | number | Date;
+  err?: unknown;
+  error?: unknown;
+  stack?: unknown;
+};
+
+/** Configuration for the dependency-free Winston transport adapter. */
+type WinstonTransportConfig = {
+  client: LogBrewClient;
+  /** Record each Winston message as an issue breadcrumb (category `log.winston`). Defaults to true. */
+  breadcrumbs?: boolean;
+  logger?: string;
+  metadata?: Metadata;
+  traceProvider?: () => LogCorrelationTraceContext | null | undefined;
+  transport?: Transport;
+  flushOnWrite?: boolean;
+  includeErrorStack?: boolean;
+  timestamp?: () => string;
+  eventIdPrefix?: string;
+  level?: string;
+  name?: string;
+  silent?: boolean;
+  handleExceptions?: boolean;
+  handleRejections?: boolean;
+  onError?: (error: unknown) => void;
+};
+
+/** Object-mode transport returned for use in a Winston logger's transports array. */
+type WinstonTransportHandle = {
+  level?: string;
+  name?: string;
+  silent?: boolean;
+  handleExceptions?: boolean;
+  handleRejections?: boolean;
+  log(info: WinstonLogInfo, callback?: () => void): void;
+  write(info: WinstonLogInfo): boolean;
+  flush(): Promise<TransportResponse | null>;
+  end(callback?: () => void): unknown;
+};
+
+/** Install explicit console capture while preserving the target console's normal output behavior. */
+declare function installLogBrewConsoleCapture(config: ConsoleCaptureConfig): ConsoleCaptureHandle;
+
+/** Convert console arguments into safe LogBrew log attributes without installing capture. */
+declare function logAttributesFromConsoleArgs(
+  method: ConsoleMethodName,
+  args: readonly unknown[],
+  options?: {
+    logger?: string;
+    metadata?: Metadata;
+    includeErrorStack?: boolean;
+  }
+): LogAttributes;
+
+/** Map a console method name to the corresponding LogBrew log level. */
+declare function logbrewLevelFromConsoleMethod(method: ConsoleMethodName): LogAttributes["level"];
+
+/** Create a dependency-free Pino destination that turns JSON log lines into queued LogBrew log events. */
+declare function createLogBrewPinoDestination(config: PinoDestinationConfig): PinoDestinationHandle;
+
+/** Convert a parsed Pino JSON log record into safe LogBrew log attributes without installing a destination. */
+declare function logAttributesFromPinoRecord(
+  record: PinoLogRecord,
+  options?: {
+    logger?: string;
+    metadata?: Metadata;
+    trace?: LogCorrelationTraceContext | null;
+    includeErrorStack?: boolean;
+  }
+): LogAttributes;
+
+/** Create a dependency-free Winston object-mode transport that queues LogBrew log events. */
+declare function createLogBrewWinstonTransport(config: WinstonTransportConfig): WinstonTransportHandle;
+
+/** Convert a Winston info object into safe LogBrew log attributes without installing a transport. */
+declare function logAttributesFromWinstonInfo(
+  info: WinstonLogInfo,
+  options?: {
+    logger?: string;
+    metadata?: Metadata;
+    trace?: LogCorrelationTraceContext | null;
+    includeErrorStack?: boolean;
+  }
+): LogAttributes;
+
+export type {
+  ConsoleCaptureConfig,
+  ConsoleCaptureHandle,
+  ConsoleLike,
+  ConsoleMethodName,
+  PinoDestinationConfig,
+  PinoDestinationHandle,
+  PinoLogRecord,
+  WinstonLogInfo,
+  WinstonTransportConfig,
+  WinstonTransportHandle
+};
+export {
+  createLogBrewPinoDestination,
+  createLogBrewWinstonTransport,
+  installLogBrewConsoleCapture,
+  logAttributesFromConsoleArgs,
+  logAttributesFromPinoRecord,
+  logAttributesFromWinstonInfo,
+  logbrewLevelFromConsoleMethod
+};

package/types/opentelemetry.d.ts

@@ -0,0 +1,205 @@
+import type { Metadata, SpanAttributes } from "./telemetry.js";
+import type { LogBrewClient } from "./client.js";
+import type { LogCorrelationTraceContext } from "./trace-context.js";
+import type { Transport } from "./delivery.js";
+
+/** Minimal OpenTelemetry SpanContext-like shape copied by dependency-free bridge helpers. */
+type OpenTelemetrySpanContextLike = {
+  traceId?: unknown;
+  spanId?: unknown;
+  traceFlags?: unknown;
+  isValid?: boolean;
+};
+
+/** Minimal OpenTelemetry Span-like shape accepted by dependency-free bridge helpers. */
+type OpenTelemetrySpanLike = {
+  spanContext?: () => OpenTelemetrySpanContextLike | null | undefined;
+  getSpanContext?: () => OpenTelemetrySpanContextLike | null | undefined;
+};
+
+/** Minimal OpenTelemetry API-like shape used for the current active span helper. */
+type OpenTelemetryApiLike = {
+  trace?: {
+    getActiveSpan?: () => OpenTelemetrySpanLike | null | undefined;
+  };
+};
+
+/** OpenTelemetry high-resolution time tuple accepted by dependency-free ReadableSpan helpers. */
+type OpenTelemetryHrTimeLike = readonly [number, number];
+
+/** Minimal OpenTelemetry event-like shape summarized from ended spans. */
+type OpenTelemetryTimedEventLike = {
+  name?: unknown;
+  time?: OpenTelemetryHrTimeLike | number | Date;
+  timestamp?: OpenTelemetryHrTimeLike | number | Date;
+  attributes?: Record<string, unknown>;
+};
+
+/** Minimal OpenTelemetry link-like shape summarized from ended spans. */
+type OpenTelemetrySpanLinkLike = {
+  context?: OpenTelemetrySpanContextLike | null | undefined;
+  spanContext?: OpenTelemetrySpanContextLike | null | undefined;
+  attributes?: Record<string, unknown>;
+};
+
+/** Minimal OpenTelemetry ReadableSpan-like shape accepted by dependency-free bridge helpers. */
+type OpenTelemetryReadableSpanLike = {
+  name?: unknown;
+  kind?: unknown;
+  spanContext?: () => OpenTelemetrySpanContextLike | null | undefined;
+  parentSpanContext?: OpenTelemetrySpanContextLike | null | undefined;
+  parentSpanId?: unknown;
+  startTime?: OpenTelemetryHrTimeLike | number | Date;
+  endTime?: OpenTelemetryHrTimeLike | number | Date;
+  duration?: OpenTelemetryHrTimeLike;
+  status?: { code?: unknown };
+  attributes?: Record<string, unknown>;
+  events?: OpenTelemetryTimedEventLike[];
+  links?: OpenTelemetrySpanLinkLike[];
+  resource?: { attributes?: Record<string, unknown> };
+  instrumentationScope?: { name?: unknown; version?: unknown };
+  droppedAttributesCount?: unknown;
+  droppedEventsCount?: unknown;
+  droppedLinksCount?: unknown;
+};
+
+/** Options for creating a LogBrew child trace from OpenTelemetry context. */
+type OpenTelemetryTraceContextOptions = {
+  spanId?: string;
+  spanIdFactory?: () => string;
+};
+
+/** Options for reading OpenTelemetry's current active span without requiring an OTel dependency. */
+type CurrentOpenTelemetryTraceContextOptions = OpenTelemetryTraceContextOptions & {
+  openTelemetryApi?: OpenTelemetryApiLike;
+};
+
+/** Options for privacy-bounded OpenTelemetry ReadableSpan conversion. */
+type OpenTelemetryReadableSpanOptions = {
+  /** Additional safe span attribute keys to copy; sensitive keys remain blocked. */
+  attributeKeys?: string[];
+  /** Capture unsampled spans. Defaults to false to follow common OTel processor behavior. */
+  captureUnsampled?: boolean;
+  /** Additional safe span event attribute keys to copy; sensitive keys remain blocked. */
+  eventAttributeKeys?: string[];
+  /** Include privacy-bounded span event summaries. Defaults to true. */
+  includeSpanEvents?: boolean;
+  /** Include privacy-bounded span link summaries. Defaults to true. */
+  includeSpanLinks?: boolean;
+  /** Additional safe span link attribute keys to copy; sensitive keys remain blocked. */
+  linkAttributeKeys?: string[];
+  /** Primitive app metadata merged into every converted span. */
+  metadata?: Metadata;
+  /** Additional safe resource attribute keys to copy; sensitive keys remain blocked. */
+  resourceAttributeKeys?: string[];
+};
+
+/** Configuration for an opt-in OpenTelemetry SpanProcessor-compatible LogBrew bridge. */
+type OpenTelemetrySpanProcessorConfig = OpenTelemetryReadableSpanOptions & {
+  client: LogBrewClient;
+  transport?: Transport;
+  flushOnForceFlush?: boolean;
+  /** Emit one privacy-bounded synthetic trace summary span per trace on forceFlush/shutdown. Defaults to false. */
+  includeTraceSummary?: boolean;
+  timestamp?: () => string;
+  eventIdPrefix?: string;
+  spanFilter?: (span: unknown) => boolean | void;
+  onError?: (error: unknown) => void;
+};
+
+/** Configuration for an opt-in OpenTelemetry SpanExporter-compatible LogBrew bridge. */
+type OpenTelemetrySpanExporterConfig = OpenTelemetryReadableSpanOptions & {
+  client: LogBrewClient;
+  transport?: Transport;
+  /** Flush with the provided transport during export. Defaults to true when a transport is supplied. */
+  flushOnExport?: boolean;
+  /** Emit one privacy-bounded synthetic trace summary span per exported batch. Defaults to false. */
+  includeTraceSummary?: boolean;
+  timestamp?: () => string;
+  eventIdPrefix?: string;
+  spanFilter?: (span: unknown) => boolean | void;
+  onError?: (error: unknown) => void;
+};
+
+/** Minimal OpenTelemetry export result shape; success is code 0, failure is code 1. */
+type OpenTelemetryExportResult = {
+  code: number;
+  error?: Error;
+};
+
+/** SpanExporter-compatible handle for app-owned OpenTelemetry processors. */
+type OpenTelemetrySpanExporterHandle = {
+  export(
+    spans: readonly unknown[],
+    resultCallback: (result: OpenTelemetryExportResult) => void
+  ): void;
+  forceFlush(): Promise<void>;
+  shutdown(): Promise<void>;
+};
+
+/** SpanProcessor-compatible handle for app-owned OpenTelemetry setup. */
+type OpenTelemetrySpanProcessorHandle = {
+  onStart(span: unknown, parentContext: unknown): void;
+  onEnd(span: unknown): void;
+  forceFlush(): Promise<void>;
+  shutdown(): Promise<void>;
+};
+
+/** Create a LogBrew child trace from a live OpenTelemetry SpanContext-like object. */
+declare function logbrewTraceContextFromOpenTelemetrySpanContext(
+  spanContext: OpenTelemetrySpanContextLike | null | undefined,
+  options?: OpenTelemetryTraceContextOptions
+): LogCorrelationTraceContext | null;
+
+/** Create a LogBrew child trace from a live OpenTelemetry Span-like object. */
+declare function logbrewTraceContextFromOpenTelemetrySpan(
+  span: OpenTelemetrySpanLike | null | undefined,
+  options?: OpenTelemetryTraceContextOptions
+): LogCorrelationTraceContext | null;
+
+/** Create a LogBrew child trace from OpenTelemetry's current active span, when available. */
+declare function logbrewTraceContextFromCurrentOpenTelemetrySpan(
+  options?: CurrentOpenTelemetryTraceContextOptions
+): LogCorrelationTraceContext | null;
+
+/** Convert an ended OpenTelemetry ReadableSpan-like object into safe LogBrew span attributes. */
+declare function spanAttributesFromOpenTelemetryReadableSpan(
+  span: OpenTelemetryReadableSpanLike | null | undefined,
+  options?: OpenTelemetryReadableSpanOptions
+): SpanAttributes | null;
+
+/** Create an opt-in SpanProcessor-compatible bridge for app-owned OpenTelemetry providers. */
+declare function createLogBrewOpenTelemetrySpanProcessor(
+  config: OpenTelemetrySpanProcessorConfig
+): OpenTelemetrySpanProcessorHandle;
+
+/** Create an opt-in SpanExporter-compatible bridge for app-owned OpenTelemetry processors. */
+declare function createLogBrewOpenTelemetrySpanExporter(
+  config: OpenTelemetrySpanExporterConfig
+): OpenTelemetrySpanExporterHandle;
+
+export type {
+  CurrentOpenTelemetryTraceContextOptions,
+  OpenTelemetryApiLike,
+  OpenTelemetryExportResult,
+  OpenTelemetryHrTimeLike,
+  OpenTelemetryReadableSpanLike,
+  OpenTelemetryReadableSpanOptions,
+  OpenTelemetrySpanContextLike,
+  OpenTelemetrySpanExporterConfig,
+  OpenTelemetrySpanExporterHandle,
+  OpenTelemetrySpanLike,
+  OpenTelemetrySpanLinkLike,
+  OpenTelemetrySpanProcessorConfig,
+  OpenTelemetrySpanProcessorHandle,
+  OpenTelemetryTimedEventLike,
+  OpenTelemetryTraceContextOptions
+};
+export {
+  createLogBrewOpenTelemetrySpanExporter,
+  createLogBrewOpenTelemetrySpanProcessor,
+  logbrewTraceContextFromCurrentOpenTelemetrySpan,
+  logbrewTraceContextFromOpenTelemetrySpan,
+  logbrewTraceContextFromOpenTelemetrySpanContext,
+  spanAttributesFromOpenTelemetryReadableSpan
+};