@provide-io/telemetry 0.2.2 → 0.2.4

package/src/runtime.ts

@@ -12,6 +12,7 @@ import {
   configFromEnv,
   setupTelemetry,
 } from './config';
+import { ConfigurationError } from './exceptions';
 
 /** Minimal interface for providers that can be flushed and shut down cleanly. */
 export interface ShutdownableProvider {
@@ -47,6 +48,7 @@ export function _areProvidersRegistered(): boolean {
 
 function deepFreeze<T extends object>(obj: T): Readonly<T> {
   for (const val of Object.values(obj)) {
+    // Stryker disable next-line ConditionalExpression,EqualityOperator,LogicalOperator: frozen-object guard — all sub-conditions required but only observable with deeply nested mutable objects
     if (typeof val === 'object' && val !== null && !Object.isFrozen(val)) {
       deepFreeze(val as object);
     }
@@ -62,6 +64,7 @@ export function getRuntimeConfig(): Readonly<TelemetryConfig> {
 
 /** Merge hot-reloadable overrides into the active config and re-apply policies. */
 export function updateRuntimeConfig(overrides: RuntimeOverrides): void {
+  validateRuntimeOverrides(overrides);
   const base = _activeConfig ?? configFromEnv();
   const merged: TelemetryConfig = { ...base };
   for (const [key, value] of Object.entries(overrides)) {
@@ -73,6 +76,53 @@ export function updateRuntimeConfig(overrides: RuntimeOverrides): void {
   setupTelemetry(_activeConfig);
 }
 
+function validateRate(name: string, value: number | undefined): void {
+  if (value === undefined) return;
+  if (!Number.isFinite(value) || value < 0 || value > 1) {
+    // Stryker disable next-line StringLiteral: error message content
+    throw new ConfigurationError(`${name} must be in [0, 1], got ${String(value)}`);
+  }
+}
+
+function validateNonNegativeInteger(name: string, value: number | undefined): void {
+  if (value === undefined) return;
+  if (!Number.isInteger(value) || value < 0) {
+    // Stryker disable next-line StringLiteral: error message content
+    throw new ConfigurationError(`${name} must be a non-negative integer, got ${String(value)}`);
+  }
+}
+
+function validateNonNegativeNumber(name: string, value: number | undefined): void {
+  if (value === undefined) return;
+  if (!Number.isFinite(value) || value < 0) {
+    // Stryker disable next-line StringLiteral: error message content
+    throw new ConfigurationError(`${name} must be >= 0, got ${String(value)}`);
+  }
+}
+
+/* Stryker disable StringLiteral: field names in validation calls are only used in error messages — mutating them does not change validation behavior */
+function validateRuntimeOverrides(overrides: RuntimeOverrides): void {
+  validateRate('samplingLogsRate', overrides.samplingLogsRate);
+  validateRate('samplingTracesRate', overrides.samplingTracesRate);
+  validateRate('samplingMetricsRate', overrides.samplingMetricsRate);
+  validateNonNegativeInteger('backpressureLogsMaxsize', overrides.backpressureLogsMaxsize);
+  validateNonNegativeInteger('backpressureTracesMaxsize', overrides.backpressureTracesMaxsize);
+  validateNonNegativeInteger('backpressureMetricsMaxsize', overrides.backpressureMetricsMaxsize);
+  validateNonNegativeInteger('exporterLogsRetries', overrides.exporterLogsRetries);
+  validateNonNegativeInteger('exporterTracesRetries', overrides.exporterTracesRetries);
+  validateNonNegativeInteger('exporterMetricsRetries', overrides.exporterMetricsRetries);
+  validateNonNegativeNumber('exporterLogsBackoffMs', overrides.exporterLogsBackoffMs);
+  validateNonNegativeNumber('exporterTracesBackoffMs', overrides.exporterTracesBackoffMs);
+  validateNonNegativeNumber('exporterMetricsBackoffMs', overrides.exporterMetricsBackoffMs);
+  validateNonNegativeNumber('exporterLogsTimeoutMs', overrides.exporterLogsTimeoutMs);
+  validateNonNegativeNumber('exporterTracesTimeoutMs', overrides.exporterTracesTimeoutMs);
+  validateNonNegativeNumber('exporterMetricsTimeoutMs', overrides.exporterMetricsTimeoutMs);
+  validateNonNegativeInteger('securityMaxAttrValueLength', overrides.securityMaxAttrValueLength);
+  validateNonNegativeInteger('securityMaxAttrCount', overrides.securityMaxAttrCount);
+  validateNonNegativeInteger('piiMaxDepth', overrides.piiMaxDepth);
+}
+/* Stryker restore StringLiteral */
+
 const _COLD_FIELDS: (keyof TelemetryConfig)[] = [
   'serviceName',
   'environment',
@@ -91,11 +141,13 @@ export function reloadRuntimeFromEnv(): void {
       (k) => JSON.stringify(current[k]) !== JSON.stringify(fresh[k]),
     );
     if (drifted.length > 0) {
+      /* Stryker disable StringLiteral: warning message content */
       console.warn(
         '[provide-telemetry] runtime.cold_field_drift:',
         drifted.join(', '),
         '— restart required to apply',
       );
+      /* Stryker restore StringLiteral */
     }
   }
   // Apply only hot fields via overrides
@@ -123,6 +175,7 @@ export function reloadRuntimeFromEnv(): void {
     sloEnableRedMetrics: fresh.sloEnableRedMetrics,
     sloEnableUseMetrics: fresh.sloEnableUseMetrics,
     piiMaxDepth: fresh.piiMaxDepth,
+    strictSchema: fresh.strictSchema,
   };
   updateRuntimeConfig(overrides);
 }
@@ -135,8 +188,8 @@ const PROVIDER_CHANGING_FIELDS: (keyof TelemetryConfig)[] = [
 
 /**
  * Apply config changes.
- * If provider-changing fields differ and providers are already registered, performs a
- * best-effort shutdown (fire-and-forget) then re-initialises — matching Go/Python behaviour.
+ * If provider-changing fields differ and providers are already registered, fail fast:
+ * provider replacement requires explicit process restart to avoid async export loss.
  * Otherwise delegates to setupTelemetry.
  */
 export function reconfigureTelemetry(config: Partial<TelemetryConfig>): void {
@@ -148,15 +201,9 @@ export function reconfigureTelemetry(config: Partial<TelemetryConfig>): void {
       (k) => JSON.stringify(current[k]) !== JSON.stringify(proposed[k]),
     );
     if (changed) {
-      // Best-effort async shutdown — fire-and-forget, errors ignored (mirrors Go's `_ = ShutdownTelemetry(ctx)`)
-      const providers = _getRegisteredProviders();
-      // Stryker disable LogicalOperator: ?? vs && is equivalent here — forceFlush/shutdown return Promise (truthy) so && still resolves; when undefined, Promise.allSettled wraps both in Promise.resolve
-      void Promise.allSettled(providers.map((p) => p.forceFlush?.() ?? Promise.resolve())).then(
-        () => Promise.allSettled(providers.map((p) => p.shutdown?.() ?? Promise.resolve())),
+      throw new ConfigurationError(
+        'provider-changing reconfiguration is unsupported after OpenTelemetry providers are installed; restart the process and call setupTelemetry() with the new config',
       );
-      // Stryker restore LogicalOperator
-      _providersRegistered = false;
-      _registeredProviders = [];
     }
   }
 

package/src/sampling.ts

@@ -6,6 +6,7 @@
  */
 
 import { ConfigurationError } from './exceptions';
+import { _droppedField, _emittedField, _incrementHealth } from './health';
 
 export interface SamplingPolicy {
   defaultRate: number;
@@ -55,12 +56,20 @@ export function shouldSample(signal: string, key?: string): boolean {
   const lookupKey = key ?? signal;
   const rate = overrides && lookupKey in overrides ? overrides[lookupKey] : _policy.defaultRate;
   const clamped = _clamp(rate);
-  // Stryker disable next-line ConditionalExpression,EqualityOperator: equivalent mutant — Math.random() in [0,1) so boundary is not observable
-  if (clamped <= 0) return false;
-  // Stryker disable next-line ConditionalExpression,EqualityOperator: equivalent mutant — Math.random() in [0,1) so boundary is not observable
-  if (clamped >= 1) return true;
+  /* Stryker disable ConditionalExpression,EqualityOperator,BlockStatement: boundary not observable (Math.random [0,1)); health counter updates tested but perTest coverage misattributes */
+  if (clamped <= 0) {
+    _incrementHealth(_droppedField(signal));
+    return false;
+  }
+  if (clamped >= 1) {
+    _incrementHealth(_emittedField(signal));
+    return true;
+  }
+  /* Stryker restore ConditionalExpression,EqualityOperator,BlockStatement */
   // Stryker disable next-line EqualityOperator: Math.random() is in [0,1) so < 1.0 and <= 1.0 are equivalent (random never equals 1.0)
-  return Math.random() < clamped;
+  const sampled = Math.random() < clamped;
+  _incrementHealth(sampled ? _emittedField(signal) : _droppedField(signal));
+  return sampled;
 }
 
 export function _resetSamplingForTests(): void {

package/src/tracing.ts

@@ -88,6 +88,7 @@ const NOOP_TRACE_ID = '00000000000000000000000000000000';
  * Used to decide whether to inject synthetic random IDs.
  */
 function _isNoopSpan(span: Span): boolean {
+  // Stryker disable next-line ConditionalExpression: without a registered OTel SDK all spans are noop — mutating to true is equivalent
   return span.spanContext().traceId === NOOP_TRACE_ID;
 }