@zucker-framework/tracing 1.0.0

package/dist/index.js

@@ -0,0 +1,504 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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, {
+  AlwaysOffSampler: () => AlwaysOffSampler,
+  AlwaysOnSampler: () => AlwaysOnSampler,
+  InMemoryTracer: () => InMemoryTracer,
+  ParentBasedSampler: () => ParentBasedSampler,
+  RatioSampler: () => RatioSampler,
+  SamplingDecision: () => SamplingDecision,
+  Span: () => Span,
+  SpanBuilder: () => SpanBuilder,
+  TraceInterceptor: () => TraceInterceptor,
+  TraceMiddleware: () => TraceMiddleware,
+  ZuckerTracingModule: () => ZuckerTracingModule,
+  generateTraceparent: () => generateTraceparent,
+  getSpanId: () => getSpanId,
+  getTraceContext: () => getTraceContext,
+  getTraceId: () => getTraceId,
+  runWithTraceContext: () => runWithTraceContext
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/span.ts
+var import_crypto = require("crypto");
+var Span = class {
+  static {
+    __name(this, "Span");
+  }
+  traceId;
+  spanId;
+  parentSpanId;
+  name;
+  startTime;
+  endTime;
+  attributes;
+  events = [];
+  links = [];
+  status = "UNSET";
+  statusMessage;
+  constructor(name, options) {
+    this.name = name;
+    this.traceId = options?.traceId ?? (0, import_crypto.randomUUID)().replace(/-/g, "");
+    this.spanId = (0, import_crypto.randomUUID)().replace(/-/g, "").substring(0, 16);
+    this.parentSpanId = options?.parentSpanId;
+    this.startTime = /* @__PURE__ */ new Date();
+    this.attributes = options?.attributes ?? {};
+  }
+  setAttribute(key, value) {
+    this.attributes[key] = value;
+    return this;
+  }
+  setAttributes(attrs) {
+    Object.assign(this.attributes, attrs);
+    return this;
+  }
+  addEvent(name, attributes) {
+    this.events.push({
+      name,
+      timestamp: /* @__PURE__ */ new Date(),
+      attributes
+    });
+    return this;
+  }
+  addLink(traceId, spanId, attributes) {
+    this.links.push({
+      traceId,
+      spanId,
+      attributes
+    });
+    return this;
+  }
+  setStatus(status, message) {
+    this.status = status;
+    this.statusMessage = message;
+    return this;
+  }
+  end() {
+    this.endTime = /* @__PURE__ */ new Date();
+  }
+  get duration() {
+    if (!this.endTime) return void 0;
+    return this.endTime.getTime() - this.startTime.getTime();
+  }
+  isRecording() {
+    return !this.endTime;
+  }
+};
+var SpanBuilder = class {
+  static {
+    __name(this, "SpanBuilder");
+  }
+  _name;
+  options = {};
+  _links = [];
+  constructor(name) {
+    this._name = name;
+  }
+  withTraceId(traceId) {
+    this.options.traceId = traceId;
+    return this;
+  }
+  withParentSpanId(parentSpanId) {
+    this.options.parentSpanId = parentSpanId;
+    return this;
+  }
+  withAttribute(key, value) {
+    if (!this.options.attributes) this.options.attributes = {};
+    this.options.attributes[key] = value;
+    return this;
+  }
+  withLink(traceId, spanId, attributes) {
+    this._links.push({
+      traceId,
+      spanId,
+      attributes
+    });
+    return this;
+  }
+  build() {
+    const span = new Span(this._name, this.options);
+    for (const link of this._links) {
+      span.addLink(link.traceId, link.spanId, link.attributes);
+    }
+    return span;
+  }
+};
+
+// src/tracer.ts
+var import_common = require("@nestjs/common");
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata, "_ts_metadata");
+var SamplingDecision = /* @__PURE__ */ (function(SamplingDecision2) {
+  SamplingDecision2["DROP"] = "DROP";
+  SamplingDecision2["RECORD_ONLY"] = "RECORD_ONLY";
+  SamplingDecision2["RECORD_AND_SAMPLE"] = "RECORD_AND_SAMPLE";
+  return SamplingDecision2;
+})({});
+var AlwaysOnSampler = class {
+  static {
+    __name(this, "AlwaysOnSampler");
+  }
+  shouldSample() {
+    return "RECORD_AND_SAMPLE";
+  }
+};
+var AlwaysOffSampler = class {
+  static {
+    __name(this, "AlwaysOffSampler");
+  }
+  shouldSample() {
+    return "DROP";
+  }
+};
+var RatioSampler = class {
+  static {
+    __name(this, "RatioSampler");
+  }
+  ratio;
+  constructor(ratio) {
+    this.ratio = ratio;
+    this.ratio = Math.max(0, Math.min(1, ratio));
+  }
+  shouldSample() {
+    return Math.random() < this.ratio ? "RECORD_AND_SAMPLE" : "DROP";
+  }
+};
+var ParentBasedSampler = class {
+  static {
+    __name(this, "ParentBasedSampler");
+  }
+  root;
+  constructor(root) {
+    this.root = root;
+  }
+  shouldSample(spanName, options) {
+    if (options?.parentSpanId) {
+      return "RECORD_AND_SAMPLE";
+    }
+    return this.root.shouldSample(spanName, options);
+  }
+};
+var InMemoryTracer = class {
+  static {
+    __name(this, "InMemoryTracer");
+  }
+  spans = [];
+  maxSpans = 1e4;
+  sampler;
+  constructor(sampler) {
+    this.sampler = sampler ?? new AlwaysOnSampler();
+  }
+  setSampler(sampler) {
+    this.sampler = sampler;
+  }
+  startSpan(name, options) {
+    const span = new Span(name, options);
+    const decision = this.sampler.shouldSample(name, options);
+    if (decision === "DROP") {
+      return span;
+    }
+    this.spans.push(span);
+    if (this.spans.length > this.maxSpans) {
+      this.spans = this.spans.slice(-this.maxSpans / 2);
+    }
+    return span;
+  }
+  getSpans() {
+    return [
+      ...this.spans
+    ];
+  }
+  getSpansByTraceId(traceId) {
+    return this.spans.filter((s) => s.traceId === traceId);
+  }
+  clear() {
+    this.spans = [];
+  }
+};
+InMemoryTracer = _ts_decorate([
+  (0, import_common.Injectable)(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof Sampler === "undefined" ? Object : Sampler
+  ])
+], InMemoryTracer);
+
+// src/trace-middleware.ts
+var import_common2 = require("@nestjs/common");
+var import_async_hooks = require("async_hooks");
+var import_crypto2 = require("crypto");
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+var traceStorage = new import_async_hooks.AsyncLocalStorage();
+function getTraceId() {
+  return traceStorage.getStore()?.traceId;
+}
+__name(getTraceId, "getTraceId");
+function getSpanId() {
+  return traceStorage.getStore()?.parentSpanId;
+}
+__name(getSpanId, "getSpanId");
+function getTraceContext() {
+  return traceStorage.getStore();
+}
+__name(getTraceContext, "getTraceContext");
+function runWithTraceContext(ctx, fn) {
+  return traceStorage.run(ctx, fn);
+}
+__name(runWithTraceContext, "runWithTraceContext");
+function generateTraceparent(traceId, spanId, sampled = true) {
+  const flags = sampled ? "01" : "00";
+  return `00-${traceId}-${spanId}-${flags}`;
+}
+__name(generateTraceparent, "generateTraceparent");
+function parseTraceparent(header) {
+  const parts = header.split("-");
+  if (parts.length !== 4) return null;
+  const [version, traceId, parentId, flags] = parts;
+  if (version !== "00") return null;
+  if (traceId.length !== 32 || parentId.length !== 16) return null;
+  if (!/^[0-9a-fA-F]{32}$/.test(traceId) || !/^[0-9a-fA-F]{16}$/.test(parentId)) return null;
+  return {
+    traceId,
+    parentSpanId: parentId,
+    traceFlags: flags
+  };
+}
+__name(parseTraceparent, "parseTraceparent");
+var TraceMiddleware = class {
+  static {
+    __name(this, "TraceMiddleware");
+  }
+  use(req, res, next) {
+    const traceparent = req.headers["traceparent"];
+    const tracestate = req.headers["tracestate"];
+    let ctx;
+    if (traceparent) {
+      const parsed = parseTraceparent(traceparent);
+      ctx = parsed ?? {
+        traceId: (0, import_crypto2.randomUUID)().replace(/-/g, ""),
+        traceFlags: "01"
+      };
+    } else {
+      ctx = {
+        traceId: (0, import_crypto2.randomUUID)().replace(/-/g, ""),
+        traceFlags: "01"
+      };
+    }
+    if (tracestate) {
+      ctx.traceState = tracestate;
+    }
+    const spanId = (0, import_crypto2.randomUUID)().replace(/-/g, "").substring(0, 16);
+    res.setHeader("traceparent", generateTraceparent(ctx.traceId, spanId, ctx.traceFlags === "01"));
+    if (ctx.traceState) {
+      res.setHeader("tracestate", ctx.traceState);
+    }
+    traceStorage.run(ctx, () => {
+      next();
+    });
+  }
+};
+TraceMiddleware = _ts_decorate2([
+  (0, import_common2.Injectable)()
+], TraceMiddleware);
+
+// src/trace-interceptor.ts
+var import_common3 = require("@nestjs/common");
+var import_rxjs = require("rxjs");
+var import_operators = require("rxjs/operators");
+function _ts_decorate3(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate3, "_ts_decorate");
+function _ts_metadata2(metadataKey, metadataValue) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") {
+    return Reflect.metadata(metadataKey, metadataValue);
+  }
+}
+__name(_ts_metadata2, "_ts_metadata");
+var TraceInterceptor = class {
+  static {
+    __name(this, "TraceInterceptor");
+  }
+  tracer;
+  constructor(tracer) {
+    this.tracer = tracer;
+  }
+  intercept(context, next) {
+    const request = context.switchToHttp().getRequest();
+    const traceCtx = getTraceContext();
+    const routePath = request.route?.path ?? request.url;
+    const spanName = `${request.method} ${routePath}`;
+    const span = this.tracer.startSpan(spanName, {
+      traceId: traceCtx?.traceId,
+      parentSpanId: traceCtx?.parentSpanId,
+      attributes: {
+        "http.method": request.method,
+        "http.url": request.url,
+        "http.route": routePath,
+        "http.user_agent": request.headers?.["user-agent"],
+        "http.client_ip": request.ip || request.headers?.["x-forwarded-for"] || ""
+      }
+    });
+    return next.handle().pipe((0, import_operators.tap)(() => {
+      const response = context.switchToHttp().getResponse();
+      const statusCode = response?.statusCode ?? 200;
+      span.setAttribute("http.status_code", statusCode);
+      span.setStatus(statusCode < 400 ? "OK" : "ERROR");
+      span.end();
+    }), (0, import_operators.catchError)((error) => {
+      const statusCode = error?.status ?? 500;
+      span.setAttribute("http.status_code", statusCode);
+      span.setAttribute("error.type", error?.constructor?.name ?? "Error");
+      span.setAttribute("error.message", error instanceof Error ? error.message : String(error));
+      span.setStatus("ERROR", error instanceof Error ? error.message : String(error));
+      span.addEvent("exception", {
+        "exception.type": error?.constructor?.name ?? "Error",
+        "exception.message": error instanceof Error ? error.message : String(error),
+        "exception.stacktrace": error instanceof Error ? error.stack : void 0
+      });
+      span.end();
+      return (0, import_rxjs.throwError)(() => error);
+    }));
+  }
+};
+TraceInterceptor = _ts_decorate3([
+  (0, import_common3.Injectable)(),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof InMemoryTracer === "undefined" ? Object : InMemoryTracer
+  ])
+], TraceInterceptor);
+
+// src/tracing.module.ts
+var import_common4 = require("@nestjs/common");
+var import_core = require("@nestjs/core");
+function _ts_decorate4(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
+    r = Reflect.decorate(decorators, target, key, desc);
+  } else {
+    for (var i = decorators.length - 1; i >= 0; i--) {
+      if (d = decorators[i]) {
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+      }
+    }
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate4, "_ts_decorate");
+var ZuckerTracingModule = class _ZuckerTracingModule {
+  static {
+    __name(this, "ZuckerTracingModule");
+  }
+  configure(consumer) {
+    consumer.apply(TraceMiddleware).forRoutes("*");
+  }
+  static forRoot(options) {
+    const sampleRate = options?.sampleRate ?? 1;
+    return {
+      module: _ZuckerTracingModule,
+      global: true,
+      providers: [
+        {
+          provide: InMemoryTracer,
+          useFactory: /* @__PURE__ */ __name(() => {
+            const sampler = new ParentBasedSampler(new RatioSampler(sampleRate));
+            return new InMemoryTracer(sampler);
+          }, "useFactory")
+        },
+        {
+          provide: import_core.APP_INTERCEPTOR,
+          useClass: TraceInterceptor
+        }
+      ],
+      exports: [
+        InMemoryTracer
+      ]
+    };
+  }
+};
+ZuckerTracingModule = _ts_decorate4([
+  (0, import_common4.Global)(),
+  (0, import_common4.Module)({})
+], ZuckerTracingModule);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AlwaysOffSampler,
+  AlwaysOnSampler,
+  InMemoryTracer,
+  ParentBasedSampler,
+  RatioSampler,
+  SamplingDecision,
+  Span,
+  SpanBuilder,
+  TraceInterceptor,
+  TraceMiddleware,
+  ZuckerTracingModule,
+  generateTraceparent,
+  getSpanId,
+  getTraceContext,
+  getTraceId,
+  runWithTraceContext
+});