@devopsplaybook.io/otel-utils-fastify 0.0.1-beta1 → 0.0.1-beta2

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./src/StandardTracerFastify";

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+// Entry point for the otel-utils npm package
+// Export all modules from src
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./src/StandardTracerFastify"), exports);

package/dist/src/StandardTracerFastify.d.ts

@@ -0,0 +1,4 @@
+import { ConfigInterfaceOTel } from "@devopsplaybook.io/otel-utils";
+import { FastifyInstance } from "fastify";
+export declare function StandardTracerFastifyRegisterHooks(fastify: FastifyInstance, config: ConfigInterfaceOTel): Promise<void>;
+export declare function StandardTracerFastifyInit(fastify: FastifyInstance): void;

package/dist/src/StandardTracerFastify.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StandardTracerFastifyRegisterHooks = StandardTracerFastifyRegisterHooks;
+exports.StandardTracerFastifyInit = StandardTracerFastifyInit;
+const otel_utils_1 = require("@devopsplaybook.io/otel-utils");
+const api_1 = require("@opentelemetry/api");
+const core_1 = require("@opentelemetry/core");
+const sdk_node_1 = require("@opentelemetry/sdk-node");
+const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+const propagator = new core_1.W3CTraceContextPropagator();
+const logger = new otel_utils_1.Logger("StandardTracerFastify");
+async function StandardTracerFastifyRegisterHooks(fastify, config) {
+    fastify.addHook("onRequest", async (req) => {
+        if (req.url.indexOf("/api") !== 0) {
+            return;
+        }
+        let spanName = `${req.method}-${req.url}`;
+        let urlName = req.url;
+        if (config.OPENTELEMETRY_COLLECTOR_AWS) {
+            spanName = `${config.SERVICE_ID}-${config.VERSION}`;
+            urlName = `${config.SERVICE_ID}-${config.VERSION}-${req.method}-${req.url}`;
+        }
+        const callerContext = propagator.extract(api_1.ROOT_CONTEXT, req.headers, api_1.defaultTextMapGetter);
+        sdk_node_1.api.context.with(callerContext, () => {
+            const span = (0, otel_utils_1.StandardTracerStartSpan)(spanName);
+            span.setAttribute(semantic_conventions_1.ATTR_HTTP_REQUEST_METHOD, req.method);
+            span.setAttribute(semantic_conventions_1.ATTR_URL_PATH, urlName);
+            /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+            req.tracerSpanApi = span;
+        });
+    });
+    fastify.addHook("onResponse", async (req, reply) => {
+        /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+        const span = req.tracerSpanApi;
+        if (reply.statusCode > 299) {
+            span.status.code = api_1.SpanStatusCode.ERROR;
+        }
+        else {
+            span.status.code = api_1.SpanStatusCode.OK;
+        }
+        span.setAttribute(semantic_conventions_1.ATTR_HTTP_RESPONSE_STATUS_CODE, reply.statusCode);
+        span.end();
+    });
+    fastify.addHook("onError", async (req, reply, error) => {
+        /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+        const span = req.tracerSpanApi;
+        span.status.code = api_1.SpanStatusCode.ERROR;
+        span.recordException(error);
+        logger.error(error);
+    });
+}
+function StandardTracerFastifyInit(fastify) {
+    fastify.addHook("onRequest", async (req) => {
+        const spanName = `${req.method}-${req.url}`;
+        const urlName = req.url;
+        const callerContext = propagator.extract(api_1.ROOT_CONTEXT, req.headers, api_1.defaultTextMapGetter);
+        sdk_node_1.api.context.with(callerContext, () => {
+            const span = (0, otel_utils_1.StandardTracerStartSpan)(spanName);
+            span.setAttribute(semantic_conventions_1.ATTR_HTTP_REQUEST_METHOD, req.method);
+            span.setAttribute(semantic_conventions_1.ATTR_URL_PATH, urlName);
+            /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+            req.tracerSpanApi = span;
+        });
+    });
+    fastify.addHook("onResponse", async (req, reply) => {
+        /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+        const span = req.tracerSpanApi;
+        if (reply.statusCode > 299) {
+            span.status.code = api_1.SpanStatusCode.ERROR;
+        }
+        else {
+            span.status.code = api_1.SpanStatusCode.OK;
+        }
+        span.setAttribute(semantic_conventions_1.ATTR_HTTP_RESPONSE_STATUS_CODE, reply.statusCode);
+        span.end();
+    });
+    fastify.addHook("onError", async (req, reply, error) => {
+        /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+        const span = req.tracerSpanApi;
+        span.status.code = api_1.SpanStatusCode.ERROR;
+        span.recordException(error);
+    });
+}

package/eslint.config.mjs

@@ -0,0 +1,10 @@
+// @ts-check
+
+import eslint from "@eslint/js";
+import tseslint from "typescript-eslint";
+
+export default tseslint.config(
+  eslint.configs.recommended,
+  ...tseslint.configs.strict,
+  ...tseslint.configs.stylistic
+);

package/index.ts

@@ -1,7 +1,4 @@
 // Entry point for the otel-utils npm package
 // Export all modules from src
 
-export * from "./src/Logger";
-export * from "./src/StandardMeter";
-export * from "./src/StandardTracer";
-export * from "./src/models/ConfigInterfaceOTel";
+export * from "./src/StandardTracerFastify";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devopsplaybook.io/otel-utils-fastify",
-  "version": "0.0.1-beta1",
+  "version": "0.0.1-beta2",
   "description": "Utility to simplify integration with Open Telemetry for Fastify API Server",
   "keywords": [
     "Open",
@@ -20,11 +20,15 @@
   },
   "dependencies": {
     "fastify": "^5.5.0",
-    "@devopsplaybook.io/otel-utils": "1.0.1-beta3"
+    "@devopsplaybook.io/otel-utils": "1.0.1-beta4"
   },
   "devDependencies": {
+    "@eslint/js": "^9.34.0",
     "@types/node": "^24.3.0",
-    "@types/sqlite3": "^5.1.0"
+    "@types/sqlite3": "^5.1.0",
+    "ts-node": "^10.9.2",
+    "typescript-eslint": "^8.40.0",
+    "typescript": "^5.9.2"
   },
   "publishConfig": {
     "access": "public"

package/prettierrc.json

@@ -0,0 +1,5 @@
+{
+  "tabWidth": 2,
+  "semi": true,
+  "singleQuote": false
+}

package/src/StandardTracerFastify.ts

@@ -0,0 +1,110 @@
+import {
+  ConfigInterfaceOTel,
+  Logger,
+  StandardTracerStartSpan,
+} from "@devopsplaybook.io/otel-utils";
+import {
+  defaultTextMapGetter,
+  ROOT_CONTEXT,
+  SpanStatusCode,
+} from "@opentelemetry/api";
+import { W3CTraceContextPropagator } from "@opentelemetry/core";
+import { api } from "@opentelemetry/sdk-node";
+import { Span } from "@opentelemetry/sdk-trace-base";
+import {
+  ATTR_HTTP_REQUEST_METHOD,
+  ATTR_HTTP_RESPONSE_STATUS_CODE,
+  ATTR_URL_PATH,
+} from "@opentelemetry/semantic-conventions";
+import { FastifyInstance } from "fastify";
+
+const propagator = new W3CTraceContextPropagator();
+const logger = new Logger("StandardTracerFastify");
+
+export async function StandardTracerFastifyRegisterHooks(
+  fastify: FastifyInstance,
+  config: ConfigInterfaceOTel
+): Promise<void> {
+  fastify.addHook("onRequest", async (req) => {
+    if (req.url.indexOf("/api") !== 0) {
+      return;
+    }
+
+    let spanName = `${req.method}-${req.url}`;
+    let urlName = req.url;
+    if (config.OPENTELEMETRY_COLLECTOR_AWS) {
+      spanName = `${config.SERVICE_ID}-${config.VERSION}`;
+      urlName = `${config.SERVICE_ID}-${config.VERSION}-${req.method}-${req.url}`;
+    }
+    const callerContext = propagator.extract(
+      ROOT_CONTEXT,
+      req.headers,
+      defaultTextMapGetter
+    );
+    api.context.with(callerContext, () => {
+      const span = StandardTracerStartSpan(spanName);
+      span.setAttribute(ATTR_HTTP_REQUEST_METHOD, req.method);
+      span.setAttribute(ATTR_URL_PATH, urlName);
+      /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+      (req as any).tracerSpanApi = span;
+    });
+  });
+
+  fastify.addHook("onResponse", async (req, reply) => {
+    /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+    const span = (req as any).tracerSpanApi as Span;
+    if (reply.statusCode > 299) {
+      span.status.code = SpanStatusCode.ERROR;
+    } else {
+      span.status.code = SpanStatusCode.OK;
+    }
+    span.setAttribute(ATTR_HTTP_RESPONSE_STATUS_CODE, reply.statusCode);
+    span.end();
+  });
+
+  fastify.addHook("onError", async (req, reply, error) => {
+    /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+    const span = (req as any).tracerSpanApi as Span;
+    span.status.code = SpanStatusCode.ERROR;
+    span.recordException(error);
+    logger.error(error);
+  });
+}
+
+export function StandardTracerFastifyInit(fastify: FastifyInstance) {
+  fastify.addHook("onRequest", async (req) => {
+    const spanName = `${req.method}-${req.url}`;
+    const urlName = req.url;
+    const callerContext = propagator.extract(
+      ROOT_CONTEXT,
+      req.headers,
+      defaultTextMapGetter
+    );
+    api.context.with(callerContext, () => {
+      const span = StandardTracerStartSpan(spanName);
+      span.setAttribute(ATTR_HTTP_REQUEST_METHOD, req.method);
+      span.setAttribute(ATTR_URL_PATH, urlName);
+      /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+      (req as any).tracerSpanApi = span;
+    });
+  });
+
+  fastify.addHook("onResponse", async (req, reply) => {
+    /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+    const span = (req as any).tracerSpanApi as Span;
+    if (reply.statusCode > 299) {
+      span.status.code = SpanStatusCode.ERROR;
+    } else {
+      span.status.code = SpanStatusCode.OK;
+    }
+    span.setAttribute(ATTR_HTTP_RESPONSE_STATUS_CODE, reply.statusCode);
+    span.end();
+  });
+
+  fastify.addHook("onError", async (req, reply, error) => {
+    /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+    const span = (req as any).tracerSpanApi as Span;
+    span.status.code = SpanStatusCode.ERROR;
+    span.recordException(error);
+  });
+}

package/src/Logger.ts

@@ -1,120 +0,0 @@
-import type { Logger as OTelLogger } from "@opentelemetry/api-logs";
-import { SeverityNumber } from "@opentelemetry/api-logs";
-import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
-import { resourceFromAttributes } from "@opentelemetry/resources";
-import {
-  BatchLogRecordProcessor,
-  LoggerProvider,
-} from "@opentelemetry/sdk-logs";
-import { Span } from "@opentelemetry/sdk-trace-base";
-import {
-  ATTR_NETWORK_LOCAL_ADDRESS,
-  ATTR_SERVICE_NAME,
-  ATTR_SERVICE_VERSION,
-} from "@opentelemetry/semantic-conventions";
-import * as os from "os";
-import { ConfigInterfaceOTel } from "./models/ConfigInterfaceOTel";
-import { StandardTracerStartSpan } from "./StandardTracer";
-
-let loggerOTel: OTelLogger;
-
-export function LoggerInit(context: Span, config: ConfigInterfaceOTel) {
-  const span = StandardTracerStartSpan("LoggerInit", context);
-
-  if (config.OPENTELEMETRY_COLLECTOR_HTTP_LOGS) {
-    const exporterHeaders: Record<string, string> = {};
-    if (config.OPENTELEMETRY_COLLECT_AUTHORIZATION_HEADER) {
-      exporterHeaders[
-        "Authorization"
-      ] = `Bearer ${config.OPENTELEMETRY_COLLECT_AUTHORIZATION_HEADER}`;
-    }
-    const exporter = new OTLPLogExporter({
-      url: config.OPENTELEMETRY_COLLECTOR_HTTP_LOGS,
-      headers: exporterHeaders,
-    });
-
-    const loggerProvider = new LoggerProvider({
-      processors: [
-        new BatchLogRecordProcessor(exporter, {
-          maxQueueSize: 100,
-          scheduledDelayMillis:
-            config.OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_INTERVAL_SECONDS * 1000,
-        }),
-      ],
-      resource: resourceFromAttributes({
-        [ATTR_SERVICE_NAME]: `${config.SERVICE_ID}`,
-        [ATTR_SERVICE_VERSION]: `${config.VERSION}`,
-        [ATTR_NETWORK_LOCAL_ADDRESS]: os.hostname(),
-      }),
-    });
-
-    loggerOTel = loggerProvider.getLogger(
-      `${config.SERVICE_ID}:${config.VERSION}`
-    );
-  }
-  span.end();
-}
-
-const DEV_MODE = (() => {
-  if (process.env.NODE_ENV === "dev") {
-    return true;
-  }
-  return false;
-})();
-
-export class Logger {
-  private module: string;
-
-  constructor(module: string) {
-    this.module = `${module}`;
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  public debug(message: Error | string | any): void {
-    if (DEV_MODE) {
-      this.display("debug", message, SeverityNumber.DEBUG);
-    }
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  public info(message: Error | string | any): void {
-    this.display("info", message, SeverityNumber.WARN);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  public warn(message: Error | string | any): void {
-    this.display("warn", message, SeverityNumber.WARN);
-  }
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  public error(message: Error | string | any): void {
-    this.display("error", message, SeverityNumber.ERROR);
-  }
-
-  private display(
-    level: string,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    message: any,
-    severityNumber = SeverityNumber.INFO
-  ): void {
-    if (typeof message === "string") {
-      // eslint:disable-next-line:no-console
-      console.log(`[${level}] [${this.module}] ${message}`);
-    } else if (message instanceof Error) {
-      // eslint:disable-next-line:no-console
-      console.log(`${level} [${this.module}] ${message}`);
-      // eslint:disable-next-line:no-console
-      console.log((message as Error).stack);
-    } else if (typeof message === "object") {
-      // eslint:disable-next-line:no-console
-      console.log(`${level} [${this.module}] ${JSON.stringify(message)}`);
-    }
-    if (loggerOTel) {
-      {
-        loggerOTel.emit({
-          severityNumber,
-          severityText: level,
-          body: message,
-          attributes: { "log.type": "custom" },
-        });
-      }
-    }
-  }
-}

package/src/StandardMeter.ts

@@ -1,91 +0,0 @@
-import { Counter, Histogram, ObservableGauge } from "@opentelemetry/api";
-import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
-import { resourceFromAttributes } from "@opentelemetry/resources";
-import {
-  MeterProvider,
-  PeriodicExportingMetricReader,
-} from "@opentelemetry/sdk-metrics";
-import {
-  ATTR_NETWORK_LOCAL_ADDRESS,
-  ATTR_SERVICE_NAME,
-  ATTR_SERVICE_VERSION,
-} from "@opentelemetry/semantic-conventions";
-import * as os from "os";
-import { ConfigInterfaceOTel } from "./models/ConfigInterfaceOTel";
-
-let meterProvider: MeterProvider;
-let config: ConfigInterfaceOTel;
-const METER_NAME = "default";
-
-//
-export function StandardMeterInitTelemetry(initConfig: ConfigInterfaceOTel) {
-  config = initConfig;
-
-  // Metrics
-  if (config.OPENTELEMETRY_COLLECTOR_HTTP_METRICS) {
-    const collectorOptions = {
-      url: config.OPENTELEMETRY_COLLECTOR_HTTP_METRICS,
-      headers: {} as Record<string, string>,
-      concurrencyLimit: 1,
-    };
-    if (config.OPENTELEMETRY_COLLECT_AUTHORIZATION_HEADER) {
-      collectorOptions.headers[
-        "Authorization"
-      ] = `Bearer ${config.OPENTELEMETRY_COLLECT_AUTHORIZATION_HEADER}`;
-    }
-    const metricExporter = new OTLPMetricExporter(collectorOptions);
-    meterProvider = new MeterProvider({
-      resource: resourceFromAttributes({
-        [ATTR_SERVICE_NAME]: `${config.SERVICE_ID}`,
-        [ATTR_SERVICE_VERSION]: `${config.VERSION}`,
-        [ATTR_NETWORK_LOCAL_ADDRESS]: os.hostname(),
-      }),
-      readers: [
-        new PeriodicExportingMetricReader({
-          exporter: metricExporter,
-          exportIntervalMillis:
-            config.OPENTELEMETRY_COLLECTOR_EXPORT_METRICS_INTERVAL_SECONDS *
-            1000,
-        }),
-      ],
-    });
-  } else {
-    meterProvider = new MeterProvider({
-      resource: resourceFromAttributes({
-        [ATTR_SERVICE_NAME]: `${config.SERVICE_ID}`,
-        [ATTR_SERVICE_VERSION]: `${config.VERSION}`,
-        [ATTR_NETWORK_LOCAL_ADDRESS]: os.hostname(),
-      }),
-    });
-  }
-}
-
-export function StandardMeterCreateCounter(key: string): Counter {
-  const meter = meterProvider.getMeter(METER_NAME);
-  return meter.createCounter(`${config.SERVICE_ID}.${key}`);
-}
-
-export function StandardMeterCreateUpDownCounter(key: string): Counter {
-  const meter = meterProvider.getMeter(METER_NAME);
-  return meter.createUpDownCounter(`${config.SERVICE_ID}.${key}`);
-}
-
-export function StandardMeterCreateHistorgram(key: string): Histogram {
-  const meter = meterProvider.getMeter(METER_NAME);
-  return meter.createHistogram(`${config.SERVICE_ID}.${key}`);
-}
-
-export function StandardMeterCreateObservableGauge(
-  key: string,
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  callback: (observableResult: any) => void,
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  description: any = null
-): ObservableGauge {
-  const meter = meterProvider.getMeter(METER_NAME);
-  const observableGauge = meter.createObservableGauge(key, description);
-
-  observableGauge.addCallback(callback);
-
-  return observableGauge;
-}

package/src/StandardTracer.ts

@@ -1,105 +0,0 @@
-import opentelemetry, {
-  defaultTextMapSetter,
-  ROOT_CONTEXT,
-  trace,
-  Tracer,
-} from "@opentelemetry/api";
-import { AsyncHooksContextManager } from "@opentelemetry/context-async-hooks";
-import { W3CTraceContextPropagator } from "@opentelemetry/core";
-import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
-import { AWSXRayIdGenerator } from "@opentelemetry/id-generator-aws-xray";
-import { resourceFromAttributes } from "@opentelemetry/resources";
-import { BatchSpanProcessor, Span } from "@opentelemetry/sdk-trace-base";
-import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
-import {
-  ATTR_HTTP_REQUEST_METHOD,
-  ATTR_HTTP_ROUTE,
-  ATTR_NETWORK_LOCAL_ADDRESS,
-  ATTR_SERVICE_NAME,
-  ATTR_SERVICE_VERSION,
-} from "@opentelemetry/semantic-conventions";
-import * as os from "os";
-import { ConfigInterfaceOTel } from "./models/ConfigInterfaceOTel";
-
-let tracerInstance: Tracer;
-const propagator = new W3CTraceContextPropagator();
-let config: ConfigInterfaceOTel;
-
-//
-export function StandardTracerInitTelemetry(initConfig: ConfigInterfaceOTel) {
-  config = initConfig;
-  const spanProcessors = [];
-
-  if (config.OPENTELEMETRY_COLLECTOR_HTTP_TRACES) {
-    const exporterHeaders: Record<string, string> = {};
-    if (config.OPENTELEMETRY_COLLECT_AUTHORIZATION_HEADER) {
-      exporterHeaders[
-        "Authorization"
-      ] = `Bearer ${config.OPENTELEMETRY_COLLECT_AUTHORIZATION_HEADER}`;
-    }
-    const exporter = new OTLPTraceExporter({
-      url: config.OPENTELEMETRY_COLLECTOR_HTTP_TRACES,
-      headers: exporterHeaders,
-    });
-    spanProcessors.push(new BatchSpanProcessor(exporter));
-  }
-  const traceProvider = new NodeTracerProvider({
-    idGenerator: new AWSXRayIdGenerator(),
-    resource: resourceFromAttributes({
-      [ATTR_SERVICE_NAME]: `${config.SERVICE_ID}`,
-      [ATTR_SERVICE_VERSION]: `${config.VERSION}`,
-      [ATTR_NETWORK_LOCAL_ADDRESS]: os.hostname(),
-    }),
-    spanProcessors,
-  });
-  traceProvider.register();
-  const contextManager = new AsyncHooksContextManager();
-  contextManager.enable();
-  opentelemetry.context.setGlobalContextManager(contextManager);
-}
-
-export function StandardTracerStartSpan(name: string, parentSpan?: Span): Span {
-  const sanitizedName = String(name).replace(/[^a-zA-Z0-9-_/]/g, "_");
-  const tracer = StandardTracerGetTracer();
-
-  if (parentSpan) {
-    return tracer.startSpan(
-      sanitizedName,
-      undefined,
-      opentelemetry.trace.setSpan(opentelemetry.context.active(), parentSpan)
-    ) as Span;
-  }
-
-  const span = tracer.startSpan(sanitizedName) as Span;
-
-  span.setAttribute(ATTR_HTTP_REQUEST_METHOD, `BACKEND`);
-  span.setAttribute(
-    ATTR_HTTP_ROUTE,
-    `${config.SERVICE_ID}-${config.VERSION}-${sanitizedName}`
-  );
-  return span;
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function StandardTracerGetTracer(): any {
-  if (!tracerInstance) {
-    tracerInstance = opentelemetry.trace.getTracer(
-      `${config.SERVICE_ID}:${config.VERSION}`
-    );
-  }
-  return tracerInstance;
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function StandardTracerAppendHeader(context: Span, headers = {}): any {
-  if (!headers) {
-    headers = {};
-  }
-  propagator.inject(
-    trace.setSpanContext(ROOT_CONTEXT, context.spanContext()),
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    headers as any,
-    defaultTextMapSetter
-  );
-  return headers;
-}

package/src/models/ConfigInterfaceOTel.ts

@@ -1,11 +0,0 @@
-export interface ConfigInterfaceOTel {
-  SERVICE_ID: string;
-  VERSION: number;
-  OPENTELEMETRY_COLLECTOR_HTTP_TRACES: string;
-  OPENTELEMETRY_COLLECTOR_HTTP_METRICS: string;
-  OPENTELEMETRY_COLLECTOR_HTTP_LOGS: string;
-  OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_INTERVAL_SECONDS: number;
-  OPENTELEMETRY_COLLECTOR_EXPORT_METRICS_INTERVAL_SECONDS: number;
-  OPENTELEMETRY_COLLECTOR_AWS: boolean;
-  OPENTELEMETRY_COLLECT_AUTHORIZATION_HEADER: string;
-}