@devopsplaybook.io/otel-utils 1.0.5 → 1.0.7-beta.6.01832d5

package/.github/workflows/main-build.yml

@@ -0,0 +1,117 @@
+name: Main Build
+
+on:
+  push:
+    branches: ["main"]
+
+  workflow_dispatch:
+
+jobs:
+  test-and-build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "18"
+          cache: "npm"
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run linting
+        run: npm run lint || echo "No lint script found, skipping"
+
+      - name: Run tests
+        run: npm test || echo "No test script found, skipping"
+
+      - name: Build package
+        run: npm run build
+
+  publish-release:
+    runs-on: ubuntu-latest
+    needs: test-and-build
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0 # Need full history for version comparison
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "18"
+          cache: "npm"
+          registry-url: "https://registry.npmjs.org"
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Build package
+        run: npm run build
+
+      - name: Check if version changed
+        id: version-check
+        run: |
+          # Get current version from package.json
+          CURRENT_VERSION=$(node -p "require('./package.json').version")
+          echo "current-version=${CURRENT_VERSION}" >> $GITHUB_OUTPUT
+
+          # Check if this version exists on npm
+          if npm view @devopsplaybook.io/otel-utils@${CURRENT_VERSION} version &> /dev/null; then
+            echo "version-exists=true" >> $GITHUB_OUTPUT
+            echo "Version ${CURRENT_VERSION} already exists on npm"
+          else
+            echo "version-exists=false" >> $GITHUB_OUTPUT
+            echo "Version ${CURRENT_VERSION} is new, will publish"
+          fi
+
+      - name: Publish release package
+        if: steps.version-check.outputs.version-exists == 'false'
+        run: |
+          echo "Publishing version ${{ steps.version-check.outputs.current-version }}"
+          npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+      - name: Create Git Tag
+        if: steps.version-check.outputs.version-exists == 'false'
+        run: |
+          git config --local user.email "action@github.com"
+          git config --local user.name "GitHub Action"
+          git tag -a v${{ steps.version-check.outputs.current-version }} -m "Release v${{ steps.version-check.outputs.current-version }}"
+          git push origin v${{ steps.version-check.outputs.current-version }}
+
+      - name: Create GitHub Release
+        if: steps.version-check.outputs.version-exists == 'false'
+        uses: actions/create-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: v${{ steps.version-check.outputs.current-version }}
+          release_name: Release v${{ steps.version-check.outputs.current-version }}
+          draft: false
+          prerelease: false
+          body: |
+            ## Release v${{ steps.version-check.outputs.current-version }}
+
+            **Package**: `@devopsplaybook.io/otel-utils@${{ steps.version-check.outputs.current-version }}`
+
+            Install with:
+            ```bash
+            npm install @devopsplaybook.io/otel-utils@${{ steps.version-check.outputs.current-version }}
+            # or for latest
+            npm install @devopsplaybook.io/otel-utils
+            ```
+
+            ### Changes
+            This release includes all changes merged since the previous version.
+
+      - name: Skip publish - version exists
+        if: steps.version-check.outputs.version-exists == 'true'
+        run: |
+          echo "⚠️  Version ${{ steps.version-check.outputs.current-version }} already exists on npm."
+          echo "To publish a new version, update the version in package.json first."

package/.github/workflows/pr-check.yml

@@ -0,0 +1,98 @@
+name: PR Check
+
+on:
+  pull_request:
+    branches: ["main"]
+
+  workflow_dispatch:
+
+concurrency:
+  group: pr-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  test-and-build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "18"
+          cache: "npm"
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run linting
+        run: npm run lint || echo "No lint script found, skipping"
+
+      - name: Run tests
+        run: npm test || echo "No test script found, skipping"
+
+      - name: Build package
+        run: npm run build
+
+  publish-beta:
+    runs-on: ubuntu-latest
+    needs: test-and-build
+    if: github.event_name == 'pull_request'
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "18"
+          cache: "npm"
+          registry-url: "https://registry.npmjs.org"
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Build package
+        run: npm run build
+
+      - name: Generate beta version
+        id: beta-version
+        run: |
+          CURRENT_VERSION=$(node -p "require('./package.json').version")
+          PR_NUMBER=${{ github.event.pull_request.number }}
+          COMMIT_SHA=${GITHUB_SHA:0:7}
+          BETA_VERSION="${CURRENT_VERSION}-beta.${PR_NUMBER}.${COMMIT_SHA}"
+          echo "version=${BETA_VERSION}" >> $GITHUB_OUTPUT
+          echo "Beta version will be: ${BETA_VERSION}"
+
+      - name: Update package.json with beta version
+        run: |
+          npm version ${{ steps.beta-version.outputs.version }} --no-git-tag-version
+
+      - name: Publish beta package
+        run: npm publish --tag beta
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+      - name: Comment PR with beta version info
+        uses: actions/github-script@v7
+        with:
+          script: |
+            github.rest.issues.createComment({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              body: `🚀 **Beta version published!**
+              
+              **Package**: \`@devopsplaybook.io/otel-utils@${{ steps.beta-version.outputs.version }}\`
+              
+              Install with:
+              \`\`\`bash
+              npm install @devopsplaybook.io/otel-utils@${{ steps.beta-version.outputs.version }}
+              # or
+              npm install @devopsplaybook.io/otel-utils@beta
+              \`\`\`
+              
+              This beta version will be available for testing until the PR is merged.`
+            })

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./src/models/ConfigOTelInterface";
+export * from "./src/models/StandardLoggerInterface";
+export * from "./src/ModuleLogger";
+export * from "./src/StandardLogger";
+export * from "./src/StandardMeter";
+export * from "./src/StandardTracer";

package/dist/index.js

@@ -0,0 +1,22 @@
+"use strict";
+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/models/ConfigOTelInterface"), exports);
+__exportStar(require("./src/models/StandardLoggerInterface"), exports);
+__exportStar(require("./src/ModuleLogger"), exports);
+__exportStar(require("./src/StandardLogger"), exports);
+__exportStar(require("./src/StandardMeter"), exports);
+__exportStar(require("./src/StandardTracer"), exports);

package/dist/src/ModuleLogger.d.ts

@@ -0,0 +1,11 @@
+import { StandardLoggerInterface } from "./models/StandardLoggerInterface";
+import { Span } from "@opentelemetry/sdk-trace-base";
+export declare class ModuleLogger {
+    private module;
+    private standardLogger?;
+    constructor(module: string, standardLogger: StandardLoggerInterface);
+    info(message: string, context?: Span): void;
+    warn(message: string, context?: Span): void;
+    error(message: string, error?: Error, context?: Span): void;
+    private display;
+}

package/dist/src/ModuleLogger.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleLogger = void 0;
+const api_logs_1 = require("@opentelemetry/api-logs");
+class ModuleLogger {
+    constructor(module, standardLogger) {
+        this.module = module;
+        this.standardLogger = standardLogger;
+    }
+    info(message, context) {
+        this.display("info", message, api_logs_1.SeverityNumber.INFO, null, context);
+    }
+    warn(message, context) {
+        this.display("warn", message, api_logs_1.SeverityNumber.WARN, null, context);
+    }
+    error(message, error, context) {
+        this.display("error", message, api_logs_1.SeverityNumber.ERROR, error, context);
+    }
+    display(level, message, severityNumber = api_logs_1.SeverityNumber.INFO, error, context) {
+        var _a, _b;
+        let formattedMessage = message;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const attributes = { "log.type": "custom" };
+        formattedMessage = message;
+        if (error) {
+            attributes["exception.type"] = error.name;
+            attributes["exception.message"] = error.message;
+            attributes["exception.stacktrace"] = error.stack;
+            formattedMessage += "\n" + error.stack;
+        }
+        if (context) {
+            const spanCtx = context.spanContext();
+            if (spanCtx) {
+                attributes["span.id"] = spanCtx.spanId;
+                attributes["trace.id"] = spanCtx.traceId;
+            }
+        }
+        console.log(`[${level}] [${this.module}] ${formattedMessage}`);
+        if (!((_a = this.standardLogger) === null || _a === void 0 ? void 0 : _a.getLogger())) {
+            return;
+        }
+        (_b = this.standardLogger.getLogger()) === null || _b === void 0 ? void 0 : _b.emit({
+            severityNumber,
+            severityText: level,
+            body: `[${this.module}] ${formattedMessage}`,
+            attributes,
+        });
+    }
+}
+exports.ModuleLogger = ModuleLogger;

package/dist/src/StandardLogger.d.ts

@@ -0,0 +1,11 @@
+import type { Logger as OTelLogger } from "@opentelemetry/api-logs";
+import { ConfigOTelInterface } from "./models/ConfigOTelInterface";
+import { ModuleLogger } from "./ModuleLogger";
+export declare class StandardLogger {
+    private logger?;
+    private serviceVersion?;
+    private serviceName?;
+    initOTel(config: ConfigOTelInterface): void;
+    getLogger(): OTelLogger | undefined;
+    createModuleLogger(moduleName: string): ModuleLogger;
+}

package/dist/src/StandardLogger.js

@@ -0,0 +1,80 @@
+"use strict";
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StandardLogger = void 0;
+const exporter_logs_otlp_http_1 = require("@opentelemetry/exporter-logs-otlp-http");
+const resources_1 = require("@opentelemetry/resources");
+const sdk_logs_1 = require("@opentelemetry/sdk-logs");
+const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+const os = __importStar(require("os"));
+const ModuleLogger_1 = require("./ModuleLogger");
+class StandardLogger {
+    initOTel(config) {
+        this.serviceName = config.SERVICE_ID;
+        this.serviceVersion = config.VERSION;
+        if (config.OPENTELEMETRY_COLLECTOR_HTTP_LOGS) {
+            const exporterHeaders = {};
+            if (config.OPENTELEMETRY_COLLECT_AUTHORIZATION_HEADER) {
+                exporterHeaders["Authorization"] = `Bearer ${config.OPENTELEMETRY_COLLECT_AUTHORIZATION_HEADER}`;
+            }
+            const exporter = new exporter_logs_otlp_http_1.OTLPLogExporter({
+                url: config.OPENTELEMETRY_COLLECTOR_HTTP_LOGS,
+                headers: exporterHeaders,
+            });
+            const loggerProvider = new sdk_logs_1.LoggerProvider({
+                processors: [
+                    new sdk_logs_1.BatchLogRecordProcessor(exporter, {
+                        maxQueueSize: 100,
+                        scheduledDelayMillis: config.OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_INTERVAL_SECONDS *
+                            1000,
+                    }),
+                ],
+                resource: (0, resources_1.resourceFromAttributes)({
+                    [semantic_conventions_1.ATTR_SERVICE_NAME]: `${this.serviceName}`,
+                    [semantic_conventions_1.ATTR_SERVICE_VERSION]: `${this.serviceVersion}`,
+                    [semantic_conventions_1.ATTR_NETWORK_LOCAL_ADDRESS]: os.hostname(),
+                }),
+            });
+            this.logger = loggerProvider.getLogger(`${this.serviceName}:${this.serviceVersion}`);
+        }
+    }
+    getLogger() {
+        return this.logger;
+    }
+    createModuleLogger(moduleName) {
+        return new ModuleLogger_1.ModuleLogger(moduleName, this);
+    }
+}
+exports.StandardLogger = StandardLogger;

package/dist/src/StandardMeter.d.ts

@@ -0,0 +1,12 @@
+import { Counter, Histogram, ObservableGauge } from "@opentelemetry/api";
+import { ConfigOTelInterface } from "./models/ConfigOTelInterface";
+export declare class StandardMeter {
+    private meter;
+    private serviceVersion;
+    private serviceName;
+    constructor(config: ConfigOTelInterface);
+    createCounter(key: string): Counter;
+    createUpDownCounter(key: string): Counter;
+    createHistogram(key: string): Histogram;
+    createObservableGauge(key: string, callback: (observableResult: any) => void, description?: any): ObservableGauge;
+}

package/dist/src/StandardMeter.js

@@ -0,0 +1,102 @@
+"use strict";
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StandardMeter = void 0;
+const exporter_metrics_otlp_http_1 = require("@opentelemetry/exporter-metrics-otlp-http");
+const resources_1 = require("@opentelemetry/resources");
+const sdk_metrics_1 = require("@opentelemetry/sdk-metrics");
+const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+const os = __importStar(require("os"));
+class StandardMeter {
+    constructor(config) {
+        this.serviceName = config.SERVICE_ID;
+        this.serviceVersion = config.VERSION;
+        let meterProvider;
+        if (config.OPENTELEMETRY_COLLECTOR_HTTP_METRICS) {
+            const collectorOptions = {
+                url: config.OPENTELEMETRY_COLLECTOR_HTTP_METRICS,
+                headers: {},
+                concurrencyLimit: 1,
+            };
+            if (config.OPENTELEMETRY_COLLECT_AUTHORIZATION_HEADER) {
+                collectorOptions.headers["Authorization"] = `Bearer ${config.OPENTELEMETRY_COLLECT_AUTHORIZATION_HEADER}`;
+            }
+            const metricExporter = new exporter_metrics_otlp_http_1.OTLPMetricExporter(collectorOptions);
+            meterProvider = new sdk_metrics_1.MeterProvider({
+                resource: (0, resources_1.resourceFromAttributes)({
+                    [semantic_conventions_1.ATTR_SERVICE_NAME]: `${this.serviceName}`,
+                    [semantic_conventions_1.ATTR_SERVICE_VERSION]: `${this.serviceVersion}`,
+                    [semantic_conventions_1.ATTR_NETWORK_LOCAL_ADDRESS]: os.hostname(),
+                }),
+                readers: [
+                    new sdk_metrics_1.PeriodicExportingMetricReader({
+                        exporter: metricExporter,
+                        exportIntervalMillis: config.OPENTELEMETRY_COLLECTOR_EXPORT_METRICS_INTERVAL_SECONDS *
+                            1000,
+                    }),
+                ],
+            });
+        }
+        else {
+            meterProvider = new sdk_metrics_1.MeterProvider({
+                resource: (0, resources_1.resourceFromAttributes)({
+                    [semantic_conventions_1.ATTR_SERVICE_NAME]: `${this.serviceName}`,
+                    [semantic_conventions_1.ATTR_SERVICE_VERSION]: `${this.serviceVersion}`,
+                    [semantic_conventions_1.ATTR_NETWORK_LOCAL_ADDRESS]: os.hostname(),
+                }),
+            });
+        }
+        this.meter = meterProvider.getMeter(`${this.serviceName}:${this.serviceVersion}`);
+    }
+    createCounter(key) {
+        return this.meter.createCounter(`${this.serviceName}.${key}`);
+    }
+    createUpDownCounter(key) {
+        return this.meter.createUpDownCounter(`${this.serviceName}.${key}`);
+    }
+    createHistogram(key) {
+        return this.meter.createHistogram(`${this.serviceName}.${key}`);
+    }
+    createObservableGauge(key, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    callback, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    description = null) {
+        const observableGauge = this.meter.createObservableGauge(key, description);
+        observableGauge.addCallback(callback);
+        return observableGauge;
+    }
+}
+exports.StandardMeter = StandardMeter;

package/dist/src/StandardTracer.d.ts

@@ -0,0 +1,10 @@
+import { Span } from "@opentelemetry/sdk-trace-base";
+import { ConfigOTelInterface } from "./models/ConfigOTelInterface";
+export declare class StandardTracer {
+    private tracer;
+    private serviceVersion;
+    private serviceName;
+    constructor(config: ConfigOTelInterface);
+    startSpan(name: string, parentSpan?: Span): Span;
+    static updateHttpHeader(context: Span, headers?: {}): any;
+}

package/dist/src/StandardTracer.js

@@ -0,0 +1,100 @@
+"use strict";
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StandardTracer = void 0;
+const api_1 = __importStar(require("@opentelemetry/api"));
+const context_async_hooks_1 = require("@opentelemetry/context-async-hooks");
+const core_1 = require("@opentelemetry/core");
+const exporter_trace_otlp_http_1 = require("@opentelemetry/exporter-trace-otlp-http");
+const id_generator_aws_xray_1 = require("@opentelemetry/id-generator-aws-xray");
+const resources_1 = require("@opentelemetry/resources");
+const sdk_trace_base_1 = require("@opentelemetry/sdk-trace-base");
+const sdk_trace_node_1 = require("@opentelemetry/sdk-trace-node");
+const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+const os = __importStar(require("os"));
+class StandardTracer {
+    constructor(config) {
+        this.serviceName = config.SERVICE_ID;
+        this.serviceVersion = config.VERSION;
+        const spanProcessors = [];
+        if (config.OPENTELEMETRY_COLLECTOR_HTTP_TRACES) {
+            const exporterHeaders = {};
+            if (config.OPENTELEMETRY_COLLECT_AUTHORIZATION_HEADER) {
+                exporterHeaders["Authorization"] = `Bearer ${config.OPENTELEMETRY_COLLECT_AUTHORIZATION_HEADER}`;
+            }
+            const exporter = new exporter_trace_otlp_http_1.OTLPTraceExporter({
+                url: config.OPENTELEMETRY_COLLECTOR_HTTP_TRACES,
+                headers: exporterHeaders,
+            });
+            spanProcessors.push(new sdk_trace_base_1.BatchSpanProcessor(exporter));
+        }
+        const traceProvider = new sdk_trace_node_1.NodeTracerProvider({
+            idGenerator: new id_generator_aws_xray_1.AWSXRayIdGenerator(),
+            resource: (0, resources_1.resourceFromAttributes)({
+                [semantic_conventions_1.ATTR_SERVICE_NAME]: `${this.serviceName}`,
+                [semantic_conventions_1.ATTR_SERVICE_VERSION]: `${this.serviceVersion}`,
+                [semantic_conventions_1.ATTR_NETWORK_LOCAL_ADDRESS]: os.hostname(),
+            }),
+            spanProcessors,
+        });
+        traceProvider.register();
+        const contextManager = new context_async_hooks_1.AsyncHooksContextManager();
+        contextManager.enable();
+        api_1.default.context.setGlobalContextManager(contextManager);
+        this.tracer = api_1.default.trace.getTracer(`${this.serviceName}:${this.serviceVersion}`);
+    }
+    startSpan(name, parentSpan) {
+        const sanitizedName = String(name).replace(/[^a-zA-Z0-9-_/]/g, "_");
+        if (parentSpan) {
+            return this.tracer.startSpan(sanitizedName, undefined, api_1.default.trace.setSpan(api_1.default.context.active(), parentSpan));
+        }
+        const span = this.tracer.startSpan(sanitizedName);
+        span.setAttribute(semantic_conventions_1.ATTR_HTTP_REQUEST_METHOD, `BACKEND`);
+        span.setAttribute(semantic_conventions_1.ATTR_HTTP_ROUTE, `${this.serviceName}-${this.serviceVersion}-${sanitizedName}`);
+        return span;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static updateHttpHeader(context, headers = {}) {
+        if (!headers) {
+            headers = {};
+        }
+        const propagator = new core_1.W3CTraceContextPropagator();
+        propagator.inject(api_1.trace.setSpanContext(api_1.ROOT_CONTEXT, context.spanContext()), 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        headers, api_1.defaultTextMapSetter);
+        return headers;
+    }
+}
+exports.StandardTracer = StandardTracer;

package/dist/src/models/ConfigOTelInterface.d.ts

@@ -0,0 +1,11 @@
+export interface ConfigOTelInterface {
+    SERVICE_ID: string;
+    VERSION: string;
+    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;
+}

package/dist/src/models/ConfigOTelInterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/models/StandardLoggerInterface.d.ts

@@ -0,0 +1,4 @@
+import type { Logger } from "@opentelemetry/api-logs";
+export interface StandardLoggerInterface {
+    getLogger(): Logger | undefined;
+}

package/dist/src/models/StandardLoggerInterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devopsplaybook.io/otel-utils",
-  "version": "1.0.5",
+  "version": "1.0.7-beta.6.01832d5",
   "description": "Utility to simplify integration with Open Telemetry",
   "keywords": [
     "Open",
@@ -20,24 +20,24 @@
   },
   "dependencies": {
     "@opentelemetry/api": "^1.9.0",
-    "@opentelemetry/api-logs": "^0.204.0",
-    "@opentelemetry/auto-instrumentations-node": "^0.63.0",
-    "@opentelemetry/exporter-logs-otlp-http": "^0.204.0",
-    "@opentelemetry/exporter-trace-otlp-http": "^0.204.0",
+    "@opentelemetry/api-logs": "^0.205.0",
+    "@opentelemetry/auto-instrumentations-node": "^0.64.1",
+    "@opentelemetry/exporter-logs-otlp-http": "^0.205.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.205.0",
     "@opentelemetry/id-generator-aws-xray": "^2.0.1",
     "@opentelemetry/resources": "^2.1.0",
-    "@opentelemetry/sdk-logs": "^0.204.0",
-    "@opentelemetry/sdk-node": "^0.204.0",
+    "@opentelemetry/sdk-logs": "^0.205.0",
+    "@opentelemetry/sdk-node": "^0.205.0",
     "@opentelemetry/sdk-trace-base": "^2.1.0",
     "@opentelemetry/sdk-trace-web": "^2.1.0",
     "@opentelemetry/semantic-conventions": "^1.37.0"
   },
   "devDependencies": {
-    "@eslint/js": "^9.35.0",
-    "@types/node": "^24.3.1",
+    "@eslint/js": "^9.36.0",
+    "@types/node": "^24.5.2",
     "@types/sqlite3": "^5.1.0",
     "ts-node": "^10.9.2",
-    "typescript-eslint": "^8.43.0",
+    "typescript-eslint": "^8.44.1",
     "typescript": "^5.9.2"
   },
   "publishConfig": {