@ogcio/o11y-sdk-node 0.1.0-beta.6 → 0.1.0-beta.8

package/test/integration/run.sh

@@ -37,6 +37,9 @@ if [[ $ERROR_CODE -eq 0 ]]; then
     docker run --detach \
         --network $NETWORK_NAME \
         --name $NODE_CONTAINER_NAME \
+        -e DB_DISABLED="true" \
+        -e SERVER_HOST="0.0.0.0" \
+        -e OTEL_COLLECTOR_URL="http://integrationalloy:4317" \
         --health-cmd="curl -f http://${NODE_CONTAINER_NAME}:9091/api/health > /dev/null || exit 1" \
         --health-start-period=1s \
         --health-retries=10 \
@@ -60,9 +63,9 @@ fi
 
 if [[ $ERROR_CODE -eq 0 ]]; then
     sleep 2
-    curl -X GET -f http://localhost:9091/api/dummy
+    curl -X GET -f http://localhost:9091/api/dummy -H 'Content-Type: application/json'
     sleep 2
-    curl -X GET -f http://localhost:9091/api/dummy
+    curl -X GET -f http://localhost:9091/api/dummy -H 'Content-Type: application/json'
 fi
 
 # sleep N seconds to await instrumentation flow send and receiving signals

package/test/metrics.test.ts

@@ -29,7 +29,7 @@ describe("MetricsFactoryMap", () => {
 
   const validMetricParams: MetricsParams = {
     metricName: "test-metric",
-    attributeName: "test-attribute",
+    meterName: "test-meter",
     options: { description: "A test metric" },
   };
 
@@ -40,7 +40,7 @@ describe("MetricsFactoryMap", () => {
 
     expect(result).toBe("mocked-gauge");
     expect(mockMeter.createGauge).toHaveBeenCalledWith(
-      validMetricParams.attributeName,
+      validMetricParams.metricName,
       validMetricParams.options,
     );
   });
@@ -52,7 +52,7 @@ describe("MetricsFactoryMap", () => {
 
     expect(result).toBe("mocked-histogram");
     expect(mockMeter.createHistogram).toHaveBeenCalledWith(
-      validMetricParams.attributeName,
+      validMetricParams.metricName,
       validMetricParams.options,
     );
   });
@@ -64,7 +64,7 @@ describe("MetricsFactoryMap", () => {
 
     expect(result).toBe("mocked-counter");
     expect(mockMeter.createCounter).toHaveBeenCalledWith(
-      validMetricParams.attributeName,
+      validMetricParams.metricName,
       validMetricParams.options,
     );
   });
@@ -76,7 +76,7 @@ describe("MetricsFactoryMap", () => {
 
     expect(result).toBe("mocked-updowncounter");
     expect(mockMeter.createUpDownCounter).toHaveBeenCalledWith(
-      validMetricParams.attributeName,
+      validMetricParams.metricName,
       validMetricParams.options,
     );
   });
@@ -88,7 +88,7 @@ describe("MetricsFactoryMap", () => {
 
     expect(result).toBe("mocked-async-counter");
     expect(mockMeter.createObservableCounter).toHaveBeenCalledWith(
-      validMetricParams.attributeName,
+      validMetricParams.metricName,
       validMetricParams.options,
     );
   });
@@ -102,7 +102,7 @@ describe("MetricsFactoryMap", () => {
 
     expect(result).toBe("mocked-async-updowncounter");
     expect(mockMeter.createObservableUpDownCounter).toHaveBeenCalledWith(
-      validMetricParams.attributeName,
+      validMetricParams.metricName,
       validMetricParams.options,
     );
   });
@@ -114,7 +114,7 @@ describe("MetricsFactoryMap", () => {
 
     expect(result).toBe("mocked-async-gauge");
     expect(mockMeter.createObservableGauge).toHaveBeenCalledWith(
-      validMetricParams.attributeName,
+      validMetricParams.metricName,
       validMetricParams.options,
     );
   });
@@ -131,7 +131,7 @@ describe("MetricsFactoryMap", () => {
   test("should return noop metric fallback for null config", async () => {
     const nullMetricParams: MetricsParams = {
       metricName: null!,
-      attributeName: "",
+      meterName: "",
     };
 
     const result = getMetric("async-gauge", nullMetricParams);

package/test/node-config.test.ts

@@ -9,7 +9,17 @@ import { OTLPTraceExporter as HTTP_OTLPTraceExporter } from "@opentelemetry/expo
 import { OTLPMetricExporter as HTTP_OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
 import { OTLPLogExporter as HTTP_OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
 import { NodeSDKConfig } from "../lib/index.js";
-import buildHttpExporters from "../lib/http.js";
+import buildHttpExporters from "../lib/exporter/http.js";
+import {
+  BatchSpanProcessor,
+  ConsoleSpanExporter,
+  SimpleSpanProcessor,
+} from "@opentelemetry/sdk-trace-base";
+import {
+  BatchLogRecordProcessor,
+  SimpleLogRecordProcessor,
+} from "@opentelemetry/sdk-logs";
+import { EnrichSpanProcessor } from "../lib/processor/enrich-span-processor.js";
 
 describe("verify config settings", () => {
   const commonConfig = {
@@ -21,6 +31,7 @@ describe("verify config settings", () => {
     const config: NodeSDKConfig = {
       ...commonConfig,
       protocol: "grpc",
+      collectorMode: "batch",
       diagLogLevel: "NONE",
     };
 
@@ -31,20 +42,21 @@ describe("verify config settings", () => {
     const _configuration = sdk["_configuration"];
     assert.equal(_configuration.serviceName, commonConfig.serviceName);
 
-    const traceExporter = _configuration.traceExporter;
+    const logs = _configuration.logRecordProcessors;
 
-    assert.ok(traceExporter instanceof GRPC_OTLPTraceExporter);
+    assert.equal(logs.length, 1);
+    assert.ok(logs[0] instanceof BatchLogRecordProcessor);
+
+    const spans = _configuration.spanProcessors;
+
+    assert.equal(spans.length, 2);
+    assert.ok(spans[0] instanceof BatchSpanProcessor);
+    assert.ok(spans[1] instanceof EnrichSpanProcessor);
 
-    const logRecordProcessors = _configuration.logRecordProcessors;
-    assert.equal(logRecordProcessors.length, 1);
-    // assert default signals sending mode
-    assert.ok(logRecordProcessors[0] instanceof logs.BatchLogRecordProcessor);
     assert.ok(
-      logRecordProcessors[0]["_exporter"] instanceof GRPC_OTLPLogExporter,
+      _configuration.metricReader instanceof
+        metrics.PeriodicExportingMetricReader,
     );
-
-    const metricReader = _configuration.metricReader;
-    assert.ok(metricReader._exporter instanceof GRPC_OTLPMetricExporter);
   });
 
   test("http config", () => {
@@ -60,19 +72,21 @@ describe("verify config settings", () => {
     const _configuration = sdk["_configuration"];
     assert.equal(_configuration.serviceName, commonConfig.serviceName);
 
-    const traceExporter = _configuration.traceExporter;
-    assert.ok(traceExporter instanceof HTTP_OTLPTraceExporter);
+    const logs = _configuration.logRecordProcessors;
+
+    assert.equal(logs.length, 1);
+    assert.ok(logs[0] instanceof BatchLogRecordProcessor);
+
+    const spans = _configuration.spanProcessors;
+
+    assert.equal(spans.length, 2);
+    assert.ok(spans[0] instanceof BatchSpanProcessor);
+    assert.ok(spans[1] instanceof EnrichSpanProcessor);
 
-    const logRecordProcessors = _configuration.logRecordProcessors;
-    assert.equal(logRecordProcessors.length, 1);
-    // assert default signals sending mode
-    assert.ok(logRecordProcessors[0] instanceof logs.BatchLogRecordProcessor);
     assert.ok(
-      logRecordProcessors[0]["_exporter"] instanceof HTTP_OTLPLogExporter,
+      _configuration.metricReader instanceof
+        metrics.PeriodicExportingMetricReader,
     );
-
-    const metricReader = _configuration.metricReader;
-    assert.ok(metricReader._exporter instanceof HTTP_OTLPMetricExporter);
   });
 
   test("console - console config", () => {
@@ -82,30 +96,29 @@ describe("verify config settings", () => {
       diagLogLevel: "NONE",
     };
 
-    const sdk: NodeSDK | undefined = buildNodeInstrumentation(config);
+    const sdk: NodeSDK = buildNodeInstrumentation(config)!;
     assert.ok(sdk);
 
     const _configuration = sdk["_configuration"];
     assert.equal(_configuration.serviceName, commonConfig.serviceName);
 
-    const traceExporter = _configuration.traceExporter;
+    const logs = _configuration.logRecordProcessors;
 
-    assert.ok(traceExporter instanceof tracing.ConsoleSpanExporter);
-    assert.isUndefined(traceExporter._transport);
+    // verify simple log processor for instant console logging
+    assert.equal(logs.length, 1);
+    assert.ok(logs[0] instanceof SimpleLogRecordProcessor);
 
-    const logRecordProcessors = _configuration.logRecordProcessors;
-    assert.equal(logRecordProcessors.length, 1);
+    const spans = _configuration.spanProcessors;
+
+    assert.equal(spans.length, 2);
+    // verify simple span for instant console logging
+    assert.ok(spans[0] instanceof SimpleSpanProcessor);
+    assert.ok(spans[1] instanceof EnrichSpanProcessor);
 
-    assert.ok(logRecordProcessors[0] instanceof logs.SimpleLogRecordProcessor);
     assert.ok(
-      logRecordProcessors[0]["_exporter"] instanceof
-        logs.ConsoleLogRecordExporter,
+      _configuration.metricReader instanceof
+        metrics.PeriodicExportingMetricReader,
     );
-    assert.isUndefined(logRecordProcessors[0]["_exporter"]._transport);
-
-    const metricReader = _configuration.metricReader;
-    assert.ok(metricReader._exporter instanceof metrics.ConsoleMetricExporter);
-    assert.isUndefined(metricReader._exporter._transport);
   });
 
   test("single log sending config", () => {
@@ -124,7 +137,7 @@ describe("verify config settings", () => {
 
     const logRecordProcessors = _configuration.logRecordProcessors;
     assert.equal(logRecordProcessors.length, 1);
-    assert.ok(logRecordProcessors[0] instanceof logs.SimpleLogRecordProcessor);
+    assert.ok(logRecordProcessors[0] instanceof SimpleLogRecordProcessor);
   });
 
   test("check if clear base endpoint final slash", () => {

package/test/url-sampler.test.ts

@@ -0,0 +1,215 @@
+import { Context } from "@opentelemetry/api";
+import {
+  SamplingDecision,
+  SamplingResult,
+} from "@opentelemetry/sdk-trace-base";
+import { describe, expect, test, vi } from "vitest";
+import { UrlSampler } from "../lib/url-sampler";
+
+describe("url sampler", () => {
+  // mock sampler to be sure every trace after UrlSamper has RECORD status
+  const mockSampler = {
+    shouldSample: vi
+      .fn()
+      .mockImplementation(
+        (_context, _traceId, _spanName, _spanKind, attributes, _links) => {
+          return {
+            decision: SamplingDecision.RECORD,
+            attributes: attributes,
+          } as SamplingResult;
+        },
+      ),
+  };
+
+  test("should add custom span attributes to trace", async () => {
+    const sampler: UrlSampler = new UrlSampler(
+      [
+        {
+          type: "endsWith",
+          url: "/health",
+        },
+      ],
+      mockSampler,
+      {
+        "signal.namespace": "unittest",
+        "signal.callback.result": () => "test",
+      },
+    );
+
+    expect(sampler).not.toBeNull();
+
+    const result = sampler.shouldSample(
+      {} as Context,
+      "traceId",
+      "span",
+      0,
+      { "http.target": "/track" },
+      [],
+    );
+
+    expect(sampler.toString()).toBe("UrlSampler");
+    expect(result.decision).toBe(SamplingDecision.RECORD);
+    expect(result.attributes).not.toBeNull();
+  });
+
+  test("should not record trace about /health api", async () => {
+    const sampler: UrlSampler = new UrlSampler(
+      [
+        {
+          type: "endsWith",
+          url: "/health",
+        },
+      ],
+      mockSampler,
+    );
+
+    const result = sampler.shouldSample(
+      {} as Context,
+      "traceId",
+      "span",
+      0,
+      { "http.target": "/health" },
+      [],
+    );
+
+    expect(sampler.toString()).toBe("UrlSampler");
+    expect(result.decision).toBe(SamplingDecision.NOT_RECORD);
+  });
+
+  test("should record every other trace which is not /health api", async () => {
+    const sampler: UrlSampler = new UrlSampler(
+      [
+        {
+          type: "endsWith",
+          url: "/health",
+        },
+      ],
+      mockSampler,
+    );
+
+    let result = sampler.shouldSample(
+      {} as Context,
+      "traceId",
+      "span",
+      0,
+      { "http.target": "/test" },
+      [],
+    );
+
+    expect(result.decision).toBe(SamplingDecision.RECORD);
+
+    result = sampler.shouldSample(
+      {} as Context,
+      "traceId",
+      "span",
+      0,
+      { "http.target": "/another/url" },
+      [],
+    );
+
+    expect(result.decision).toBe(SamplingDecision.RECORD);
+  });
+
+  test("operator 'includes', should not record every trace which include /block in url", async () => {
+    const sampler: UrlSampler = new UrlSampler(
+      [
+        {
+          type: "includes",
+          url: "/block",
+        },
+      ],
+      mockSampler,
+    );
+
+    expect(sampler).not.toBeNull();
+
+    const result = sampler.shouldSample(
+      {} as Context,
+      "traceId",
+      "span",
+      0,
+      { "http.target": "/namespace/block/example/12" },
+      [],
+    );
+
+    expect(sampler.toString()).toBe("UrlSampler");
+    expect(result.decision).toBe(SamplingDecision.NOT_RECORD);
+  });
+
+  test("operator 'endsWith', should not record only trace which ends with /block in url", async () => {
+    const sampler: UrlSampler = new UrlSampler(
+      [
+        {
+          type: "endsWith",
+          url: "/block",
+        },
+      ],
+      mockSampler,
+    );
+
+    expect(sampler).not.toBeNull();
+
+    // expect traced with block in the URL middle
+    let result = sampler.shouldSample(
+      {} as Context,
+      "traceId",
+      "span",
+      0,
+      { "http.target": "/namespace/block/example/12" },
+      [],
+    );
+
+    expect(sampler.toString()).toBe("UrlSampler");
+    expect(result.decision).toBe(SamplingDecision.RECORD);
+
+    // should stop trace with block at the end
+    result = sampler.shouldSample(
+      {} as Context,
+      "traceId",
+      "span",
+      0,
+      { "http.target": "/namespace/example/block" },
+      [],
+    );
+
+    expect(sampler.toString()).toBe("UrlSampler");
+    expect(result.decision).toBe(SamplingDecision.NOT_RECORD);
+  });
+
+  test("operator 'equals', should not record trace which is equal to /block in url", async () => {
+    const sampler: UrlSampler = new UrlSampler(
+      [
+        {
+          type: "equals",
+          url: "/block",
+        },
+      ],
+      mockSampler,
+    );
+
+    expect(sampler).not.toBeNull();
+
+    let result = sampler.shouldSample(
+      {} as Context,
+      "traceId",
+      "span",
+      0,
+      { "http.target": "/namespace/block/example/12" },
+      [],
+    );
+
+    expect(sampler.toString()).toBe("UrlSampler");
+    expect(result.decision).toBe(SamplingDecision.RECORD);
+
+    result = sampler.shouldSample(
+      {} as Context,
+      "traceId",
+      "span",
+      0,
+      { "http.target": "/block" },
+      [],
+    );
+
+    expect(result.decision).toBe(SamplingDecision.NOT_RECORD);
+  });
+});

package/vitest.config.ts

@@ -4,7 +4,6 @@ export default defineConfig({
   test: {
     globals: true,
     watch: false,
-    include: ["**/test/*.test.ts", "**/test/integration/*.test.ts"],
     exclude: ["**/fixtures/**", "**/dist/**"],
     poolOptions: {
       threads: {
@@ -22,5 +21,20 @@ export default defineConfig({
     },
     reporters: ["default", ["junit", { outputFile: "test-report.xml" }]],
     environment: "node",
+    pool: "threads",
+    workspace: [
+      {
+        test: {
+          include: ["**/test/*.test.ts"],
+          name: "unit",
+        },
+      },
+      {
+        test: {
+          include: ["**/test/integration/*.test.ts"],
+          name: "integration",
+        },
+      },
+    ],
   },
 });

package/dist/lib/console.d.ts

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

package/dist/lib/console.js

@@ -1,12 +0,0 @@
-import { logs, metrics, tracing } from "@opentelemetry/sdk-node";
-export default function buildConsoleExporters(_) {
-    return {
-        traces: new tracing.ConsoleSpanExporter(),
-        metrics: new metrics.PeriodicExportingMetricReader({
-            exporter: new metrics.ConsoleMetricExporter(),
-        }),
-        logs: [
-            new logs.SimpleLogRecordProcessor(new logs.ConsoleLogRecordExporter()),
-        ],
-    };
-}

package/dist/lib/grpc.d.ts

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

package/dist/lib/http.d.ts

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

package/lib/console.ts

@@ -1,15 +0,0 @@
-import type { NodeSDKConfig } from "./index.js";
-import type { Exporters } from "./options.js";
-import { logs, metrics, tracing } from "@opentelemetry/sdk-node";
-
-export default function buildConsoleExporters(_: NodeSDKConfig): Exporters {
-  return {
-    traces: new tracing.ConsoleSpanExporter(),
-    metrics: new metrics.PeriodicExportingMetricReader({
-      exporter: new metrics.ConsoleMetricExporter(),
-    }),
-    logs: [
-      new logs.SimpleLogRecordProcessor(new logs.ConsoleLogRecordExporter()),
-    ],
-  };
-}