@sixb/core 0.0.1

package/dist/chunk-c3zd880g.js

@@ -0,0 +1,629 @@
+// @bun
+import {
+  LOG_LEVELS,
+  SIXB_RUN_KINDS,
+  isLevelEnabled,
+  isLogRecord,
+  normalizeLogError
+} from "./chunk-5yny9z0e.js";
+import {
+  getInvalidJsonValueReason
+} from "./chunk-1vffvydj.js";
+
+// src/logging/console-logger.ts
+var CONSOLE_METHOD = {
+  debug: "debug",
+  info: "info",
+  warn: "warn",
+  error: "error"
+};
+
+class ConsoleLogger {
+  level;
+  constructor(options = {}) {
+    this.level = options.level ?? "info";
+  }
+  write(entry) {
+    if (!isLevelEnabled(entry.level, this.level)) {
+      return;
+    }
+    let suffix = "";
+    try {
+      suffix = ` ${JSON.stringify({
+        ...entry.fields ?? {},
+        sixb: entry.context
+      })}`;
+    } catch {
+      suffix = ` ${JSON.stringify({ sixb: entry.context, sixb_unloggableFields: true })}`;
+    }
+    console[CONSOLE_METHOD[entry.level]](`${entry.level.toUpperCase()} ${entry.message}${suffix}`);
+  }
+}
+var noopLoggerProvider = {
+  write() {}
+};
+var noopLogger = {
+  debug() {},
+  info() {},
+  warn() {},
+  error() {},
+  child() {
+    return noopLogger;
+  }
+};
+// src/logging/record.ts
+var textEncoder = new TextEncoder;
+function sanitizeRecord(entry, options) {
+  const fields = sanitizeFields(entry.fields, options.redactPaths, options.redactCensor);
+  let record = {
+    level: entry.level,
+    message: entry.message,
+    ...fields && Object.keys(fields).length > 0 ? { fields } : {},
+    at: entry.at,
+    context: entry.context
+  };
+  const originalBytes = serializedBytes(record);
+  if (originalBytes <= options.maxBytes) {
+    return record;
+  }
+  record = {
+    ...record,
+    fields: { sixb_truncated: true, originalBytes }
+  };
+  if (serializedBytes(record) <= options.maxBytes) {
+    return record;
+  }
+  const characters = Array.from(record.message);
+  let low = 0;
+  let high = characters.length;
+  while (low < high) {
+    const middle = Math.ceil((low + high) / 2);
+    const candidate = { ...record, message: characters.slice(0, middle).join("") };
+    if (serializedBytes(candidate) <= options.maxBytes) {
+      low = middle;
+    } else {
+      high = middle - 1;
+    }
+  }
+  return { ...record, message: characters.slice(0, low).join("") };
+}
+function serializedBytes(value) {
+  return textEncoder.encode(JSON.stringify(value)).byteLength;
+}
+function sanitizeFields(fields, redactPaths, censor) {
+  if (!fields) {
+    return;
+  }
+  const reason = getInvalidJsonValueReason(fields, "log fields");
+  if (reason) {
+    return { sixb_unloggableFields: reason };
+  }
+  const copy = JSON.parse(JSON.stringify(fields));
+  for (const configuredPath of redactPaths) {
+    const path = configuredPath.startsWith("fields.") ? configuredPath.slice("fields.".length) : configuredPath;
+    redactPath(copy, path.split(".").filter(Boolean), censor);
+  }
+  return copy;
+}
+function redactPath(target, path, censor) {
+  if (path.length === 0 || typeof target !== "object" || target === null) {
+    return;
+  }
+  const [head, ...tail] = path;
+  if (!head) {
+    return;
+  }
+  if (head === "*") {
+    const values = Array.isArray(target) ? target : Object.values(target);
+    if (tail.length === 0) {
+      if (Array.isArray(target)) {
+        target.fill(censor);
+      } else {
+        for (const key of Object.keys(target)) {
+          target[key] = censor;
+        }
+      }
+      return;
+    }
+    for (const value of values) {
+      redactPath(value, tail, censor);
+    }
+    return;
+  }
+  if (Array.isArray(target)) {
+    const index = Number(head);
+    if (!Number.isSafeInteger(index) || index < 0 || index >= target.length) {
+      return;
+    }
+    if (tail.length === 0) {
+      target[index] = censor;
+    } else {
+      redactPath(target[index], tail, censor);
+    }
+    return;
+  }
+  if (!(head in target)) {
+    return;
+  }
+  if (tail.length === 0) {
+    target[head] = censor;
+  } else {
+    redactPath(target[head], tail, censor);
+  }
+}
+
+// src/logging/run-logger.ts
+class RunLogSession {
+  options;
+  logger;
+  captured = 0;
+  droppedByLineLimit = 0;
+  droppedByBackpressure = 0;
+  pending = [];
+  pendingBytes = 0;
+  bufferedBytes = 0;
+  pumpPromise;
+  flushPromise;
+  flushTimer;
+  captureClosed = false;
+  providerFailureReported = false;
+  publisherFailureReported = false;
+  emitFromContext = (level, message, fields, context) => {
+    this.emit(level, message, fields, context);
+  };
+  constructor(options) {
+    this.options = options;
+    this.logger = new ContextLogger(this.emitFromContext, {}, {});
+  }
+  withContext(context) {
+    return new ContextLogger(this.emitFromContext, {}, { ...context });
+  }
+  flush() {
+    this.flushPromise ??= this.flushCapture();
+    return this.flushPromise;
+  }
+  emit(level, message, fields, context) {
+    const entry = {
+      level,
+      message,
+      ...fields && safeKeys(fields).length > 0 ? { fields } : {},
+      at: new Date().toISOString(),
+      context: { ...context, run: this.options.run }
+    };
+    this.writeToProvider(entry);
+    const capture = this.options.capture;
+    if (this.captureClosed || !capture || !isLevelEnabled(level, capture.level)) {
+      return;
+    }
+    if (this.captured >= capture.maxLinesPerExecution) {
+      this.droppedByLineLimit += 1;
+      return;
+    }
+    const record = sanitizeRecord(entry, {
+      maxBytes: capture.maxRecordBytes,
+      redactPaths: capture.redactPaths,
+      redactCensor: capture.redactCensor
+    });
+    const bytes = serializedBytes(record);
+    if (this.bufferedBytes + bytes > capture.maxBufferedBytes) {
+      this.droppedByBackpressure += 1;
+      return;
+    }
+    this.captured += 1;
+    this.pending.push({ record, bytes });
+    this.pendingBytes += bytes;
+    this.bufferedBytes += bytes;
+    if (this.pending.length >= capture.batchMaxRecords || this.pendingBytes >= capture.batchMaxBytes) {
+      this.startPump();
+    } else {
+      this.scheduleFlush();
+    }
+  }
+  async flushCapture() {
+    this.captureClosed = true;
+    this.startPump();
+    await this.drain();
+    this.enqueueTruncationMarker();
+    this.startPump();
+    await this.drain();
+  }
+  async drain() {
+    while (this.pumpPromise || this.pending.length > 0) {
+      this.startPump();
+      const pump = this.pumpPromise;
+      if (!pump) {
+        return;
+      }
+      await pump;
+    }
+  }
+  writeToProvider(entry) {
+    try {
+      this.options.provider.write(entry);
+    } catch (error) {
+      if (!this.providerFailureReported) {
+        this.providerFailureReported = true;
+        reportLoggingFailure("output provider", error);
+      }
+    }
+  }
+  enqueueTruncationMarker() {
+    const capture = this.options.capture;
+    const droppedLines = this.droppedByLineLimit + this.droppedByBackpressure;
+    if (droppedLines === 0 || !capture) {
+      return;
+    }
+    const marker = sanitizeRecord({
+      level: "warn",
+      message: "log truncated",
+      fields: {
+        droppedLines,
+        lineLimit: this.droppedByLineLimit,
+        backpressure: this.droppedByBackpressure
+      },
+      at: new Date().toISOString(),
+      context: { run: this.options.run }
+    }, {
+      maxBytes: capture.maxRecordBytes,
+      redactPaths: [],
+      redactCensor: capture.redactCensor
+    });
+    const bytes = serializedBytes(marker);
+    if (bytes > capture.maxBufferedBytes) {
+      reportLoggingFailure("broker capture", new Error("The log truncation marker exceeds the internal capture buffer bound."));
+      return;
+    }
+    this.pending.push({ record: marker, bytes });
+    this.pendingBytes += bytes;
+    this.bufferedBytes += bytes;
+  }
+  scheduleFlush() {
+    if (this.flushTimer !== undefined) {
+      return;
+    }
+    const delay = this.options.capture?.batchMaxDelayMs;
+    if (delay === undefined) {
+      return;
+    }
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = undefined;
+      this.startPump();
+    }, delay);
+  }
+  startPump() {
+    if (this.flushTimer !== undefined) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = undefined;
+    }
+    const publish = this.options.capture?.publish;
+    if (this.pending.length === 0 || !publish || this.pumpPromise) {
+      return;
+    }
+    this.pumpPromise = this.pump(publish).finally(() => {
+      this.pumpPromise = undefined;
+      if (this.pending.length > 0) {
+        this.startPump();
+      }
+    });
+  }
+  async pump(publish) {
+    while (this.pending.length > 0) {
+      const batch = this.takeBatch();
+      try {
+        await publish(batch.records);
+      } catch (error) {
+        if (!this.publisherFailureReported) {
+          this.publisherFailureReported = true;
+          reportLoggingFailure("broker capture", error);
+        }
+      } finally {
+        this.bufferedBytes -= batch.bytes;
+      }
+    }
+  }
+  takeBatch() {
+    const capture = this.options.capture;
+    if (!capture) {
+      return { records: [], bytes: 0 };
+    }
+    let count = 0;
+    let bytes = 0;
+    while (count < this.pending.length && count < capture.batchMaxRecords) {
+      const next = this.pending[count];
+      if (count > 0 && bytes + next.bytes > capture.batchMaxBytes) {
+        break;
+      }
+      bytes += next.bytes;
+      count += 1;
+    }
+    const items = this.pending.splice(0, count);
+    this.pendingBytes -= bytes;
+    return { records: items.map((item) => item.record), bytes };
+  }
+}
+
+class ContextLogger {
+  emit;
+  fields;
+  context;
+  constructor(emit, fields, context) {
+    this.emit = emit;
+    this.fields = fields;
+    this.context = context;
+  }
+  debug(message, fields) {
+    this.safeEmit("debug", message, fields);
+  }
+  info(message, fields) {
+    this.safeEmit("info", message, fields);
+  }
+  warn(message, fields) {
+    this.safeEmit("warn", message, fields);
+  }
+  error(message, fields) {
+    try {
+      const normalized = normalizeLogError(message, this.merge(fields));
+      this.emit("error", normalized.message, normalized.fields, this.context);
+    } catch (error) {
+      reportLoggingFailure("handler fa\xE7ade", error);
+    }
+  }
+  child(bindings) {
+    try {
+      return new ContextLogger(this.emit, { ...this.fields, ...bindings }, this.context);
+    } catch (error) {
+      reportLoggingFailure("handler fa\xE7ade", error);
+      return this;
+    }
+  }
+  safeEmit(level, message, fields) {
+    try {
+      this.emit(level, message, this.merge(fields), this.context);
+    } catch (error) {
+      reportLoggingFailure("handler fa\xE7ade", error);
+    }
+  }
+  merge(fields) {
+    if (!fields || safeKeys(fields).length === 0) {
+      return safeKeys(this.fields).length > 0 ? this.fields : undefined;
+    }
+    return { ...this.fields, ...fields };
+  }
+}
+function safeKeys(value) {
+  try {
+    return Object.keys(value);
+  } catch {
+    return [];
+  }
+}
+function reportLoggingFailure(destination, error) {
+  try {
+    console.error(`[Sixb] Logging ${destination} failed:`, error);
+  } catch {}
+}
+
+// src/logging/stream.ts
+var THIRTY_DAYS_MS = 30 * 24 * 60 * 60 * 1000;
+var DEFAULT_LOGS_MAX_BYTES = 256 * 1024 * 1024;
+var DEFAULT_LOGS_RETENTION = {
+  maxAgeMs: THIRTY_DAYS_MS,
+  maxRecords: 1e5,
+  maxBytes: DEFAULT_LOGS_MAX_BYTES
+};
+var LOGS_STREAM = {
+  id: "__logs",
+  retention: DEFAULT_LOGS_RETENTION
+};
+var DEFAULT_MAX_LINES_PER_EXECUTION = 1e4;
+var DEFAULT_MAX_LOG_RECORD_BYTES = 64 * 1024;
+var DEFAULT_LOG_BATCH_MAX_RECORDS = 64;
+var DEFAULT_LOG_BATCH_MAX_BYTES = 256 * 1024;
+var DEFAULT_LOG_BATCH_MAX_DELAY_MS = 10;
+var DEFAULT_LOG_MAX_BUFFERED_BYTES = 1024 * 1024;
+
+// src/logging/runtime.ts
+class LogsRuntime {
+  projectId;
+  broker;
+  provider;
+  captureEnabled;
+  captureLevel;
+  maxLinesPerExecution;
+  redactPaths;
+  redactCensor;
+  stream;
+  ensureStreamPromise;
+  constructor(options) {
+    const config = options.observability ?? {};
+    this.projectId = options.projectId;
+    this.broker = options.broker;
+    this.provider = options.logger ?? noopLoggerProvider;
+    this.captureEnabled = config.enabled ?? true;
+    this.captureLevel = logLevel(config.level ?? "info", "observability.logs.level");
+    this.maxLinesPerExecution = nonNegativeInteger(config.maxLinesPerExecution ?? DEFAULT_MAX_LINES_PER_EXECUTION, "observability.logs.maxLinesPerExecution");
+    this.redactPaths = normalizeRedactPaths(config.redact?.paths ?? []);
+    this.redactCensor = config.redact?.censor ?? "[REDACTED]";
+    const censorReason = getInvalidJsonValueReason(this.redactCensor, "observability.logs.redact.censor");
+    if (censorReason) {
+      throw new TypeError(censorReason);
+    }
+    this.stream = options.stream ?? {
+      ...LOGS_STREAM,
+      retention: mergeLogsRetention(config.retention)
+    };
+  }
+  startExecution(run) {
+    const publish = this.publisher();
+    return new RunLogSession({
+      run,
+      provider: this.provider,
+      capture: publish ? {
+        publish,
+        level: this.captureLevel,
+        maxLinesPerExecution: this.maxLinesPerExecution,
+        maxRecordBytes: DEFAULT_MAX_LOG_RECORD_BYTES,
+        maxBufferedBytes: DEFAULT_LOG_MAX_BUFFERED_BYTES,
+        batchMaxRecords: DEFAULT_LOG_BATCH_MAX_RECORDS,
+        batchMaxBytes: DEFAULT_LOG_BATCH_MAX_BYTES,
+        batchMaxDelayMs: DEFAULT_LOG_BATCH_MAX_DELAY_MS,
+        redactPaths: this.redactPaths,
+        redactCensor: this.redactCensor
+      } : undefined
+    });
+  }
+  async read(input = {}) {
+    if (!this.broker || input.limit !== undefined && input.limit <= 0) {
+      return { lines: [], cursor: input.afterCursor, hasMore: false };
+    }
+    await this.ensureStream();
+    const page = await this.broker.read({
+      projectId: this.projectId,
+      streamId: this.stream.id,
+      afterCursor: input.afterCursor,
+      limit: input.limit,
+      names: logRecordNames(input.kinds, input.levels, input.run),
+      keys: input.run ? [`${input.run.kind}:${input.run.id}`] : undefined
+    });
+    return {
+      lines: page.records.map(hydrateLogRecord),
+      cursor: page.cursor,
+      hasMore: page.hasMore
+    };
+  }
+  async tail(input = {}) {
+    if (!this.broker || input.limit !== undefined && input.limit <= 0) {
+      return { lines: [], cursor: input.beforeCursor, hasMore: false };
+    }
+    await this.ensureStream();
+    const page = await this.broker.tail({
+      projectId: this.projectId,
+      streamId: this.stream.id,
+      beforeCursor: input.beforeCursor,
+      limit: input.limit,
+      names: logRecordNames(input.kinds, input.levels, input.run),
+      keys: input.run ? [`${input.run.kind}:${input.run.id}`] : undefined
+    });
+    return {
+      lines: page.records.map(hydrateLogRecord),
+      cursor: page.cursor,
+      hasMore: page.hasMore
+    };
+  }
+  async subscribe(input, handler) {
+    const broker = this.broker;
+    if (!broker) {
+      return () => {
+        return;
+      };
+    }
+    await this.ensureStream();
+    return broker.subscribe({
+      projectId: this.projectId,
+      streamId: this.stream.id,
+      from: input.from,
+      afterCursor: input.afterCursor,
+      names: logRecordNames(input.kinds, input.levels, input.run),
+      keys: input.run ? [`${input.run.kind}:${input.run.id}`] : undefined
+    }, (records) => {
+      const lines = records.map(hydrateLogRecord);
+      if (lines.length === 0)
+        return;
+      try {
+        handler(lines);
+      } catch {}
+    });
+  }
+  async flush() {
+    await this.provider.flush?.();
+  }
+  async close() {
+    if (this.provider.close) {
+      await this.provider.close();
+      return;
+    }
+    await this.provider.flush?.();
+  }
+  publisher() {
+    const broker = this.broker;
+    if (!broker || !this.captureEnabled) {
+      return;
+    }
+    return async (records) => {
+      await this.ensureStream();
+      await broker.append({
+        projectId: this.projectId,
+        streamId: this.stream.id,
+        records: records.map((record) => ({
+          name: `${record.context.run.kind}.${record.level}`,
+          key: `${record.context.run.kind}:${record.context.run.id}`,
+          payload: record
+        }))
+      });
+    };
+  }
+  ensureStream() {
+    const broker = this.broker;
+    if (!broker) {
+      return Promise.resolve();
+    }
+    if (!this.ensureStreamPromise) {
+      this.ensureStreamPromise = broker.ensureStream({ projectId: this.projectId, stream: this.stream }).catch((error) => {
+        this.ensureStreamPromise = undefined;
+        throw error;
+      });
+    }
+    return this.ensureStreamPromise;
+  }
+}
+function resolveLogsRuntime(projectId, logs) {
+  return logs ?? new LogsRuntime({ projectId, logger: noopLoggerProvider });
+}
+function normalizeRedactPaths(paths) {
+  const normalized = new Set;
+  for (const path of paths) {
+    if (typeof path !== "string" || path.trim().length === 0) {
+      throw new TypeError("observability.logs.redact.paths must contain non-empty strings");
+    }
+    normalized.add(path.trim());
+  }
+  return [...normalized];
+}
+function mergeLogsRetention(retention) {
+  return {
+    maxAgeMs: nonNegativeInteger(retention?.maxAgeMs ?? DEFAULT_LOGS_RETENTION.maxAgeMs, "observability.logs.retention.maxAgeMs"),
+    maxRecords: nonNegativeInteger(retention?.maxRecords ?? DEFAULT_LOGS_RETENTION.maxRecords, "observability.logs.retention.maxRecords"),
+    maxBytes: nonNegativeInteger(retention?.maxBytes ?? DEFAULT_LOGS_RETENTION.maxBytes, "observability.logs.retention.maxBytes")
+  };
+}
+function logLevel(value, path) {
+  if (value !== "debug" && value !== "info" && value !== "warn" && value !== "error") {
+    throw new TypeError(`${path} must be one of: debug, info, warn, error`);
+  }
+  return value;
+}
+function nonNegativeInteger(value, path) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new TypeError(`${path} must be a non-negative safe integer`);
+  }
+  return value;
+}
+function logRecordNames(kinds, levels, run) {
+  const selectedKinds = run ? [run.kind] : kinds;
+  if ((!selectedKinds || selectedKinds.length === 0) && (!levels || levels.length === 0)) {
+    return;
+  }
+  const resolvedKinds = selectedKinds && selectedKinds.length > 0 ? selectedKinds : SIXB_RUN_KINDS;
+  const resolvedLevels = levels && levels.length > 0 ? levels : LOG_LEVELS;
+  return resolvedKinds.flatMap((kind) => resolvedLevels.map((level) => `${kind}.${level}`));
+}
+function hydrateLogRecord(record) {
+  const payload = record.payload;
+  if (!isLogRecord(payload)) {
+    throw new Error(`[Sixb] Broker record at cursor '${record.cursor}' is not a log line.`);
+  }
+  return { ...payload, cursor: record.cursor };
+}
+export { ConsoleLogger, noopLoggerProvider, noopLogger, DEFAULT_LOGS_MAX_BYTES, DEFAULT_LOGS_RETENTION, LOGS_STREAM, LogsRuntime, resolveLogsRuntime };
+
+//# debugId=9C47EFE3BB2FCD6764756E2164756E21