Tracer

declare const DisablePropagation: Reference<DisablePropagation, boolean>;

interface DisablePropagation {
  readonly _: typeof _;
}

declare const externalSpan: (options: {
  readonly context?: Context.Context<never>;
  readonly sampled?: boolean;
  readonly spanId: string;
  readonly traceId: string;
}) => ExternalSpan;

declare const make: (options: Omit<Tracer, typeof TracerTypeId>) => Tracer;

declare const tracerWith: <A, E, R>(
  f: (tracer: Tracer) => Effect.Effect<A, E, R>,
) => Effect.Effect<A, E, R>;

type AnySpan = Span | ExternalSpan;

interface ExternalSpan {
  readonly _tag: "ExternalSpan";
  readonly context: Context<never>;
  readonly sampled: boolean;
  readonly spanId: string;
  readonly traceId: string;
}

interface Span {
  readonly _tag: "Span";
  readonly attributes: ReadonlyMap<string, unknown>;
  readonly context: Context<never>;
  readonly kind: SpanKind;
  readonly links: readonly Array<SpanLink>;
  readonly name: string;
  readonly parent: Option<AnySpan>;
  readonly sampled: boolean;
  readonly spanId: string;
  readonly status: SpanStatus;
  readonly traceId: string;
  addLinks(links: readonly Array<SpanLink>): void;
  attribute(key: string, value: unknown): void;
  end(endTime: bigint, exit: Exit<unknown, unknown>): void;
  event(name: string, startTime: bigint, attributes?: Record<string, unknown>): void;
}

type SpanKind = "internal" | "server" | "client" | "producer" | "consumer";

interface SpanLink {
  readonly _tag: "SpanLink";
  readonly attributes: Readonly<Record<string, unknown>>;
  readonly span: AnySpan;
}

interface SpanOptions {
  readonly attributes?: Record<string, unknown>;
  readonly captureStackTrace?: boolean | LazyArg<string | undefined>;
  readonly context?: Context<never>;
  readonly kind?: SpanKind;
  readonly links?: readonly Array<SpanLink>;
  readonly parent?: AnySpan;
  readonly root?: boolean;
}

type SpanStatus =
  | {
      _tag: "Started";
      startTime: bigint;
    }
  | {
      _tag: "Ended";
      endTime: bigint;
      exit: Exit.Exit<unknown, unknown>;
      startTime: bigint;
    };

interface Tracer {
  readonly [TracerTypeId]: typeof TracerTypeId;
  context<X>(f: () => X, fiber: RuntimeFiber<any, any>): X;
  span(name: string, parent: Option<AnySpan>, context: Context<never>, links: readonly Array<SpanLink>, startTime: bigint, kind: SpanKind, options?: SpanOptions): Span;
}

declare const TracerTypeId: unique symbol;

type TracerTypeId = typeof TracerTypeId;

declare const ParentSpan: Tag<ParentSpan, AnySpan>;

interface ParentSpan {
  readonly _: typeof _;
}

declare const Tracer: Tag<Tracer, Tracer>;