@zucker-framework/tracing 1.0.0

package/dist/index.mjs

@@ -0,0 +1,464 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/span.ts
+import { randomUUID } from "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 ?? randomUUID().replace(/-/g, "");
+    this.spanId = 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
+import { Injectable } from "@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([
+  Injectable(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof Sampler === "undefined" ? Object : Sampler
+  ])
+], InMemoryTracer);
+
+// src/trace-middleware.ts
+import { Injectable as Injectable2 } from "@nestjs/common";
+import { AsyncLocalStorage } from "async_hooks";
+import { randomUUID as randomUUID2 } from "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 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: randomUUID2().replace(/-/g, ""),
+        traceFlags: "01"
+      };
+    } else {
+      ctx = {
+        traceId: randomUUID2().replace(/-/g, ""),
+        traceFlags: "01"
+      };
+    }
+    if (tracestate) {
+      ctx.traceState = tracestate;
+    }
+    const spanId = randomUUID2().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([
+  Injectable2()
+], TraceMiddleware);
+
+// src/trace-interceptor.ts
+import { Injectable as Injectable3 } from "@nestjs/common";
+import { throwError } from "rxjs";
+import { tap, catchError } from "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(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();
+    }), 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 throwError(() => error);
+    }));
+  }
+};
+TraceInterceptor = _ts_decorate3([
+  Injectable3(),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof InMemoryTracer === "undefined" ? Object : InMemoryTracer
+  ])
+], TraceInterceptor);
+
+// src/tracing.module.ts
+import { Module, Global } from "@nestjs/common";
+import { APP_INTERCEPTOR } from "@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: APP_INTERCEPTOR,
+          useClass: TraceInterceptor
+        }
+      ],
+      exports: [
+        InMemoryTracer
+      ]
+    };
+  }
+};
+ZuckerTracingModule = _ts_decorate4([
+  Global(),
+  Module({})
+], ZuckerTracingModule);
+export {
+  AlwaysOffSampler,
+  AlwaysOnSampler,
+  InMemoryTracer,
+  ParentBasedSampler,
+  RatioSampler,
+  SamplingDecision,
+  Span,
+  SpanBuilder,
+  TraceInterceptor,
+  TraceMiddleware,
+  ZuckerTracingModule,
+  generateTraceparent,
+  getSpanId,
+  getTraceContext,
+  getTraceId,
+  runWithTraceContext
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@zucker-framework/tracing",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "LICENSE",
+    "NOTICE",
+    "THIRD_PARTY_NOTICES"
+  ],
+  "dependencies": {
+    "@zucker-framework/core": "1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.43"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^12.0.0",
+    "@nestjs/core": "^12.0.0",
+    "rxjs": "^7.0.0"
+  },
+  "license": "Apache-2.0",
+  "author": "Lind",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Lind-pro/zucker-framework.git",
+    "directory": "packages/tracing"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "clean": "rm -rf dist",
+    "lint": "eslint src/"
+  }
+}