@ogcio/o11y-sdk-node 0.1.0-beta.1 → 0.1.0-beta.10

package/CHANGELOG.md

@@ -1,5 +1,79 @@
 # Changelog
 
+## [0.1.0-beta.10](https://github.com/ogcio/o11y/compare/@ogcio/o11y-sdk-node@v0.1.0-beta.9...@ogcio/o11y-sdk-node@v0.1.0-beta.10) (2025-04-09)
+
+
+### Features
+
+* april depedency upgrade AB[#27200](https://github.com/ogcio/o11y/issues/27200) ([#116](https://github.com/ogcio/o11y/issues/116)) ([d792fe5](https://github.com/ogcio/o11y/commit/d792fe5a783b0b495912b5bef2babfe11ef5e01d))
+
+
+### Bug Fixes
+
+* default attributes in resource ([#112](https://github.com/ogcio/o11y/issues/112)) ([f0f0b9d](https://github.com/ogcio/o11y/commit/f0f0b9d555ef321d31f7171e25dc4b8a5b044522))
+
+## [0.1.0-beta.9](https://github.com/ogcio/o11y/compare/@ogcio/o11y-sdk-node@v0.1.0-beta.8...@ogcio/o11y-sdk-node@v0.1.0-beta.9) (2025-03-24)
+
+
+### Features
+
+* add custom log processor for span enrich ([#102](https://github.com/ogcio/o11y/issues/102)) ([bbf8334](https://github.com/ogcio/o11y/commit/bbf83340940ed651dff63bbe7aaa52881d1e8c8c))
+* upgrade to opentelemetry 2 AB[#25863](https://github.com/ogcio/o11y/issues/25863) ([#106](https://github.com/ogcio/o11y/issues/106)) ([3ff0314](https://github.com/ogcio/o11y/commit/3ff0314fef9f4d7b5db76da3b94e9035801384c7))
+
+## [0.1.0-beta.8](https://github.com/ogcio/o11y/compare/@ogcio/o11y-sdk-node@v0.1.0-beta.7...@ogcio/o11y-sdk-node@v0.1.0-beta.8) (2025-03-07)
+
+
+### Features
+
+* o11y showcase AB[#25895](https://github.com/ogcio/o11y/issues/25895) ([#84](https://github.com/ogcio/o11y/issues/84)) ([f8f10af](https://github.com/ogcio/o11y/commit/f8f10af97d9f5c188e3e65f7d62d5c673edce25a))
+
+
+### Bug Fixes
+
+* improve getMetric attributes types ([#76](https://github.com/ogcio/o11y/issues/76)) ([243649c](https://github.com/ogcio/o11y/commit/243649c4bfe750687a729fbd836772cce16e0cb1))
+
+## [0.1.0-beta.7](https://github.com/ogcio/o11y/compare/@ogcio/o11y-sdk-node@v0.1.0-beta.6...@ogcio/o11y-sdk-node@v0.1.0-beta.7) (2025-02-18)
+
+
+### Features
+
+* **sdk-node:** add span customization AB[#25358](https://github.com/ogcio/o11y/issues/25358) ([46ba97b](https://github.com/ogcio/o11y/commit/46ba97bac4004ff326a954592f45213ce0e4d683))
+
+## [0.1.0-beta.6](https://github.com/ogcio/o11y/compare/@ogcio/o11y-sdk-node@v0.1.0-beta.5...@ogcio/o11y-sdk-node@v0.1.0-beta.6) (2025-02-06)
+
+
+### Features
+
+* remove pnpm test on prepublishOnly script ([#68](https://github.com/ogcio/o11y/issues/68)) ([41f6f57](https://github.com/ogcio/o11y/commit/41f6f57fa415c4f7adc29f49f983539274ef7320))
+
+## [0.1.0-beta.5](https://github.com/ogcio/o11y/compare/@ogcio/o11y-sdk-node@v0.1.0-beta.4...@ogcio/o11y-sdk-node@v0.1.0-beta.5) (2025-02-06)
+
+
+### Features
+
+* add opentelemetry sampler ([#65](https://github.com/ogcio/o11y/issues/65)) ([66793fd](https://github.com/ogcio/o11y/commit/66793fd36bf071e592e3b455f2e33ad9d5b2db37))
+
+## [0.1.0-beta.4](https://github.com/ogcio/o11y/compare/@ogcio/o11y-sdk-node@v0.1.0-beta.3...@ogcio/o11y-sdk-node@v0.1.0-beta.4) (2025-01-29)
+
+
+### Bug Fixes
+
+* prepublishOnly hook ([#60](https://github.com/ogcio/o11y/issues/60)) ([9fbd3ad](https://github.com/ogcio/o11y/commit/9fbd3ad0b45a1604cf2eccc26b2f8855640417a1))
+
+## [0.1.0-beta.3](https://github.com/ogcio/o11y/compare/@ogcio/o11y-sdk-node@0.1.0-beta.2...@ogcio/o11y-sdk-node@v0.1.0-beta.3) (2025-01-28)
+
+
+### Features
+
+* **sdk-node:** custom metrics ([#53](https://github.com/ogcio/o11y/issues/53)) ([3cb40b1](https://github.com/ogcio/o11y/commit/3cb40b1add3d80615c8d123d233724094559c7ff))
+
+## [0.1.0-beta.2](https://github.com/ogcio/o11y/compare/@ogcio/o11y-sdk-node@0.1.0-beta.1...@ogcio/o11y-sdk-node@0.1.0-beta.2) (2024-11-28)
+
+
+### Bug Fixes
+
+* Add readme file inside submodule ([#27](https://github.com/ogcio/o11y/issues/27)) ([dc518d5](https://github.com/ogcio/o11y/commit/dc518d5dde573368443bc0f8619e80e331880c78))
+
 ## [0.1.0-beta.1](https://github.com/ogcio/o11y/compare/@ogcio/o11y-sdk-node@0.0.1-beta.1...@ogcio/o11y-sdk-node@0.1.0-beta.1) (2024-11-27)
 
 

package/README.md

@@ -0,0 +1,222 @@
+# Observability NodeJS SDK
+
+The NodeJS observability sdk is a npm package used to setup and implement opentelemetry instrumentation.
+
+## Installation
+
+pnpm
+
+```bash
+  pnpm i --save @ogcio/o11y-sdk-node
+```
+
+npm
+
+```bash
+  npm i @ogcio/o11y-sdk-node
+```
+
+## Usage
+
+Setup using constructor function
+
+```javascript
+// instrumentation.ts
+
+import("@ogcio/o11y-sdk-node/lib/index").then((sdk) =>
+  sdk.instrumentNode({
+    serviceName: "node-microservice",
+    collectorUrl: "http://localhost:4317",
+    resourceAttributes: {
+      "team.infra.cluster": "dev-01",
+      "team.infra.pod": "01",
+      "team.service.type": "fastify",
+    },
+    spanAttributes: {
+      "signal.namespace": "documentation",
+    },
+    ignoreUrls: [{ type: "equals", url: "/api/health" }],
+  }),
+);
+```
+
+Run your node script with instrumentation
+
+`node --import instrumentation.js server.js`
+
+Or setup inside your package.json
+
+```json
+{
+  "main": "dist/index.js",
+  "type": "module",
+  "scripts": {
+    "start": "node --env-file=.env --import ./dist/instrumentation.js dist/index.js"
+  }
+}
+```
+
+## Span Customization
+
+It is possible to customize spans such as traces and logs globally or in a single code statement using predefined functions.
+
+### Global Configuration
+
+In the SDK configuration, you can set the following properties:
+
+- `spanAttributes` Object containing static properties or functions used to evaluate custom attributes for every logs and traces.
+- `resourceAttributes` Object containing static properties used as resources attributes for any signal.
+- `traceRatio` Faction value from 0 to 1, used by TraceIdRatioBasedSampler which it deterministically samples a percentage of traces that you pass in as a parameter.
+
+```typescript
+function generateRandomString(): string {
+  return Math.random() + "_" + Date.now();
+}
+
+instrumentNode({
+  resourceAttributes: {
+    "property.name.one": "value_one",
+    "property.name.two": "value_two",
+  },
+  spanAttributes: {
+    "custom.span.value": "example",
+    "custom.span.value_with_function": generateRandomString,
+  },
+});
+```
+
+### Edit Active Span
+
+Using `getActiveSpan` function, you can access to current transaction span and customize it.
+
+You can use the function everywhere in your code, and set some custom attributes that are enabled for that single span
+
+```typescript
+import { getActiveSpan } from "@ogcio/o11y-sdk-node";
+
+async function routes(app: FastifyInstance) {
+  app.get("/", async (req, reply) => {
+    // validation and business logic
+
+    // set span attribute
+    getActiveSpan()?.setAttribute("business.info", "dummy");
+
+    reply.status(200).send(response);
+  });
+}
+```
+
+## Sending Custom Metrics
+
+This package gives the possibility to send custom metrics and define them as desired in the code, you can choose between sync metrics and observable async metrics.
+
+To use this functionality, you only need to import `getMetric` and enable the application instrumentation.
+
+```typescript
+import { getMetric } from "@ogcio/o11y-sdk-node";
+```
+
+### Sync
+
+Sync metrics are signals sent when the function has been called.
+
+Creating a counter, there are 2 types of counter:
+
+- **counter** a simple counter that can only add positive numbers
+- **updowncounter** counter that support also negative numbers
+
+```typescript
+const counter = getMetric("counter", {
+  attributeName: "counter",
+  metricName: "fastify-counter",
+});
+
+counter.add(1, {
+  my: "my",
+  custom: "custom",
+  attributes: "attributes",
+});
+```
+
+Creating a Histogram
+
+```typescript
+const histogram = getMetric("histogram", {
+  metricName: "response_duration",
+  attributeName: "http_response",
+  options: {
+    advice: {
+      explicitBucketBoundaries: [0, 100, 200, 500, 1000],
+    },
+    description: "Response durations",
+  },
+});
+
+histogram.record(120, { path: "/home" });
+```
+
+### Async
+
+Async metrics are called by the scraper collector to read current data using the `Observable` pattern.
+Creating an async metric means that the application will subscribe to the observability URL and record data on call (default 60s).
+
+_keep in mind, you can't send signals on-demand with this component_
+
+Creating an async Gauge
+
+```typescript
+const asyncGauge = getMetric("async-gauge", {
+  metricName: "cpu_usage",
+  attributeName: "server_load",
+  options: { unit: "percentage" },
+}).addCallback((observer) => {
+  observer.observe(50, { host: "server1" });
+});
+```
+
+Creating an async Counter
+
+```typescript
+getMetric("async-counter", {
+  attributeName: "scraped-memory",
+  metricName: "fastify-counter",
+}).addCallback((observer) => {
+  observer.observe(freemem(), {
+    "application.os.memory": "free-memory",
+  });
+});
+```
+
+## API Reference
+
+#### Protocol
+
+protocol is a string parameter used to define how to send signals to observability infrastructure
+
+- **grpc** Use gRPC protocol, usually default port use 4317. Is the most performant option for server side applications.
+- **http** Use HTTP standard protocol, usually default port use 4318. Mainly used on web or UI client applications.
+- **console** Used for debugging sending signals to observability cluster, every information will be printed to your runtime console.
+
+#### Shared Types
+
+```ts
+export type SDKLogLevel =
+  | "NONE"
+  | "ERROR"
+  | "WARN"
+  | "INFO"
+  | "DEBUG"
+  | "VERBOSE"
+  | "ALL";
+```
+
+### Config
+
+| Parameter       | Type              | Description                                                                                              |
+| :-------------- | :---------------- | :------------------------------------------------------------------------------------------------------- |
+| `collectorUrl`  | `string`          | **Required**. The opentelemetry collector entrypoint url, if null, instrumentation will not be activated |
+| `serviceName`   | `string`          | Name of your application used for the collector to group logs                                            |
+| `diagLogLevel`  | `SDKLogLevel`     | Diagnostic log level for the internal runtime instrumentation                                            |
+| `collectorMode` | `single \| batch` | Signals sending mode, default is batch for performance                                                   |
+| `enableFS`      | `boolean`         | Flag to enable or disable the tracing for node:fs module                                                 |
+| `protocol`      | `string`          | Type of the protocol used to send signals                                                                |

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import type { NodeSDK } from "@opentelemetry/sdk-node";
-import type { NodeSDKConfig } from "./lib/index.js";
 import buildNodeInstrumentation from "./lib/instrumentation.node.js";
 export type * from "./lib/index.js";
-export type { NodeSDKConfig, NodeSDK };
+export type { NodeSDK };
 export { buildNodeInstrumentation as instrumentNode };
+export * from "./lib/metrics.js";
+export * from "./lib/traces.js";

package/dist/index.js

@@ -1,2 +1,4 @@
 import buildNodeInstrumentation from "./lib/instrumentation.node.js";
 export { buildNodeInstrumentation as instrumentNode };
+export * from "./lib/metrics.js";
+export * from "./lib/traces.js";

package/dist/lib/exporter/console.d.ts

@@ -0,0 +1,3 @@
+import { NodeSDKConfig } from "../index.js";
+import { Exporters } from "./index.js";
+export default function buildConsoleExporters(config: NodeSDKConfig): Exporters;

package/dist/lib/exporter/console.js

@@ -0,0 +1,20 @@
+import { ConsoleLogRecordExporter, SimpleLogRecordProcessor, } from "@opentelemetry/sdk-logs";
+import { metrics } from "@opentelemetry/sdk-node";
+import { ConsoleSpanExporter, SimpleSpanProcessor, } from "@opentelemetry/sdk-trace-base";
+import { EnrichSpanProcessor } from "../processor/enrich-span-processor.js";
+import { EnrichLogProcessor } from "../processor/enrich-logger-processor.js";
+export default function buildConsoleExporters(config) {
+    return {
+        spans: [
+            new SimpleSpanProcessor(new ConsoleSpanExporter()),
+            new EnrichSpanProcessor(config.spanAttributes),
+        ],
+        metrics: new metrics.PeriodicExportingMetricReader({
+            exporter: new metrics.ConsoleMetricExporter(),
+        }),
+        logs: [
+            new EnrichLogProcessor(config.spanAttributes),
+            new SimpleLogRecordProcessor(new ConsoleLogRecordExporter()),
+        ],
+    };
+}

package/dist/lib/exporter/grpc.d.ts

@@ -0,0 +1,3 @@
+import { NodeSDKConfig } from "../index.js";
+import { Exporters } from "./index.js";
+export default function buildGrpcExporters(config: NodeSDKConfig): Exporters;

package/dist/lib/{grpc.js → exporter/grpc.js}

@@ -1,22 +1,28 @@
-import { LogRecordProcessorMap } from "./utils.js";
+import { metrics } from "@opentelemetry/sdk-node";
 import { CompressionAlgorithm } from "@opentelemetry/otlp-exporter-base";
-import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
-import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-grpc";
-import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-grpc";
 import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-grpc";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-grpc";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-grpc";
+import { LogRecordProcessorMap, SpanProcessorMap } from "../utils.js";
+import { EnrichSpanProcessor } from "../processor/enrich-span-processor.js";
+import { EnrichLogProcessor } from "../processor/enrich-logger-processor.js";
 export default function buildGrpcExporters(config) {
     return {
-        traces: new OTLPTraceExporter({
-            url: `${config.collectorUrl}`,
-            compression: CompressionAlgorithm.GZIP,
-        }),
-        metrics: new PeriodicExportingMetricReader({
+        spans: [
+            new SpanProcessorMap[config.collectorMode ?? "batch"](new OTLPTraceExporter({
+                url: `${config.collectorUrl}`,
+                compression: CompressionAlgorithm.GZIP,
+            })),
+            new EnrichSpanProcessor(config.spanAttributes),
+        ],
+        metrics: new metrics.PeriodicExportingMetricReader({
             exporter: new OTLPMetricExporter({
                 url: `${config.collectorUrl}`,
                 compression: CompressionAlgorithm.GZIP,
             }),
         }),
         logs: [
+            new EnrichLogProcessor(config.spanAttributes),
             new LogRecordProcessorMap[config.collectorMode ?? "batch"](new OTLPLogExporter({
                 url: `${config.collectorUrl}`,
                 compression: CompressionAlgorithm.GZIP,

package/dist/lib/exporter/http.d.ts

@@ -0,0 +1,3 @@
+import { Exporters } from "./index.js";
+import { NodeSDKConfig } from "../index.js";
+export default function buildHttpExporters(config: NodeSDKConfig): Exporters;

package/dist/lib/{http.js → exporter/http.js}

@@ -1,25 +1,31 @@
-import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
-import { LogRecordProcessorMap } from "./utils.js";
+import { metrics } from "@opentelemetry/sdk-node";
 import { CompressionAlgorithm } from "@opentelemetry/otlp-exporter-base";
-import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
-import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
 import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
+import { LogRecordProcessorMap, SpanProcessorMap } from "../utils.js";
+import { EnrichSpanProcessor } from "../processor/enrich-span-processor.js";
+import { EnrichLogProcessor } from "../processor/enrich-logger-processor.js";
 export default function buildHttpExporters(config) {
     if (config.collectorUrl.endsWith("/")) {
         config.collectorUrl = config.collectorUrl.slice(0, -1);
     }
     return {
-        traces: new OTLPTraceExporter({
-            url: `${config.collectorUrl}/v1/traces`,
-            compression: CompressionAlgorithm.GZIP,
-        }),
-        metrics: new PeriodicExportingMetricReader({
+        spans: [
+            new SpanProcessorMap[config.collectorMode ?? "batch"](new OTLPTraceExporter({
+                url: `${config.collectorUrl}/v1/traces`,
+                compression: CompressionAlgorithm.GZIP,
+            })),
+            new EnrichSpanProcessor(config.spanAttributes),
+        ],
+        metrics: new metrics.PeriodicExportingMetricReader({
             exporter: new OTLPMetricExporter({
                 url: `${config.collectorUrl}/v1/metrics`,
                 compression: CompressionAlgorithm.GZIP,
             }),
         }),
         logs: [
+            new EnrichLogProcessor(config.spanAttributes),
             new LogRecordProcessorMap[config.collectorMode ?? "batch"](new OTLPLogExporter({
                 url: `${config.collectorUrl}/v1/logs`,
                 compression: CompressionAlgorithm.GZIP,

package/dist/lib/exporter/index.d.ts

@@ -0,0 +1,8 @@
+import { LogRecordProcessor } from "@opentelemetry/sdk-logs";
+import type { metrics } from "@opentelemetry/sdk-node";
+import { SpanProcessor } from "@opentelemetry/sdk-trace-base";
+export type Exporters = {
+    spans: SpanProcessor[];
+    metrics: metrics.MetricReader;
+    logs: LogRecordProcessor[];
+};

package/dist/lib/index.d.ts

@@ -1,4 +1,4 @@
-interface SDKConfig {
+export interface NodeSDKConfig {
     /**
      * The opentelemetry collector entrypoint GRPC url.
      * If the collectoUrl is null or undefined, the instrumentation will not be activated.
@@ -25,8 +25,27 @@ interface SDKConfig {
      * @default batch
      */
     collectorMode?: SDKCollectorMode;
-}
-export interface NodeSDKConfig extends SDKConfig {
+    /**
+     * Array of not traced urls.
+     *
+     * @type {SamplerCondition}
+     * @default []
+     */
+    ignoreUrls?: SamplerCondition[];
+    /**
+     * Object containing static properties or functions used to evaluate custom attributes for every logs and traces.
+     */
+    spanAttributes?: Record<string, SignalAttributeValue | (() => SignalAttributeValue)>;
+    /**
+     * Object containing static properties used as resources attributes for the Node SDK initialization.
+     */
+    resourceAttributes?: Record<string, SignalAttributeValue>;
+    /**
+     * Faction value from 0 to 1, used by TraceIdRatioBasedSampler which it deterministically samples a percentage of traces that you pass in as a parameter.
+     *
+     * @default 1
+     */
+    traceRatio?: number;
     /**
      * Flag to enable or disable the tracing for node:fs module
      *
@@ -34,13 +53,17 @@ export interface NodeSDKConfig extends SDKConfig {
      */
     enableFS?: boolean;
     /**
-     * http based connection protocol used to send signals.
+     * Protocol used to send signals.
      *
      * @default grpc
      */
     protocol?: SDKProtocol;
 }
+export interface SamplerCondition {
+    type: "endsWith" | "includes" | "equals";
+    url: string;
+}
+export type SignalAttributeValue = string | number | boolean;
 export type SDKCollectorMode = "single" | "batch";
-export type SDKProtocol = "grpc" | "http";
+export type SDKProtocol = "grpc" | "http" | "console";
 export type SDKLogLevel = "NONE" | "ERROR" | "WARN" | "INFO" | "DEBUG" | "VERBOSE" | "ALL";
-export {};

package/dist/lib/instrumentation.node.js

@@ -1,10 +1,13 @@
-import { NodeSDK } from "@opentelemetry/sdk-node";
-import isUrl from "is-url";
-import buildHttpExporters from "./http.js";
-import buildGrpcExporters from "./grpc.js";
 import { diag, DiagConsoleLogger, DiagLogLevel } from "@opentelemetry/api";
 import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
 import { W3CTraceContextPropagator } from "@opentelemetry/core";
+import { NodeSDK } from "@opentelemetry/sdk-node";
+import { AlwaysOffSampler, ParentBasedSampler, TraceIdRatioBasedSampler, } from "@opentelemetry/sdk-trace-base";
+import buildConsoleExporters from "./exporter/console.js";
+import buildGrpcExporters from "./exporter/grpc.js";
+import buildHttpExporters from "./exporter/http.js";
+import { ObservabilityResourceDetector } from "./resource.js";
+import { UrlSampler } from "./url-sampler.js";
 export default function buildNodeInstrumentation(config) {
     if (!config) {
         console.warn("observability config not set. Skipping NodeJS OpenTelemetry instrumentation.");
@@ -22,18 +25,33 @@ export default function buildNodeInstrumentation(config) {
     if (config.protocol === "http") {
         exporter = buildHttpExporters(config);
     }
+    else if (config.protocol === "console") {
+        exporter = buildConsoleExporters(config);
+    }
     else {
         exporter = buildGrpcExporters(config);
     }
+    const urlSampler = new UrlSampler(config.ignoreUrls, new TraceIdRatioBasedSampler(config.traceRatio ?? 1));
+    const mainSampler = new ParentBasedSampler({
+        root: urlSampler,
+        remoteParentSampled: urlSampler,
+        remoteParentNotSampled: new AlwaysOffSampler(),
+        localParentSampled: urlSampler,
+        localParentNotSampled: new AlwaysOffSampler(),
+    });
     try {
         diag.setLogger(new DiagConsoleLogger(), config.diagLogLevel
             ? DiagLogLevel[config.diagLogLevel]
             : DiagLogLevel.INFO);
         const sdk = new NodeSDK({
+            resourceDetectors: [
+                new ObservabilityResourceDetector(config.resourceAttributes),
+            ],
+            spanProcessors: exporter.spans,
             serviceName: config.serviceName,
-            traceExporter: exporter.traces,
             metricReader: exporter.metrics,
             logRecordProcessors: exporter.logs,
+            sampler: mainSampler,
             textMapPropagator: new W3CTraceContextPropagator(),
             instrumentations: [
                 getNodeAutoInstrumentations({
@@ -51,3 +69,12 @@ export default function buildNodeInstrumentation(config) {
         console.error("Error starting NodeJS OpenTelemetry instrumentation:", error);
     }
 }
+function isUrl(url) {
+    try {
+        new URL(url);
+        return true;
+    }
+    catch (_) {
+        return false;
+    }
+}

package/dist/lib/metrics.d.ts

@@ -0,0 +1,18 @@
+import { Counter, Gauge, Histogram, MetricOptions, ObservableCounter, ObservableGauge, ObservableUpDownCounter, UpDownCounter, Attributes } from "@opentelemetry/api";
+type MetricTypeMap<TAttributes extends Attributes> = {
+    counter: Counter<TAttributes>;
+    histogram: Histogram<TAttributes>;
+    gauge: Gauge<TAttributes>;
+    updowncounter: UpDownCounter<TAttributes>;
+    "async-counter": ObservableCounter<TAttributes>;
+    "async-updowncounter": ObservableUpDownCounter<TAttributes>;
+    "async-gauge": ObservableGauge<TAttributes>;
+};
+export type MetricType = keyof MetricTypeMap<Attributes>;
+export interface MetricsParams {
+    meterName: string;
+    metricName: string;
+    options?: MetricOptions;
+}
+export declare function getMetric<T extends MetricType, TAttributes extends Attributes = Attributes>(type: T, p: MetricsParams): MetricTypeMap<TAttributes>[T];
+export {};

package/dist/lib/metrics.js

@@ -0,0 +1,24 @@
+import { createNoopMeter, metrics, } from "@opentelemetry/api";
+const MetricsFactoryMap = {
+    gauge: (meter) => meter.createGauge,
+    histogram: (meter) => meter.createHistogram,
+    counter: (meter) => meter.createCounter,
+    updowncounter: (meter) => meter.createUpDownCounter,
+    "async-counter": (meter) => meter.createObservableCounter,
+    "async-updowncounter": (meter) => meter.createObservableUpDownCounter,
+    "async-gauge": (meter) => meter.createObservableGauge,
+};
+function getMeter({ meterName }) {
+    if (!meterName) {
+        console.error("Invalid metric name!");
+        return createNoopMeter();
+    }
+    return metrics.getMeter(`custom_metric.${meterName}`);
+}
+export function getMetric(type, p) {
+    const meter = getMeter(p);
+    if (!MetricsFactoryMap[type]) {
+        throw new Error(`Unsupported metric type: ${type}`);
+    }
+    return MetricsFactoryMap[type](meter).bind(meter)(p.metricName, p.options);
+}

package/dist/lib/processor/enrich-logger-processor.d.ts

@@ -0,0 +1,10 @@
+import { LogRecord, LogRecordProcessor } from "@opentelemetry/sdk-logs";
+import { Context } from "@opentelemetry/api";
+import { SignalAttributeValue } from "../index.js";
+export declare class EnrichLogProcessor implements LogRecordProcessor {
+    private _spanAttributes?;
+    constructor(spanAttributes?: Record<string, SignalAttributeValue | (() => SignalAttributeValue)>);
+    forceFlush(): Promise<void>;
+    onEmit(logRecord: LogRecord, _context?: Context): void;
+    shutdown(): Promise<void>;
+}

package/dist/lib/processor/enrich-logger-processor.js

@@ -0,0 +1,19 @@
+export class EnrichLogProcessor {
+    _spanAttributes = undefined;
+    constructor(spanAttributes) {
+        this._spanAttributes = spanAttributes;
+    }
+    forceFlush() {
+        return Promise.resolve();
+    }
+    onEmit(logRecord, _context) {
+        if (this._spanAttributes) {
+            for (const [key, value] of Object.entries(this._spanAttributes)) {
+                logRecord.setAttribute(key, typeof value === "function" ? value() : value);
+            }
+        }
+    }
+    shutdown() {
+        return Promise.resolve();
+    }
+}

package/dist/lib/processor/enrich-span-processor.d.ts

@@ -0,0 +1,11 @@
+import { Context } from "@opentelemetry/api";
+import { ReadableSpan, Span, SpanProcessor } from "@opentelemetry/sdk-trace-base";
+import { SignalAttributeValue } from "../index.js";
+export declare class EnrichSpanProcessor implements SpanProcessor {
+    private _spanAttributes;
+    constructor(spanAttributes?: Record<string, SignalAttributeValue | (() => SignalAttributeValue)>);
+    forceFlush(): Promise<void>;
+    onStart(span: Span, _context: Context): void;
+    onEnd(_span: ReadableSpan): void;
+    shutdown(): Promise<void>;
+}