memorylens 0.1.0

package/dist/index.js

@@ -0,0 +1,492 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BatchSpanProcessor: () => BatchSpanProcessor,
+  ConsoleExporter: () => ConsoleExporter,
+  ExportResult: () => ExportResult,
+  MutableSpan: () => MutableSpan,
+  OTLPExporter: () => OTLPExporter,
+  Sampler: () => Sampler,
+  SimpleSpanProcessor: () => SimpleSpanProcessor,
+  Tracer: () => Tracer,
+  TracerProvider: () => TracerProvider,
+  context: () => context,
+  getCurrentContext: () => getCurrentContext,
+  getTracer: () => getTracer,
+  init: () => init,
+  instrumentCompress: () => instrumentCompress,
+  instrumentRead: () => instrumentRead,
+  instrumentUpdate: () => instrumentUpdate,
+  instrumentWrite: () => instrumentWrite,
+  runWithContext: () => runWithContext,
+  shutdown: () => shutdown
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var ExportResult = /* @__PURE__ */ ((ExportResult2) => {
+  ExportResult2[ExportResult2["SUCCESS"] = 0] = "SUCCESS";
+  ExportResult2[ExportResult2["FAILURE"] = 1] = "FAILURE";
+  return ExportResult2;
+})(ExportResult || {});
+
+// src/context.ts
+var import_node_async_hooks = require("async_hooks");
+var contextStorage = new import_node_async_hooks.AsyncLocalStorage();
+function runWithContext(ctx, fn) {
+  return contextStorage.run(ctx, fn);
+}
+function getCurrentContext() {
+  return contextStorage.getStore();
+}
+
+// src/tracer.ts
+var import_node_crypto = require("crypto");
+
+// src/sampler.ts
+var Sampler = class {
+  rate;
+  constructor(rate = 1) {
+    if (rate < 0 || rate > 1) {
+      throw new Error(`Sample rate must be between 0.0 and 1.0, got ${rate}`);
+    }
+    this.rate = rate;
+  }
+  shouldSample() {
+    if (this.rate === 1) return true;
+    if (this.rate === 0) return false;
+    return Math.random() < this.rate;
+  }
+  getRate() {
+    return this.rate;
+  }
+};
+
+// src/tracer.ts
+var MutableSpan = class {
+  traceId;
+  spanId;
+  operation;
+  parentSpanId;
+  status = "ok";
+  startTime;
+  endTime = 0;
+  agentId;
+  sessionId;
+  userId;
+  inputContent = null;
+  outputContent = null;
+  attributes;
+  constructor(options) {
+    this.traceId = (0, import_node_crypto.randomUUID)().replace(/-/g, "");
+    this.spanId = (0, import_node_crypto.randomUUID)().replace(/-/g, "").substring(0, 16);
+    this.operation = options.operation;
+    this.parentSpanId = options.parentSpanId ?? null;
+    const ctx = getCurrentContext();
+    this.agentId = options.agentId !== void 0 ? options.agentId : ctx?.agentId ?? null;
+    this.sessionId = options.sessionId !== void 0 ? options.sessionId : ctx?.sessionId ?? null;
+    this.userId = options.userId !== void 0 ? options.userId : ctx?.userId ?? null;
+    this.attributes = { ...options.attributes };
+    this.startTime = Date.now();
+  }
+  setAttribute(key, value) {
+    this.attributes[key] = value;
+  }
+  setContent(input, output) {
+    if (input !== void 0) this.inputContent = input;
+    if (output !== void 0) this.outputContent = output;
+  }
+  setStatus(status) {
+    this.status = status;
+  }
+  setError(error) {
+    this.status = "error";
+    if (error instanceof Error) {
+      this.attributes["error.type"] = error.constructor.name;
+      this.attributes["error.message"] = error.message;
+    } else {
+      this.attributes["error.type"] = "Error";
+      this.attributes["error.message"] = String(error);
+    }
+  }
+  end() {
+    this.endTime = Date.now();
+    return {
+      spanId: this.spanId,
+      traceId: this.traceId,
+      parentSpanId: this.parentSpanId,
+      operation: this.operation,
+      status: this.status,
+      startTime: this.startTime,
+      endTime: this.endTime,
+      durationMs: this.endTime - this.startTime,
+      agentId: this.agentId,
+      sessionId: this.sessionId,
+      userId: this.userId,
+      inputContent: this.inputContent,
+      outputContent: this.outputContent,
+      attributes: { ...this.attributes }
+    };
+  }
+};
+var Tracer = class {
+  name;
+  provider;
+  constructor(name, provider) {
+    this.name = name;
+    this.provider = provider;
+  }
+  getName() {
+    return this.name;
+  }
+  startSpan(operation, attributes) {
+    const ctx = getCurrentContext();
+    return new MutableSpan({
+      operation,
+      agentId: ctx?.agentId ?? null,
+      sessionId: ctx?.sessionId ?? null,
+      userId: ctx?.userId ?? null,
+      attributes
+    });
+  }
+  endSpan(span) {
+    const finished = span.end();
+    for (const processor of this.provider.processors) {
+      processor.onEnd(finished);
+    }
+  }
+};
+var TracerProvider = class _TracerProvider {
+  static instance = null;
+  processors = [];
+  sampler = new Sampler(1);
+  serviceName = "memorylens";
+  static get() {
+    if (!_TracerProvider.instance) {
+      _TracerProvider.instance = new _TracerProvider();
+    }
+    return _TracerProvider.instance;
+  }
+  static reset() {
+    if (_TracerProvider.instance) {
+      for (const p of _TracerProvider.instance.processors) {
+        p.shutdown().catch(() => {
+        });
+      }
+    }
+    _TracerProvider.instance = null;
+  }
+  addProcessor(processor) {
+    this.processors.push(processor);
+  }
+  getTracer(name) {
+    return new Tracer(name, this);
+  }
+  async shutdown() {
+    for (const p of this.processors) {
+      await p.shutdown();
+    }
+  }
+};
+
+// src/processor.ts
+var SimpleSpanProcessor = class {
+  exporter;
+  constructor(exporter) {
+    this.exporter = exporter;
+  }
+  onStart(_span) {
+  }
+  onEnd(span) {
+    this.exporter.export([span]);
+  }
+  async shutdown() {
+    await this.exporter.shutdown();
+  }
+  async forceFlush(_timeoutMs) {
+    return true;
+  }
+};
+var BatchSpanProcessor = class {
+  exporter;
+  queue = [];
+  maxBatchSize;
+  scheduleDelayMs;
+  maxQueueSize;
+  timer = null;
+  isShutdown = false;
+  constructor(exporter, options) {
+    this.exporter = exporter;
+    this.maxBatchSize = options?.maxBatchSize ?? 512;
+    this.scheduleDelayMs = options?.scheduleDelayMs ?? 5e3;
+    this.maxQueueSize = options?.maxQueueSize ?? 2048;
+    this.scheduleFlush();
+  }
+  onStart(_span) {
+  }
+  onEnd(span) {
+    if (this.isShutdown) return;
+    if (this.queue.length < this.maxQueueSize) {
+      this.queue.push(span);
+    }
+    if (this.queue.length >= this.maxBatchSize) {
+      this.flush();
+    }
+  }
+  async shutdown() {
+    this.isShutdown = true;
+    if (this.timer) clearTimeout(this.timer);
+    await this.flush();
+    await this.exporter.shutdown();
+  }
+  async forceFlush(_timeoutMs) {
+    await this.flush();
+    return true;
+  }
+  async flush() {
+    if (this.queue.length === 0) return;
+    const batch = this.queue.splice(0, this.maxBatchSize);
+    await this.exporter.export(batch);
+  }
+  scheduleFlush() {
+    this.timer = setTimeout(async () => {
+      await this.flush();
+      if (!this.isShutdown) this.scheduleFlush();
+    }, this.scheduleDelayMs);
+    if (this.timer && typeof this.timer === "object" && "unref" in this.timer) {
+      this.timer.unref();
+    }
+  }
+};
+
+// src/exporters/console.ts
+var ConsoleExporter = class {
+  async export(spans) {
+    for (const span of spans) {
+      console.log(
+        JSON.stringify(
+          {
+            spanId: span.spanId,
+            traceId: span.traceId,
+            parentSpanId: span.parentSpanId,
+            operation: span.operation,
+            status: span.status,
+            startTime: span.startTime,
+            endTime: span.endTime,
+            durationMs: span.durationMs,
+            agentId: span.agentId,
+            sessionId: span.sessionId,
+            userId: span.userId,
+            inputContent: span.inputContent,
+            outputContent: span.outputContent,
+            attributes: span.attributes
+          },
+          null,
+          2
+        )
+      );
+    }
+    return 0 /* SUCCESS */;
+  }
+  async shutdown() {
+  }
+};
+
+// src/exporters/otlp.ts
+var OTLPExporter = class {
+  endpoint;
+  constructor(options) {
+    this.endpoint = options?.endpoint ?? process.env["OTEL_EXPORTER_OTLP_ENDPOINT"] ?? "http://localhost:8000/v1/traces";
+  }
+  async export(spans) {
+    if (spans.length === 0) return 0 /* SUCCESS */;
+    const body = this.buildOTLPPayload(spans);
+    try {
+      const response = await fetch(this.endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        return 1 /* FAILURE */;
+      }
+      return 0 /* SUCCESS */;
+    } catch {
+      return 1 /* FAILURE */;
+    }
+  }
+  async shutdown() {
+  }
+  buildOTLPPayload(spans) {
+    return {
+      resourceSpans: [
+        {
+          resource: {
+            attributes: [
+              {
+                key: "service.name",
+                value: {
+                  stringValue: process.env["OTEL_SERVICE_NAME"] ?? "memorylens"
+                }
+              }
+            ]
+          },
+          scopeSpans: [
+            {
+              scope: { name: "memorylens", version: "0.1.0" },
+              spans: spans.map((span) => this.spanToOTLP(span))
+            }
+          ]
+        }
+      ]
+    };
+  }
+  spanToOTLP(span) {
+    const startTimeUnixNano = String(span.startTime * 1e6);
+    const endTimeUnixNano = String(span.endTime * 1e6);
+    const attributes = [{ key: "memory.operation", value: { stringValue: span.operation } }];
+    if (span.agentId) attributes.push({ key: "agent.id", value: { stringValue: span.agentId } });
+    if (span.sessionId)
+      attributes.push({ key: "session.id", value: { stringValue: span.sessionId } });
+    if (span.userId) attributes.push({ key: "user.id", value: { stringValue: span.userId } });
+    if (span.inputContent)
+      attributes.push({ key: "memory.input", value: { stringValue: span.inputContent } });
+    if (span.outputContent)
+      attributes.push({ key: "memory.output", value: { stringValue: span.outputContent } });
+    for (const [key, val] of Object.entries(span.attributes)) {
+      attributes.push({ key, value: { stringValue: String(val) } });
+    }
+    return {
+      traceId: span.traceId,
+      spanId: span.spanId,
+      parentSpanId: span.parentSpanId ?? void 0,
+      name: span.operation,
+      kind: 1,
+      // SPAN_KIND_INTERNAL
+      startTimeUnixNano,
+      endTimeUnixNano,
+      attributes,
+      status: {
+        code: span.status === "ok" ? 1 : span.status === "error" ? 2 : 0
+      }
+    };
+  }
+};
+
+// src/wrappers.ts
+function createWrapper(operation, fn, options = {}) {
+  const { captureContent = true, ...extraAttrs } = options;
+  const attributes = { ...extraAttrs };
+  return async (...args) => {
+    const provider = TracerProvider.get();
+    if (!provider.sampler.shouldSample()) {
+      return fn(...args);
+    }
+    const tracer = provider.getTracer("memorylens.wrappers");
+    const span = tracer.startSpan(operation, attributes);
+    if (captureContent && args.length > 0) {
+      const firstArg = args[0];
+      if (typeof firstArg === "string") {
+        span.setContent(firstArg, void 0);
+      }
+    }
+    try {
+      const result = await fn(...args);
+      span.setStatus("ok");
+      if (captureContent && result !== void 0) {
+        if (typeof result === "string") {
+          span.setContent(void 0, result);
+        } else if (result !== null && typeof result === "object") {
+          span.setContent(void 0, JSON.stringify(result));
+        }
+      }
+      tracer.endSpan(span);
+      return result;
+    } catch (error) {
+      span.setError(error);
+      tracer.endSpan(span);
+      throw error;
+    }
+  };
+}
+function instrumentWrite(fn, options) {
+  return createWrapper("memory.write", fn, options);
+}
+function instrumentRead(fn, options) {
+  return createWrapper("memory.read", fn, options);
+}
+function instrumentCompress(fn, options) {
+  return createWrapper("memory.compress", fn, options);
+}
+function instrumentUpdate(fn, options) {
+  return createWrapper("memory.update", fn, options);
+}
+
+// src/index.ts
+function init(options = {}) {
+  const {
+    serviceName = process.env["OTEL_SERVICE_NAME"] ?? "memorylens",
+    exporter: exporterType = process.env["MEMORYLENS_EXPORTER"] ?? "otlp",
+    endpoint,
+    sampleRate = parseFloat(process.env["MEMORYLENS_SAMPLE_RATE"] ?? "1.0"),
+    batch = true
+  } = options;
+  const provider = TracerProvider.get();
+  provider.serviceName = serviceName;
+  provider.sampler = new Sampler(sampleRate);
+  const exp = exporterType === "console" ? new ConsoleExporter() : new OTLPExporter({ endpoint });
+  const processor = batch ? new BatchSpanProcessor(exp) : new SimpleSpanProcessor(exp);
+  provider.addProcessor(processor);
+}
+async function shutdown() {
+  const provider = TracerProvider.get();
+  await provider.shutdown();
+  TracerProvider.reset();
+}
+async function context(ctx, fn) {
+  return runWithContext(ctx, fn);
+}
+function getTracer(name) {
+  return TracerProvider.get().getTracer(name);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BatchSpanProcessor,
+  ConsoleExporter,
+  ExportResult,
+  MutableSpan,
+  OTLPExporter,
+  Sampler,
+  SimpleSpanProcessor,
+  Tracer,
+  TracerProvider,
+  context,
+  getCurrentContext,
+  getTracer,
+  init,
+  instrumentCompress,
+  instrumentRead,
+  instrumentUpdate,
+  instrumentWrite,
+  runWithContext,
+  shutdown
+});