@nxgt/telemetry 0.1.0 → 0.2.1

package/dist/index.js

@@ -1,6 +1,14 @@
 // src/attributes/attributes.ts
 var EMPTY_ATTRIBUTES = Object.freeze({});
+var UNREADABLE = "[unreadable]";
 function coerceAttribute(value) {
+  try {
+    return coerce(value);
+  } catch {
+    return UNREADABLE;
+  }
+}
+function coerce(value) {
   if (value === null || value === undefined)
     return null;
   switch (typeof value) {
@@ -24,12 +32,25 @@ function coerceAttribute(value) {
   return render(value);
 }
 function attributesOf(input) {
-  if (input === undefined)
+  if (input === undefined || input === null)
     return EMPTY_ATTRIBUTES;
+  let keys;
+  try {
+    keys = Object.keys(input);
+  } catch {
+    return EMPTY_ATTRIBUTES;
+  }
   const attributes = {};
   let any = false;
-  for (const key of Object.keys(input)) {
-    const value = input[key];
+  for (const key of keys) {
+    let value;
+    try {
+      value = input[key];
+    } catch {
+      attributes[key] = UNREADABLE;
+      any = true;
+      continue;
+    }
     if (value === undefined)
       continue;
     attributes[key] = coerceAttribute(value);
@@ -67,38 +88,97 @@ function render(value) {
   try {
     return String(value);
   } catch {
-    return "[unrenderable]";
+    return UNREADABLE;
   }
 }
-// src/model/signal.ts
-var SEVERITY_NUMBER = Object.freeze({
-  debug: 5,
-  info: 9,
-  warn: 13,
-  error: 17
-});
-var SEVERITIES = Object.freeze([
-  "debug",
-  "info",
-  "warn",
-  "error"
-]);
-function meetsSeverity(severity, minimum) {
-  return SEVERITY_NUMBER[severity] >= SEVERITY_NUMBER[minimum];
-}
-var SPAN_KIND_NUMBER = Object.freeze({
-  internal: 1,
-  server: 2,
-  client: 3,
-  producer: 4,
-  consumer: 5
-});
-function signalAt(signal) {
-  return signal.type === "log" ? signal.at : signal.startedAt;
+// src/context/current.ts
+import * as asyncHooks from "node:async_hooks";
+
+// src/export/pipeline.ts
+class Pipeline {
+  constructor(options) {
+    this.buffer = [];
+    this.draining = Promise.resolve();
+    this.closed = false;
+    this.options = options;
+  }
+  post(signal) {
+    if (this.closed)
+      return false;
+    this.buffer.push(signal);
+    if (this.buffer.length >= this.options.batch) {
+      this.flush();
+    } else if (this.timer === undefined) {
+      this.timer = setTimeout(() => {
+        this.timer = undefined;
+        this.flush();
+      }, this.options.linger);
+      this.timer.unref?.();
+    }
+    return true;
+  }
+  close() {
+    this.closing ??= this.drainAndClose();
+    return this.closing;
+  }
+  flush() {
+    this.clearTimer();
+    if (this.buffer.length === 0)
+      return;
+    const batch = this.buffer;
+    this.buffer = [];
+    this.draining = this.draining.then(() => this.ship(batch));
+  }
+  clearTimer() {
+    if (this.timer === undefined)
+      return;
+    clearTimeout(this.timer);
+    this.timer = undefined;
+  }
+  async ship(batch) {
+    for (const exporter of this.options.exporters) {
+      try {
+        await exporter.export(this.options.resource, batch);
+      } catch (failure) {
+        this.report(failure);
+      }
+    }
+  }
+  async drainAndClose() {
+    this.closed = true;
+    this.flush();
+    const deadline = timeout(this.options.drainTimeout);
+    const drained = await Promise.race([
+      this.draining.then(() => true),
+      deadline.then(() => false)
+    ]);
+    if (!drained) {
+      this.report(new Error(`[telemetry] the backlog did not ship within ${this.options.drainTimeout}ms; closing anyway`));
+    }
+    await Promise.race([this.closeExporters(), deadline]);
+  }
+  async closeExporters() {
+    for (const exporter of this.options.exporters) {
+      try {
+        await exporter.close?.();
+      } catch (failure) {
+        this.report(failure);
+      }
+    }
+  }
+  report(failure) {
+    try {
+      this.options.onExportError(failure);
+    } catch {}
+  }
 }
-function signalSpan(signal) {
-  return signal.type === "log" ? signal.span : signal.context;
+function timeout(milliseconds) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, milliseconds);
+    timer.unref?.();
+  });
 }
+
 // src/trace/ids.ts
 var INVALID_TRACE_ID = "0".repeat(32);
 var INVALID_SPAN_ID = "0".repeat(16);
@@ -164,6 +244,7 @@ function randomHex(bytes) {
   }
   return hex;
 }
+
 // src/trace/sampler.ts
 var alwaysSample = { sample: () => true };
 var neverSample = { sample: () => false };
@@ -186,32 +267,763 @@ function ratioSampler(ratio) {
     }
   };
 }
+
+// src/telemetry/telemetry.ts
+var TELEMETRY_DEFAULTS = Object.freeze({
+  minimum: "info",
+  stackTraces: true,
+  batch: 512,
+  linger: 1000,
+  drainTimeout: 1e4
+});
+var installed;
+
+class Telemetry {
+  constructor(options) {
+    this.resource = {
+      service: options.service,
+      ...options.version === undefined ? {} : { version: options.version },
+      ...options.environment === undefined ? {} : { environment: options.environment },
+      attributes: attributesOf(options.attributes)
+    };
+    this.sampler = options.sampler ?? alwaysSample;
+    this.minimum = options.minimum ?? TELEMETRY_DEFAULTS.minimum;
+    this.stackTraces = options.stackTraces ?? TELEMETRY_DEFAULTS.stackTraces;
+    this.pipeline = new Pipeline({
+      resource: this.resource,
+      exporters: options.exporters ?? [],
+      batch: options.batch ?? TELEMETRY_DEFAULTS.batch,
+      linger: options.linger ?? TELEMETRY_DEFAULTS.linger,
+      drainTimeout: options.drainTimeout ?? TELEMETRY_DEFAULTS.drainTimeout,
+      onExportError: options.onExportError ?? defaultOnExportError
+    });
+  }
+  emit(signal) {
+    return this.pipeline.post(signal);
+  }
+  install() {
+    installed = this;
+    return this;
+  }
+  async close() {
+    if (installed === this)
+      installed = undefined;
+    await this.pipeline.close();
+  }
+  async[Symbol.asyncDispose]() {
+    await this.close();
+  }
+}
+function createTelemetry(service, options = {}) {
+  return new Telemetry({ ...options, service });
+}
+function installedTelemetry() {
+  return installed;
+}
+function uninstallTelemetry(telemetry) {
+  if (telemetry === undefined || installed === telemetry)
+    installed = undefined;
+}
+function defaultOnExportError(failure) {
+  console.error("[telemetry] export failed", failure);
+}
+
+// src/context/current.ts
+var storage = createStorage();
+function currentContext() {
+  return storage.getStore();
+}
+function runWithContext(context, fn) {
+  return storage.run(context, fn);
+}
+function resolveTelemetry() {
+  return currentContext()?.telemetry ?? installedTelemetry();
+}
+function withTelemetry(telemetry, fn) {
+  const context = currentContext();
+  return runWithContext({
+    telemetry,
+    ...context?.span === undefined ? {} : { span: context.span },
+    attributes: context?.attributes ?? EMPTY_ATTRIBUTES
+  }, fn);
+}
+function withAttributes(attributes, fn) {
+  const given = attributesOf(attributes);
+  const context = currentContext();
+  if (context === undefined) {
+    const telemetry = installedTelemetry();
+    if (telemetry === undefined)
+      return fn();
+    return runWithContext({ telemetry, attributes: given }, fn);
+  }
+  return runWithContext({ ...context, attributes: mergeAttributes(context.attributes, given) }, fn);
+}
+function currentSpan() {
+  return currentContext()?.span;
+}
+function currentTraceparent() {
+  const span = currentSpan();
+  return span === undefined ? undefined : renderTraceparent(span);
+}
+function currentAttributes() {
+  return currentContext()?.attributes ?? EMPTY_ATTRIBUTES;
+}
+function createStorage() {
+  const AsyncLocalStorage2 = asyncHooks.AsyncLocalStorage;
+  if (typeof AsyncLocalStorage2 === "function") {
+    return new AsyncLocalStorage2;
+  }
+  let current;
+  return {
+    getStore: () => current,
+    run(context, fn) {
+      const previous = current;
+      current = context;
+      try {
+        return fn();
+      } finally {
+        current = previous;
+      }
+    }
+  };
+}
+// src/export/console.ts
+function consoleExporter(options = {}) {
+  const write = options.write ?? ((line) => console.log(line));
+  const stackTraces = options.stackTraces ?? true;
+  return {
+    export(_resource, batch) {
+      for (const signal of batch) {
+        write(signal.type === "log" ? renderLog(signal) : renderSpan(signal));
+        const error = signal.error;
+        if (stackTraces && error?.stackTrace)
+          write(error.stackTrace);
+      }
+    }
+  };
+}
+function renderLog(log) {
+  return [
+    clock(log.at),
+    log.severity.toUpperCase().padEnd(5),
+    log.source,
+    log.name,
+    renderAttributes(log.attributes),
+    renderError(log.error),
+    renderTrace(log)
+  ].filter(Boolean).join("  ");
+}
+function renderSpan(span) {
+  return [
+    clock(span.endedAt),
+    "SPAN ",
+    span.name,
+    `${span.endedAt - span.startedAt}ms`,
+    span.status === "ok" ? "" : span.status.toUpperCase(),
+    renderAttributes(span.attributes),
+    renderError(span.error),
+    renderTrace(span)
+  ].filter(Boolean).join("  ");
+}
+function clock(at) {
+  if (!Number.isFinite(at) || Math.abs(at) > 8640000000000000)
+    return String(at);
+  return new Date(at).toISOString().slice(11, 23);
+}
+function renderAttributes(attributes) {
+  return Object.entries(attributes).map(([key, value]) => `${key}=${renderValue(value)}`).join(" ");
+}
+function renderValue(value) {
+  return Array.isArray(value) ? `[${value.join(",")}]` : String(value);
+}
+function renderError(error) {
+  if (error === undefined)
+    return "";
+  return error.message ? `${error.type}: ${error.message}` : error.type;
+}
+function renderTrace(signal) {
+  const span = signal.type === "log" ? signal.span : signal.context;
+  if (span === undefined)
+    return "";
+  return `[${span.traceId.slice(0, 8)}/${span.spanId.slice(0, 8)}]`;
+}
+// src/export/file.ts
+import {
+  appendFile,
+  mkdir,
+  readdir,
+  readFile,
+  rename,
+  rm,
+  stat,
+  writeFile
+} from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { promisify } from "node:util";
+import { gzip } from "node:zlib";
+
+// src/export/rotation.ts
+import { basename } from "node:path";
+function rotationDue(size, openedAt, now, policy) {
+  if (size <= 0)
+    return false;
+  if (policy.maxSize > 0 && size >= policy.maxSize)
+    return true;
+  return policy.every > 0 && period(openedAt, policy) !== period(now, policy);
+}
+function rolledName(path, at, taken = 0) {
+  const file = basename(path);
+  const directory = path.slice(0, path.length - file.length);
+  const dot = file.lastIndexOf(".");
+  const base = dot <= 0 ? file : file.slice(0, dot);
+  const extension = dot <= 0 ? "" : file.slice(dot);
+  const suffix = taken === 0 ? "" : `-${taken}`;
+  return `${directory}${base}-${stamp(at)}${suffix}${extension}`;
+}
+function rolledOf(path, names) {
+  const found = new Map;
+  for (const name of names) {
+    const rolled = parse(path, name);
+    if (rolled === undefined)
+      continue;
+    const key = `${rolled.at}-${rolled.taken}`;
+    const seen = found.get(key);
+    if (seen === undefined || name.endsWith(".gz")) {
+      found.set(key, { ...rolled, name });
+    }
+  }
+  return [...found.values()].sort((one, other) => other.at.localeCompare(one.at) || other.taken - one.taken).map((rolled) => rolled.name);
+}
+function prunable(path, names, keep) {
+  const kept = new Set(rolledOf(path, names).slice(0, Math.max(keep, 0)));
+  return names.filter((name) => parse(path, name) !== undefined && !kept.has(name));
+}
+function period(at, policy) {
+  return Math.floor(at / policy.every);
+}
+function parse(path, name) {
+  const file = basename(path);
+  const dot = file.lastIndexOf(".");
+  const base = dot <= 0 ? file : file.slice(0, dot);
+  const extension = dot <= 0 ? "" : file.slice(dot);
+  const pattern = new RegExp(`^${escapeRegex(base)}-(\\d{8}-\\d{6})(?:-(\\d+))?${escapeRegex(extension)}(\\.gz)?$`);
+  const found = pattern.exec(name);
+  if (found === null)
+    return;
+  return { at: found[1], taken: Number(found[2] ?? 0) };
+}
+function stamp(at) {
+  const iso = new Date(at).toISOString();
+  return `${iso.slice(0, 10).replaceAll("-", "")}-${iso.slice(11, 19).replaceAll(":", "")}`;
+}
+function escapeRegex(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/export/file.ts
+var compressed = promisify(gzip);
+var DEFAULT_MAX_SIZE = 64 * 1024 * 1024;
+var DEFAULT_ROTATION_PERIOD = 24 * 60 * 60 * 1000;
+var MAX_COLLISIONS = 1000;
+function fileExporter(options) {
+  const policy = {
+    maxSize: options.maxSize ?? DEFAULT_MAX_SIZE,
+    every: options.every ?? DEFAULT_ROTATION_PERIOD,
+    keep: options.keep ?? 7,
+    compress: options.compress ?? false
+  };
+  const now = options.now ?? Date.now;
+  const path = options.path;
+  let state;
+  let queue = Promise.resolve();
+  const write = async (batch) => {
+    const text = render2(batch);
+    if (text.length === 0)
+      return;
+    try {
+      state ??= await currentState(path, now());
+      if (rotationDue(state.size, state.openedAt, now(), policy)) {
+        await roll(path, now(), policy);
+        state = { size: 0, openedAt: now() };
+      }
+      await appendFile(path, text, "utf8");
+      state.size += Buffer.byteLength(text, "utf8");
+    } catch (failure) {
+      state = undefined;
+      throw failure;
+    }
+  };
+  return {
+    export(_resource, batch) {
+      const next = queue.then(() => write(batch));
+      queue = next.catch(() => {
+        return;
+      });
+      return next;
+    }
+  };
+}
+function render2(batch) {
+  let text = "";
+  for (const signal of batch) {
+    try {
+      text += `${JSON.stringify(signal)}
+`;
+    } catch {}
+  }
+  return text;
+}
+async function currentState(path, fallback) {
+  await mkdir(dirname(path), { recursive: true });
+  try {
+    const found = await stat(path);
+    return { size: found.size, openedAt: found.mtimeMs };
+  } catch {
+    return { size: 0, openedAt: fallback };
+  }
+}
+async function roll(path, at, policy) {
+  const target = await freeName(path, at);
+  await rename(path, target);
+  if (policy.compress)
+    await compress(target);
+  await prune(path, policy.keep);
+}
+async function freeName(path, at) {
+  for (let taken = 0;taken < MAX_COLLISIONS; taken++) {
+    const candidate = rolledName(path, at, taken);
+    if (!await exists(candidate) && !await exists(`${candidate}.gz`)) {
+      return candidate;
+    }
+  }
+  throw new Error(`[telemetry] ${MAX_COLLISIONS} archives of ${path} already share this second`);
+}
+async function compress(path) {
+  const pending = `${path}.gz.pending`;
+  await writeFile(pending, await compressed(await readFile(path)));
+  await rename(pending, `${path}.gz`);
+  await rm(path, { force: true });
+}
+async function prune(path, keep) {
+  const directory = dirname(path);
+  const names = await readdir(directory);
+  for (const name of prunable(path, names, keep)) {
+    await rm(join(directory, name), { force: true });
+  }
+}
+async function exists(path) {
+  return stat(path).then(() => true, () => false);
+}
+// src/export/json-lines.ts
+function jsonLinesExporter(options = {}) {
+  const write = options.write ?? ((line) => console.log(line));
+  return {
+    export(_resource, batch) {
+      for (const signal of batch) {
+        const line = render3(signal);
+        if (line !== undefined)
+          write(line);
+      }
+    }
+  };
+}
+function render3(signal) {
+  try {
+    return JSON.stringify(signal);
+  } catch {
+    return;
+  }
+}
+// src/logger/event.ts
+var INVALID_EVENT_ATTRIBUTE = "telemetry.event.invalid";
+function event(name, schema) {
+  return (input) => {
+    if (schema === undefined)
+      return { name, attributes: attributesOf(input) };
+    let result;
+    try {
+      result = schema["~standard"].validate(input);
+    } catch {
+      return invalid(name, input);
+    }
+    if (isThenable(result)) {
+      Promise.resolve(result).catch(() => {
+        return;
+      });
+      return invalid(name, input);
+    }
+    const checked = result;
+    if (checked.issues !== undefined)
+      return invalid(name, input);
+    return { name, attributes: fields(checked.value) };
+  };
+}
+function isTelemetryEvent(value) {
+  return typeof value === "object" && value !== null && typeof value.name === "string" && typeof value.attributes === "object";
+}
+function invalid(name, input) {
+  return {
+    name,
+    attributes: { ...attributesOf(input), [INVALID_EVENT_ATTRIBUTE]: true },
+    invalid: true
+  };
+}
+function fields(value) {
+  if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+    return attributesOf(value);
+  }
+  return { value: coerceAttribute(value) };
+}
+function isThenable(value) {
+  return typeof value === "object" && value !== null && typeof value.then === "function";
+}
+// src/model/error.ts
+function errorInfo(failure, stackTraces = true) {
+  try {
+    return flatten(failure, stackTraces);
+  } catch {
+    return { type: "Error", message: UNREADABLE };
+  }
+}
+function isAbort(failure) {
+  if (typeof failure !== "object" || failure === null)
+    return false;
+  const name = read(failure, "name");
+  return name === "AbortError" || name === "TimeoutError";
+}
+function flatten(failure, stackTraces) {
+  if (isError(failure)) {
+    const message = read(failure, "message");
+    const stack = stackTraces ? read(failure, "stack") : undefined;
+    return {
+      type: errorType(failure),
+      ...typeof message === "string" && message ? { message } : {},
+      ...typeof stack === "string" && stack ? { stackTrace: stack } : {}
+    };
+  }
+  return { type: typeName(failure), message: describe(failure) };
+}
+function isError(value) {
+  try {
+    if (value instanceof Error)
+      return true;
+    return typeof value === "object" && value !== null && Object.prototype.toString.call(value) === "[object Error]";
+  } catch {
+    return false;
+  }
+}
+function errorType(failure) {
+  const name = read(failure, "name");
+  const named = typeof name === "string" && name ? name : undefined;
+  if (named !== undefined && named !== "Error")
+    return named;
+  const constructed = constructorName(failure);
+  if (constructed !== undefined && constructed !== "Object")
+    return constructed;
+  return named ?? "Error";
+}
+function typeName(failure) {
+  if (failure === null)
+    return "null";
+  if (typeof failure !== "object")
+    return typeof failure;
+  return constructorName(failure) ?? "Object";
+}
+function constructorName(value) {
+  const name = read(value, "constructor");
+  if (typeof name !== "function" && typeof name !== "object")
+    return;
+  if (name === null)
+    return;
+  const own = read(name, "name");
+  return typeof own === "string" && own ? own : undefined;
+}
+function read(value, key) {
+  try {
+    return value[key];
+  } catch {
+    return;
+  }
+}
+function describe(failure) {
+  try {
+    return typeof failure === "object" && failure !== null ? JSON.stringify(failure) || String(failure) : String(failure);
+  } catch {
+    return UNREADABLE;
+  }
+}
+
+// src/model/signal.ts
+var SEVERITY_NUMBER = Object.freeze({
+  debug: 5,
+  info: 9,
+  warn: 13,
+  error: 17
+});
+var SEVERITIES = Object.freeze([
+  "debug",
+  "info",
+  "warn",
+  "error"
+]);
+function meetsSeverity(severity, minimum) {
+  return SEVERITY_NUMBER[severity] >= SEVERITY_NUMBER[minimum];
+}
+var SPAN_KIND_NUMBER = Object.freeze({
+  internal: 1,
+  server: 2,
+  client: 3,
+  producer: 4,
+  consumer: 5
+});
+function signalAt(signal) {
+  return signal.type === "log" ? signal.at : signal.startedAt;
+}
+function signalSpan(signal) {
+  return signal.type === "log" ? signal.span : signal.context;
+}
+
+// src/logger/logger.ts
+function createLogger(source) {
+  const write = (severity, input, second, third) => {
+    const telemetry = resolveTelemetry();
+    if (telemetry === undefined)
+      return;
+    if (!meetsSeverity(severity, telemetry.minimum))
+      return;
+    const [failure, fields] = split(second, third);
+    const span = currentSpan();
+    const named = name(input);
+    const record = {
+      type: "log",
+      at: Date.now(),
+      severity,
+      name: named.name,
+      source,
+      attributes: mergeAttributes(mergeAttributes(currentAttributes(), named.attributes), attributesOf(fields)),
+      ...span === undefined ? {} : { span },
+      ...failure === undefined ? {} : { error: errorInfo(failure, telemetry.stackTraces) }
+    };
+    telemetry.emit(record);
+  };
+  return {
+    enabled(severity) {
+      const telemetry = resolveTelemetry();
+      return telemetry !== undefined && meetsSeverity(severity, telemetry.minimum);
+    },
+    debug: (input, attributes) => write("debug", input, attributes),
+    info: (input, attributes) => write("info", input, attributes),
+    warn: (input, second, third) => write("warn", input, second, third),
+    error: (input, second, third) => write("error", input, second, third)
+  };
+}
+function split(second, third) {
+  if (third !== undefined)
+    return [second, third];
+  if (second === undefined)
+    return [undefined, undefined];
+  return isFields(second) ? [undefined, second] : [second, undefined];
+}
+function isFields(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  try {
+    if (value instanceof Error || Array.isArray(value))
+      return false;
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype === null || prototype === Object.prototype)
+      return true;
+    return Object.getPrototypeOf(prototype) === null && prototype.constructor?.name === "Object";
+  } catch {
+    return false;
+  }
+}
+function name(input) {
+  if (typeof input === "string") {
+    return { name: input, attributes: EMPTY_ATTRIBUTES };
+  }
+  if (isTelemetryEvent(input)) {
+    return { name: input.name, attributes: input.attributes };
+  }
+  try {
+    return { name: input(), attributes: EMPTY_ATTRIBUTES };
+  } catch (failure) {
+    return {
+      name: "[message failed to build]",
+      attributes: {
+        "telemetry.message.invalid": errorInfo(failure, false).type
+      }
+    };
+  }
+}
+// src/span/scope.ts
+class Span {
+  constructor(context, name, kind, stackTraces = true) {
+    this.status = "ok";
+    this.own = {};
+    this.happened = [];
+    this.context = context;
+    this.name = name;
+    this.kind = kind;
+    this.stackTraces = stackTraces;
+  }
+  get traceId() {
+    return this.context.traceId;
+  }
+  get spanId() {
+    return this.context.spanId;
+  }
+  traceparent() {
+    return renderTraceparent(this.context);
+  }
+  attribute(name, value) {
+    this.own[name] = coerceAttribute(value);
+  }
+  attributes(record) {
+    Object.assign(this.own, attributesOf(record));
+  }
+  event(input, attributes) {
+    const declared = isTelemetryEvent(input);
+    this.happened.push({
+      name: declared ? input.name : input,
+      at: Date.now(),
+      attributes: declared ? input.attributes : attributesOf(attributes)
+    });
+  }
+  fail(failure) {
+    if (this.error !== undefined)
+      return;
+    const cancelled = isAbort(failure);
+    this.status = cancelled ? "cancelled" : "error";
+    this.error = errorInfo(failure, !cancelled && this.stackTraces);
+  }
+  record(startedAt, endedAt, parent, inherited) {
+    return {
+      type: "span",
+      name: this.name,
+      context: this.context,
+      ...parent === undefined ? {} : { parent },
+      kind: this.kind,
+      startedAt,
+      endedAt,
+      status: this.status,
+      attributes: { ...mergeAttributes(inherited, this.own) },
+      events: [...this.happened],
+      ...this.error === undefined ? {} : { error: this.error }
+    };
+  }
+}
+// src/span/span.ts
+function span(name, optionsOrBlock, maybeBlock) {
+  const [options, block] = read2(optionsOrBlock, maybeBlock);
+  return open(name, options, block, undefined, "internal");
+}
+function continuing(traceparent, name, optionsOrBlock, maybeBlock) {
+  const [options, block] = read2(optionsOrBlock, maybeBlock);
+  const remote = parseTraceparent(traceparent) ?? undefined;
+  return open(name, options, block, remote, "server");
+}
+async function open(name, options, block, remote, fallbackKind) {
+  const parent = currentContext();
+  const telemetry = parent?.telemetry ?? installedTelemetry();
+  const kind = options.kind ?? fallbackKind;
+  if (telemetry === undefined) {
+    return block(new Span(DETACHED_SPAN_CONTEXT, name, kind));
+  }
+  const parentSpan = remote ?? parent?.span;
+  const traceId = parentSpan?.traceId ?? randomTraceId();
+  const context = {
+    traceId,
+    spanId: randomSpanId(),
+    sampled: parentSpan?.sampled ?? decide(telemetry, traceId),
+    remote: false
+  };
+  const inherited = mergeAttributes(parent?.attributes ?? EMPTY_ATTRIBUTES, attributesOf(options.attributes));
+  const scope = new Span(context, name, kind, telemetry.stackTraces);
+  const startedAt = Date.now();
+  try {
+    return await runWithContext({ telemetry, span: context, attributes: inherited }, () => block(scope));
+  } catch (failure) {
+    try {
+      scope.fail(failure);
+    } catch {
+      scope.status = "error";
+    }
+    throw failure;
+  } finally {
+    if (context.sampled) {
+      telemetry.emit(scope.record(startedAt, Date.now(), parentSpan?.spanId, inherited));
+    }
+  }
+}
+function read2(optionsOrBlock, maybeBlock) {
+  return typeof optionsOrBlock === "function" ? [{}, optionsOrBlock] : [optionsOrBlock, maybeBlock];
+}
+function decide(telemetry, traceId) {
+  try {
+    return telemetry.sampler.sample(traceId);
+  } catch {
+    return false;
+  }
+}
 export {
+  DEFAULT_MAX_SIZE,
+  DEFAULT_ROTATION_PERIOD,
   DETACHED_SPAN_CONTEXT,
   EMPTY_ATTRIBUTES,
+  INVALID_EVENT_ATTRIBUTE,
   INVALID_SPAN_ID,
   INVALID_TRACE_ID,
   SEVERITIES,
   SEVERITY_NUMBER,
   SPAN_KIND_NUMBER,
+  Span,
+  TELEMETRY_DEFAULTS,
+  Telemetry,
+  UNREADABLE,
   alwaysSample,
   attributesOf,
   coerceAttribute,
+  consoleExporter,
+  continuing,
+  createLogger,
+  createTelemetry,
+  currentAttributes,
+  currentContext,
+  currentSpan,
+  currentTraceparent,
+  errorInfo,
+  event,
+  fileExporter,
+  installedTelemetry,
+  isAbort,
   isDetached,
   isEmptyAttributes,
+  isTelemetryEvent,
   isValidSpanId,
   isValidTraceId,
+  jsonLinesExporter,
   meetsSeverity,
   mergeAttributes,
   neverSample,
   parseTraceparent,
+  prunable,
   randomSpanId,
   randomTraceId,
   ratioSampler,
   renderTraceparent,
+  resolveTelemetry,
+  rolledName,
+  rolledOf,
+  rotationDue,
+  runWithContext,
   signalAt,
-  signalSpan
+  signalSpan,
+  span,
+  uninstallTelemetry,
+  withAttributes,
+  withTelemetry
 };
 
-//# debugId=909718EB5895F3DC64756E2164756E21
+//# debugId=48D06AD1E41A02B464756E2164756E21
 //# sourceMappingURL=index.js.map