@qlibs/apm 0.1.2 → 1.1.0

package/README.md

@@ -19,7 +19,8 @@ What gets traced automatically (no business-logic changes required):
 
 Metrics (RED dashboards — latency, error rate, throughput) are intentionally
 **not** exported separately: SigNoz and Elastic APM both derive these from
-trace data automatically. If you need custom business metrics later, add an
+trace data automatically. The OTel SDK therefore ships traces only
+(`OTEL_METRICS_EXPORTER` and `OTEL_LOGS_EXPORTER` default to `none`). If you need custom business metrics later, add an
 `@opentelemetry/sdk-metrics` + OTLP metrics exporter next to `tracing.ts` —
 the config/resource plumbing here already gives you everything needed to
 wire that in.
@@ -70,17 +71,209 @@ dependency of this package.
 
 | Variable | Default | Purpose |
 |---|---|---|
-| `APM_ENABLED` | `true` | Master switch. `false` fully disables tracing + remote log transports (console logging still works). |
+| `APM_ENABLED` | `true` | `false` disables tracing. Log transports are controlled only by `APM_LOG_TRANSPORT`. |
 | `APM_SERVICE_NAME` | `ats-be` | Service name shown in traces/logs — set per app, e.g. `my-app-api`. |
-| `APM_ENVIRONMENT` | `NODE_ENV` | `deployment.environment` resource attribute. |
+| `APM_ENVIRONMENT` | `NODE_ENV`, else `production` | `deployment.environment` resource attribute. Also drives the log level/format defaults below. Unset `NODE_ENV` is treated as `production` (never as local). |
 | `OTEL_EXPORTER_OTLP_ENDPOINT` | _(empty)_ | Base OTLP endpoint. Empty = tracing disabled. |
 | `OTEL_EXPORTER_OTLP_PROTOCOL` | `http/protobuf` | `http/protobuf` (port 4318 typically) or `grpc` (port 4317). Must match what your collector listens on. |
 | `OTEL_EXPORTER_OTLP_HEADERS` | _(empty)_ | Comma-separated `key=value` pairs, e.g. ingestion keys / auth tokens. |
-| `LOG_LEVEL` | `info` (`debug` locally) | Winston log level. |
-| `APM_LOG_FORMAT` | `pretty` locally, `json` otherwise | `pretty` = colorized console; `json` = structured stdout. |
-| `APM_LOG_TRANSPORT` | `stdout` | Comma list of `stdout`, `elasticsearch`, `otlp`. Multiple can be active at once. |
-| `ELASTICSEARCH_NODE` / `_USERNAME` / `_PASSWORD` / `_INDEX` | _(empty)_ | Only used when `APM_LOG_TRANSPORT` includes `elasticsearch`. |
-| `APM_HTTP_IGNORE_PATHS` | `/health,/favicon.ico` | Comma list of path prefixes excluded from the HTTP access log. |
+| `LOG_LEVEL` | `info` (`debug` when env is `local`) | Winston log level (`error`, `warn`, `info`, `http`, `verbose`, `debug`). At `info`, Nest `verbose`/`debug` logs are dropped — set `verbose` or `debug` to see them. HTTP access logs and Nest `fatal` (logged as `error` with `fatal: true`) are always visible at `info`. On the console, `error`/`warn` go to stderr and everything else to stdout. |
+| `APM_LOG_FORMAT` | `pretty` for `local`/`development`, `json` otherwise | `pretty` = colorized console; `json` = structured stdout. |
+| `APM_LOG_TRANSPORT` | `stdout` | Comma list of `stdout`, `elasticsearch`, `otlp`. Multiple can be active at once. `none` = the APM writes no log lines of its own (no access log, no extra error line); `ApmLoggerService` then just forwards to Nest's default console logger, so console output appears once, in Nest's format. Traces are unaffected. |
+| `ELASTICSEARCH_NODE` / `_USERNAME` / `_PASSWORD` / `_INDEX` | _(empty)_ | Only used when `APM_LOG_TRANSPORT` includes `elasticsearch`. While ES is unreachable at most 1000 log lines are buffered (the rest are dropped) and each is retried 5 times. Shipping via stdout + Filebeat/Fluent Bit is still preferred in production. |
+| `APM_HTTP_IGNORE_PATHS` | `/health,/favicon.ico` | Comma list of path prefixes excluded from the HTTP access log and from tracing. |
+| `OTEL_NODE_ENABLED_INSTRUMENTATIONS` | `http,undici,express,nestjs-core,pg,ioredis,redis,amqplib` | Which auto-instrumentations to load (names without the `@opentelemetry/instrumentation-` prefix). Add e.g. `mongodb`, `kafkajs` if your app needs them. |
+| `OTEL_TRACES_SAMPLER` / `OTEL_TRACES_SAMPLER_ARG` | `parentbased_always_on` | Standard OTel sampling. For high-traffic services use `parentbased_traceidratio` with e.g. `0.1` (10%). |
+
+## Recommended setup
+
+### Production
+
+```env
+NODE_ENV=production
+APM_SERVICE_NAME=my-app-api
+APM_SERVICE_VERSION=1.4.2
+LOG_LEVEL=warn
+APM_LOG_TRANSPORT=none
+OTEL_EXPORTER_OTLP_ENDPOINT=http://signoz-otel-collector:4318
+# Optional, for high-traffic services (> ~50 req/s):
+# OTEL_TRACES_SAMPLER=parentbased_traceidratio
+# OTEL_TRACES_SAMPLER_ARG=0.2
+```
+
+| Destination | What you get |
+|---|---|
+| **pm2 / docker logs** | Only `ERROR`, `WARN` and `FATAL`, in Nest's own format (`[Nest] 123 - ... ERROR [OrderService] ...`), each line **once**. Errors/fatal go to stderr (`pm2 logs --err`), warnings to stdout. No per-request access log, no `log`/`verbose`/`debug`. Plus one startup line: `[apm] tracing enabled -> ...`. |
+| **SigNoz — Traces** | Every request (except `/health`, `/favicon.ico`) including its Postgres, Redis, RabbitMQ and outbound HTTP calls. Failed requests are marked as errors with message and stack trace. Latency / error-rate / throughput dashboards are derived from these traces. |
+| **SigNoz — Logs** | Nothing is sent. |
+| **SigNoz — Metrics** | Nothing is sent. |
+| **Deploy / restart** | Pending traces are flushed (max 5s), then Nest's graceful shutdown runs normally. |
+
+In short: the terminal is for warnings and errors only; per-request detail
+lives in SigNoz.
+
+Requirements in the app:
+- `import '@qlibs/apm/tracing'` as the first line of `main.ts`.
+- `recordException()` or `ApmExceptionFilter` in place, so errors are marked
+  on the trace.
+- If `main.ts` does **not** call `app.useLogger(app.get(ApmLoggerService))`,
+  `LOG_LEVEL` does not filter Nest's output — use
+  `NestFactory.create(AppModule, { logger: ['fatal', 'error', 'warn'] })`
+  instead.
+
+On the server, enable log rotation as a safety net (`pm2 install
+pm2-logrotate`, or `max-size` / `max-file` for Docker's `json-file` driver).
+
+### Development (shared dev / staging server)
+
+```env
+NODE_ENV=development
+APM_SERVICE_NAME=my-app-api
+LOG_LEVEL=debug
+APM_LOG_TRANSPORT=stdout
+OTEL_EXPORTER_OTLP_ENDPOINT=http://signoz-otel-collector:4318
+```
+
+| Destination | What you get |
+|---|---|
+| **pm2 / docker logs** | **All levels** (error … debug), colorized and human-readable, written by the APM — e.g. `10:21:05 info [HTTP] GET /api/orders 200 (trace=4bf92f...)`. Includes a **per-request access log** with duration and `trace_id`, so any log line can be looked up as a trace in SigNoz. Nest's own logs go through the same logger, so nothing is printed twice. |
+| **SigNoz — Traces** | Every request, kept apart from production by `deployment.environment=development` (filter by environment in SigNoz). |
+| **SigNoz — Logs / Metrics** | Nothing is sent. |
+
+**Developer laptop:** use `NODE_ENV=local` and drop `LOG_LEVEL` (defaults to
+`debug`) and `OTEL_EXPORTER_OTLP_ENDPOINT`. Logs stay colorized in the
+terminal, tracing is off, nothing is sent anywhere.
+
+### At a glance
+
+| | Production | Development |
+|---|---|---|
+| Who prints to the terminal | Nest (APM is silent) | APM |
+| Levels shown | warn, error, fatal | all |
+| Per-request access log | ❌ (use SigNoz) | ✅ |
+| `trace_id` on log lines | ❌ | ✅ |
+| Traces to SigNoz | ✅ | ✅ |
+| Logs / metrics to SigNoz | ❌ | ❌ |
+
+## Example configurations
+
+`LOG_LEVEL` is a threshold: it keeps that level and everything more severe
+(`error` < `warn` < `info` < `http` < `verbose` < `debug` < `silly`). Nest's
+`logger.log()` is `info`, `logger.fatal()` is `error`. Use lowercase values
+exactly as listed — an unknown value (e.g. `WARN`, `log`, `trace`) currently
+drops **all** logs, errors included.
+
+What each setting affects:
+
+| | stdout (pm2 / docker logs) | Logs in SigNoz | Traces in SigNoz |
+|---|---|---|---|
+| `LOG_LEVEL` | ✅ | ✅ | ❌ |
+| `APM_LOG_TRANSPORT` | ✅ | ✅ (needs `otlp`) | ❌ |
+| `OTEL_TRACES_SAMPLER` | ❌ | ❌ | ✅ |
+
+Errors are still marked on the trace span by `recordException()` regardless of
+`LOG_LEVEL`. After changing env vars, restart the app (pm2:
+`pm2 restart <app> --update-env`).
+
+**1. Traces only — Nest's own console logs, no duplicate APM log lines**
+```env
+NODE_ENV=production
+APM_SERVICE_NAME=my-app-api
+LOG_LEVEL=warn
+APM_LOG_TRANSPORT=none
+OTEL_EXPORTER_OTLP_ENDPOINT=http://signoz-otel-collector:4318
+```
+pm2/docker show only Nest's normal `[Nest] ... ERROR [Context] ...` lines, each
+once. Errors still appear on the trace in SigNoz (status ERROR + exception
+event) via `recordException()`. `LOG_LEVEL` keeps working if `main.ts` calls
+`app.useLogger(app.get(ApmLoggerService))`; if it doesn't, filter Nest's output
+with `NestFactory.create(AppModule, { logger: ['fatal', 'error', 'warn'] })`
+instead. Trade-off: console lines carry no `trace_id`.
+
+**2. Production, minimal — only warn + error in pm2/docker, traces to SigNoz**
+```env
+NODE_ENV=production
+APM_SERVICE_NAME=my-app-api
+LOG_LEVEL=warn
+APM_LOG_TRANSPORT=stdout
+OTEL_EXPORTER_OTLP_ENDPOINT=http://signoz-otel-collector:4318
+```
+Note: at `warn` the HTTP access log (`GET /api/... 200`, level `info`) is
+dropped too.
+
+**3. Production, standard — info + access log in pm2/docker, logs and traces to SigNoz**
+```env
+NODE_ENV=production
+APM_SERVICE_NAME=my-app-api
+LOG_LEVEL=info
+APM_LOG_TRANSPORT=stdout,otlp
+OTEL_EXPORTER_OTLP_ENDPOINT=http://signoz-otel-collector:4318
+```
+
+**4. Production, high traffic — trace only 10% of requests**
+```env
+NODE_ENV=production
+APM_SERVICE_NAME=my-app-api
+LOG_LEVEL=warn
+APM_LOG_TRANSPORT=stdout,otlp
+OTEL_EXPORTER_OTLP_ENDPOINT=http://signoz-otel-collector:4318
+OTEL_TRACES_SAMPLER=parentbased_traceidratio
+OTEL_TRACES_SAMPLER_ARG=0.1
+```
+
+**5. Staging, investigating a bug — everything**
+```env
+NODE_ENV=staging
+APM_SERVICE_NAME=my-app-api
+LOG_LEVEL=debug
+APM_LOG_TRANSPORT=stdout,otlp
+OTEL_EXPORTER_OTLP_ENDPOINT=http://signoz-otel-collector:4318
+```
+
+**6. Local development, no SigNoz**
+```env
+NODE_ENV=local
+APM_SERVICE_NAME=my-app-api
+# LOG_LEVEL defaults to debug, format to colorized pretty output
+# OTEL_EXPORTER_OTLP_ENDPOINT left empty -> tracing off
+```
+
+**7. Logs to pm2/docker only, no tracing at all**
+```env
+NODE_ENV=production
+APM_SERVICE_NAME=my-app-api
+LOG_LEVEL=warn
+APM_LOG_TRANSPORT=stdout
+# OTEL_EXPORTER_OTLP_ENDPOINT not set -> nothing is sent to SigNoz
+```
+
+**8. Collector listening on gRPC (port 4317)**
+```env
+OTEL_EXPORTER_OTLP_ENDPOINT=http://signoz-otel-collector:4317
+OTEL_EXPORTER_OTLP_PROTOCOL=grpc
+```
+
+**9. Logs to Elasticsearch / Kibana**
+```env
+NODE_ENV=production
+APM_SERVICE_NAME=my-app-api
+LOG_LEVEL=warn
+APM_LOG_TRANSPORT=stdout,elasticsearch
+ELASTICSEARCH_NODE=https://es.internal:9200
+ELASTICSEARCH_USERNAME=elastic
+ELASTICSEARCH_PASSWORD=changeme
+```
+
+To stop shipping logs remotely, remove `otlp` / `elasticsearch` from
+`APM_LOG_TRANSPORT` — `APM_ENABLED=false` currently only turns tracing off.
+
+## Shutdown
+
+On `SIGTERM`/`SIGINT` the tracing SDK flushes pending spans (max 5s) but does
+**not** call `process.exit()` — your app's own graceful shutdown (e.g.
+`app.enableShutdownHooks()` in Nest) stays in control. If no other signal
+handler is registered, the signal is re-raised after the flush so the process
+still terminates normally.
 
 ## Pointing at a specific backend
 

package/dist/apm.config.d.ts

@@ -1,5 +1,5 @@
 export type LogFormat = 'pretty' | 'json';
-export type LogTransportKind = 'stdout' | 'elasticsearch' | 'otlp';
+export type LogTransportKind = 'stdout' | 'elasticsearch' | 'otlp' | 'none';
 export type OtlpProtocol = 'http/protobuf' | 'grpc';
 export interface ApmConfig {
     enabled: boolean;
@@ -13,6 +13,7 @@ export interface ApmConfig {
         headers: Record<string, string>;
     };
     logging: {
+        enabled: boolean;
         level: string;
         format: LogFormat;
         transports: LogTransportKind[];

package/dist/apm.config.js

@@ -29,7 +29,8 @@ function getApmConfig() {
     if (cachedConfig)
         return cachedConfig;
     const env = process.env;
-    const nodeEnv = env.NODE_ENV || 'local';
+    const nodeEnv = env.APM_ENVIRONMENT || env.NODE_ENV || 'production';
+    const isLocal = nodeEnv === 'local' || nodeEnv === 'development';
     const otlpEndpoint = env.OTEL_EXPORTER_OTLP_ENDPOINT || undefined;
     const transports = parseList(env.APM_LOG_TRANSPORT);
     cachedConfig = {
@@ -44,9 +45,9 @@ function getApmConfig() {
             headers: parseHeaders(env.OTEL_EXPORTER_OTLP_HEADERS),
         },
         logging: {
+            enabled: !transports.includes('none'),
             level: env.LOG_LEVEL || (nodeEnv === 'local' ? 'debug' : 'info'),
-            format: env.APM_LOG_FORMAT ||
-                (nodeEnv === 'local' || nodeEnv === 'development' ? 'pretty' : 'json'),
+            format: env.APM_LOG_FORMAT || (isLocal ? 'pretty' : 'json'),
             transports: transports.length ? transports : ['stdout'],
             elasticsearch: {
                 node: env.ELASTICSEARCH_NODE || undefined,

package/dist/filters/apm-exception.filter.js

@@ -14,7 +14,7 @@ let ApmExceptionFilter = class ApmExceptionFilter {
         (0, record_exception_1.recordException)(err, 'ApmExceptionFilter');
         const ctx = host.switchToHttp();
         const response = ctx.getResponse();
-        if (!(response === null || response === void 0 ? void 0 : response.status))
+        if (!(response === null || response === void 0 ? void 0 : response.status) || response.headersSent)
             return;
         const status = err instanceof common_1.HttpException ? err.getStatus() : 500;
         const body = err instanceof common_1.HttpException

package/dist/http/apm-logging.interceptor.js

@@ -14,7 +14,7 @@ const apm_config_1 = require("../apm.config");
 const winston_instance_1 = require("../logger/winston.instance");
 let ApmLoggingInterceptor = class ApmLoggingInterceptor {
     intercept(context, next) {
-        if (context.getType() !== 'http') {
+        if (context.getType() !== 'http' || !(0, apm_config_1.getApmConfig)().logging.enabled) {
             return next.handle();
         }
         const request = context.switchToHttp().getRequest();
@@ -30,7 +30,7 @@ let ApmLoggingInterceptor = class ApmLoggingInterceptor {
         return next.handle().pipe((0, rxjs_1.tap)({
             next: () => {
                 const response = context.switchToHttp().getResponse();
-                winston_instance_1.winstonLogger.http(`${method} ${path} ${response.statusCode}`, {
+                winston_instance_1.winstonLogger.info(`${method} ${path} ${response.statusCode}`, {
                     context: 'HTTP',
                     method,
                     path,
@@ -41,7 +41,7 @@ let ApmLoggingInterceptor = class ApmLoggingInterceptor {
                 });
             },
             error: (err) => {
-                winston_instance_1.winstonLogger.http(`${method} ${path} failed`, {
+                winston_instance_1.winstonLogger.info(`${method} ${path} failed`, {
                     context: 'HTTP',
                     method,
                     path,

package/dist/logger/apm-logger.service.d.ts

@@ -1,9 +1,11 @@
 import { LoggerService } from '@nestjs/common';
 export declare class ApmLoggerService implements LoggerService {
+    private readonly fallback;
     log(message: any, context?: string): void;
     error(message: any, trace?: string, context?: string): void;
     warn(message: any, context?: string): void;
     debug(message: any, context?: string): void;
+    fatal(message: any, context?: string): void;
     verbose(message: any, context?: string): void;
     private stringify;
 }

package/dist/logger/apm-logger.service.js

@@ -8,21 +8,57 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApmLoggerService = void 0;
 const common_1 = require("@nestjs/common");
+const apm_config_1 = require("../apm.config");
 const winston_instance_1 = require("./winston.instance");
+const NEST_LEVELS = {
+    error: ['fatal', 'error'],
+    warn: ['fatal', 'error', 'warn'],
+    info: ['fatal', 'error', 'warn', 'log'],
+    http: ['fatal', 'error', 'warn', 'log'],
+    verbose: ['fatal', 'error', 'warn', 'log', 'verbose'],
+    debug: ['fatal', 'error', 'warn', 'log', 'verbose', 'debug'],
+    silly: ['fatal', 'error', 'warn', 'log', 'verbose', 'debug'],
+};
+function buildFallbackLogger() {
+    const { logging } = (0, apm_config_1.getApmConfig)();
+    if (logging.enabled)
+        return undefined;
+    return new common_1.ConsoleLogger(undefined, {
+        logLevels: NEST_LEVELS[logging.level] || NEST_LEVELS.info,
+    });
+}
 let ApmLoggerService = class ApmLoggerService {
+    constructor() {
+        this.fallback = buildFallbackLogger();
+    }
     log(message, context) {
+        if (this.fallback)
+            return this.fallback.log(message, context);
         winston_instance_1.winstonLogger.info(this.stringify(message), { context });
     }
     error(message, trace, context) {
+        if (this.fallback)
+            return this.fallback.error(message, trace, context);
         winston_instance_1.winstonLogger.error(this.stringify(message), { trace, context });
     }
     warn(message, context) {
+        if (this.fallback)
+            return this.fallback.warn(message, context);
         winston_instance_1.winstonLogger.warn(this.stringify(message), { context });
     }
     debug(message, context) {
+        if (this.fallback)
+            return this.fallback.debug(message, context);
         winston_instance_1.winstonLogger.debug(this.stringify(message), { context });
     }
+    fatal(message, context) {
+        if (this.fallback)
+            return this.fallback.fatal(message, context);
+        winston_instance_1.winstonLogger.error(this.stringify(message), { context, fatal: true });
+    }
     verbose(message, context) {
+        if (this.fallback)
+            return this.fallback.verbose(message, context);
         winston_instance_1.winstonLogger.verbose(this.stringify(message), { context });
     }
     stringify(message) {

package/dist/logger/otlp-log.transport.js

@@ -28,25 +28,33 @@ const SEVERITY_MAP = {
     silly: { number: 1, text: 'TRACE' },
 };
 let otelLogger;
+let emitFailureReported = false;
 function getOtelLogger() {
     if (otelLogger)
         return otelLogger;
     const config = (0, apm_config_1.getApmConfig)();
     const { LoggerProvider, BatchLogRecordProcessor, } = require('@opentelemetry/sdk-logs');
-    const { OTLPLogExporter } = require('@opentelemetry/exporter-logs-otlp-http');
     const { resourceFromAttributes } = require('@opentelemetry/resources');
     const { ATTR_SERVICE_NAME } = require('@opentelemetry/semantic-conventions');
-    const base = (config.tracing.otlpEndpoint || '').replace(/\/$/, '');
-    const exporter = new OTLPLogExporter({
-        url: `${base}/v1/logs`,
-        headers: config.tracing.headers,
-    });
+    let exporter;
+    if (config.tracing.protocol === 'grpc') {
+        const { OTLPLogExporter, } = require('@opentelemetry/exporter-logs-otlp-grpc');
+        exporter = new OTLPLogExporter({ url: config.tracing.otlpEndpoint });
+    }
+    else {
+        const { OTLPLogExporter, } = require('@opentelemetry/exporter-logs-otlp-http');
+        const base = (config.tracing.otlpEndpoint || '').replace(/\/$/, '');
+        exporter = new OTLPLogExporter({
+            url: `${base}/v1/logs`,
+            headers: config.tracing.headers,
+        });
+    }
     const provider = new LoggerProvider({
         resource: resourceFromAttributes({
             [ATTR_SERVICE_NAME]: config.serviceName,
         }),
+        processors: [new BatchLogRecordProcessor({ exporter })],
     });
-    provider.addLogRecordProcessor(new BatchLogRecordProcessor(exporter));
     otelLogger = provider.getLogger(config.serviceName);
     return otelLogger;
 }
@@ -64,7 +72,11 @@ class OtlpLogTransport extends winston_transport_1.default {
                 context: api_1.context.active(),
             });
         }
-        catch (_a) {
+        catch (err) {
+            if (!emitFailureReported) {
+                emitFailureReported = true;
+                console.error('[apm] otlp log transport failed, logs are not being exported:', err instanceof Error ? err.message : err);
+            }
         }
         callback();
     }

package/dist/logger/winston.instance.js

@@ -61,7 +61,10 @@ function buildConsoleTransport() {
             return `${timestamp} ${level}${ctx} ${message}${trace}${extra}`;
         }))
         : winston.format.combine((0, trace_context_format_1.traceContextFormat)(), winston.format.timestamp(), winston.format.json());
-    return new winston.transports.Console({ format });
+    return new winston.transports.Console({
+        format,
+        stderrLevels: ['error', 'warn'],
+    });
 }
 function buildElasticsearchTransport() {
     const config = (0, apm_config_1.getApmConfig)();
@@ -73,6 +76,8 @@ function buildElasticsearchTransport() {
     return new ElasticsearchTransport({
         level: config.logging.level,
         indexPrefix: config.logging.elasticsearch.index,
+        bufferLimit: 1000,
+        retryLimit: 5,
         clientOpts: {
             node: config.logging.elasticsearch.node,
             auth: config.logging.elasticsearch.username &&
@@ -117,8 +122,17 @@ function buildTransports() {
     return transports;
 }
 const config = (0, apm_config_1.getApmConfig)();
-exports.winstonLogger = winston.createLogger({
-    level: config.logging.level,
-    defaultMeta: { service: config.serviceName, environment: config.environment },
-    transports: buildTransports(),
+exports.winstonLogger = config.logging.enabled
+    ? winston.createLogger({
+        level: config.logging.level,
+        defaultMeta: {
+            service: config.serviceName,
+            environment: config.environment,
+        },
+        transports: buildTransports(),
+    })
+    :
+        winston.createLogger({ silent: true });
+exports.winstonLogger.on('error', (err) => {
+    console.error('[apm] log transport error:', err instanceof Error ? err.message : err);
 });

package/dist/tracing.js

@@ -1,19 +1,21 @@
 "use strict";
+var _a, _b;
 Object.defineProperty(exports, "__esModule", { value: true });
 const apm_config_1 = require("./apm.config");
 const config = (0, apm_config_1.getApmConfig)();
 if (config.enabled && config.tracing.enabled && config.tracing.otlpEndpoint) {
+    if (!process.env.OTEL_NODE_ENABLED_INSTRUMENTATIONS) {
+        process.env.OTEL_NODE_ENABLED_INSTRUMENTATIONS =
+            'http,undici,express,nestjs-core,pg,ioredis,redis,amqplib';
+    }
+    (_a = process.env).OTEL_METRICS_EXPORTER || (_a.OTEL_METRICS_EXPORTER = 'none');
+    (_b = process.env).OTEL_LOGS_EXPORTER || (_b.OTEL_LOGS_EXPORTER = 'none');
     const { NodeSDK } = require('@opentelemetry/sdk-node');
     const { getNodeAutoInstrumentations, } = require('@opentelemetry/auto-instrumentations-node');
-    const { OTLPTraceExporter, } = require('@opentelemetry/exporter-trace-otlp-http');
     const { resourceFromAttributes } = require('@opentelemetry/resources');
     const { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION, } = require('@opentelemetry/semantic-conventions');
-    const traceExporter = new OTLPTraceExporter({
-        url: config.tracing.protocol === 'grpc'
-            ? config.tracing.otlpEndpoint
-            : `${config.tracing.otlpEndpoint.replace(/\/$/, '')}/v1/traces`,
-        headers: config.tracing.headers,
-    });
+    const traceExporter = createTraceExporter();
+    const ignorePaths = config.http.ignorePaths;
     const sdk = new NodeSDK({
         resource: resourceFromAttributes({
             [ATTR_SERVICE_NAME]: config.serviceName,
@@ -24,20 +26,46 @@ if (config.enabled && config.tracing.enabled && config.tracing.otlpEndpoint) {
         instrumentations: [
             getNodeAutoInstrumentations({
                 '@opentelemetry/instrumentation-fs': { enabled: false },
+                '@opentelemetry/instrumentation-http': {
+                    ignoreIncomingRequestHook: (req) => ignorePaths.some((p) => { var _a; return (_a = req.url) === null || _a === void 0 ? void 0 : _a.startsWith(p); }),
+                },
             }),
         ],
     });
     sdk.start();
-    const shutdown = () => {
-        sdk
-            .shutdown()
-            .catch((err) => console.error('Error shutting down OTel SDK', err))
-            .finally(() => process.exit(0));
+    const SHUTDOWN_TIMEOUT_MS = 5000;
+    const onSignal = (signal) => {
+        let timer;
+        Promise.race([
+            sdk.shutdown(),
+            new Promise((resolve) => {
+                timer = setTimeout(resolve, SHUTDOWN_TIMEOUT_MS);
+            }),
+        ])
+            .catch((err) => console.error('[apm] error shutting down OTel SDK', err))
+            .finally(() => {
+            clearTimeout(timer);
+            if (process.listenerCount(signal) === 0) {
+                process.kill(process.pid, signal);
+            }
+        });
     };
-    process.on('SIGTERM', shutdown);
-    process.on('SIGINT', shutdown);
-    console.info(`[apm] tracing enabled -> ${config.tracing.otlpEndpoint} (service: ${config.serviceName})`);
+    process.once('SIGTERM', onSignal);
+    process.once('SIGINT', onSignal);
+    console.info(`[apm] tracing enabled -> ${config.tracing.otlpEndpoint} (${config.tracing.protocol}, service: ${config.serviceName})`);
 }
 else {
     console.info('[apm] tracing disabled (set OTEL_EXPORTER_OTLP_ENDPOINT to enable)');
 }
+function createTraceExporter() {
+    const { otlpEndpoint, protocol, headers } = config.tracing;
+    if (protocol === 'grpc') {
+        const { OTLPTraceExporter, } = require('@opentelemetry/exporter-trace-otlp-grpc');
+        return new OTLPTraceExporter({ url: otlpEndpoint });
+    }
+    const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http');
+    return new OTLPTraceExporter({
+        url: `${otlpEndpoint.replace(/\/$/, '')}/v1/traces`,
+        headers,
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qlibs/apm",
-  "version": "0.1.2",
+  "version": "1.1.0",
   "description": "Vendor-neutral APM for NestJS: OpenTelemetry tracing (OTLP) + structured logging + error monitoring. Works with SigNoz, Elastic/Kibana, Jaeger, or any OTel collector.",
   "author": "QBIT Developer",
   "license": "MIT",
@@ -28,7 +28,9 @@
     "@opentelemetry/api": "^1.9.1",
     "@opentelemetry/api-logs": "^0.221.0",
     "@opentelemetry/auto-instrumentations-node": "^0.79.0",
+    "@opentelemetry/exporter-logs-otlp-grpc": "^0.221.0",
     "@opentelemetry/exporter-logs-otlp-http": "^0.221.0",
+    "@opentelemetry/exporter-trace-otlp-grpc": "^0.221.0",
     "@opentelemetry/exporter-trace-otlp-http": "^0.221.0",
     "@opentelemetry/resources": "^2.10.0",
     "@opentelemetry/sdk-logs": "^0.221.0",