@reactionary/source 0.0.28 → 0.0.30

package/otel/project.json

@@ -0,0 +1,33 @@
+{
+  "name": "otel",
+  "$schema": "../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "otel/src",
+  "projectType": "library",
+  "release": {
+    "version": {
+      "manifestRootsToUpdate": ["dist/{projectRoot}"],
+      "currentVersionResolver": "git-tag",
+      "fallbackCurrentVersionResolver": "disk"
+    }
+  },
+  "tags": [],
+  "targets": {
+    "build": {
+      "executor": "@nx/esbuild:esbuild",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "outputPath": "dist/otel",
+        "main": "otel/src/index.ts",
+        "tsConfig": "otel/tsconfig.lib.json",
+        "assets": ["otel/*.md"],
+        "format": ["cjs"],
+        "generatePackageJson": true
+      }
+    },
+    "nx-release-publish": {
+      "options": {
+        "packageRoot": "dist/{projectRoot}"
+      }
+    }
+  }
+}

package/otel/src/index.ts

@@ -0,0 +1,9 @@
+// OpenTelemetry auto-initialization based on standard environment variables
+// See: https://opentelemetry.io/docs/specs/otel/configuration/sdk-environment-variables/
+
+// Framework integration exports (internal use only)
+export { createTRPCTracing } from './trpc-middleware';
+export { createProviderInstrumentation } from './provider-instrumentation';
+
+// Graceful shutdown for process termination
+export { shutdownOtel } from './sdk';

package/otel/src/metrics.ts

@@ -0,0 +1,75 @@
+import { metrics, Meter, Counter, Histogram, UpDownCounter } from '@opentelemetry/api';
+import { isOtelInitialized } from './sdk';
+
+const METER_NAME = '@reactionary/otel';
+const METER_VERSION = '0.0.1';
+
+let globalMeter: Meter | null = null;
+
+export function getMeter(): Meter {
+  if (!globalMeter) {
+    // Ensure OTEL is initialized before creating meter
+    isOtelInitialized();
+    globalMeter = metrics.getMeter(METER_NAME, METER_VERSION);
+  }
+  return globalMeter;
+}
+
+export interface ReactMetrics {
+  requestCounter: Counter;
+  requestDuration: Histogram;
+  activeRequests: UpDownCounter;
+  errorCounter: Counter;
+  providerCallCounter: Counter;
+  providerCallDuration: Histogram;
+  cacheHitCounter: Counter;
+  cacheMissCounter: Counter;
+}
+
+let metricsInstance: ReactMetrics | null = null;
+
+export function initializeMetrics(): ReactMetrics {
+  if (metricsInstance) {
+    return metricsInstance;
+  }
+
+  const meter = getMeter();
+
+  metricsInstance = {
+    requestCounter: meter.createCounter('reactionary.requests', {
+      description: 'Total number of requests',
+    }),
+    requestDuration: meter.createHistogram('reactionary.request.duration', {
+      description: 'Request duration in milliseconds',
+      unit: 'ms',
+    }),
+    activeRequests: meter.createUpDownCounter('reactionary.requests.active', {
+      description: 'Number of active requests',
+    }),
+    errorCounter: meter.createCounter('reactionary.errors', {
+      description: 'Total number of errors',
+    }),
+    providerCallCounter: meter.createCounter('reactionary.provider.calls', {
+      description: 'Total number of provider calls',
+    }),
+    providerCallDuration: meter.createHistogram('reactionary.provider.duration', {
+      description: 'Provider call duration in milliseconds',
+      unit: 'ms',
+    }),
+    cacheHitCounter: meter.createCounter('reactionary.cache.hits', {
+      description: 'Total number of cache hits',
+    }),
+    cacheMissCounter: meter.createCounter('reactionary.cache.misses', {
+      description: 'Total number of cache misses',
+    }),
+  };
+
+  return metricsInstance;
+}
+
+export function getMetrics(): ReactMetrics {
+  if (!metricsInstance) {
+    return initializeMetrics();
+  }
+  return metricsInstance;
+}

package/otel/src/provider-instrumentation.ts

@@ -0,0 +1,107 @@
+import { Span, SpanKind } from '@opentelemetry/api';
+import { withSpan, setSpanAttributes } from './tracer';
+import { getMetrics } from './metrics';
+
+export interface ProviderSpanOptions {
+  providerName: string;
+  operationType: 'query' | 'mutation';
+  operationName?: string;
+  attributes?: Record<string, unknown>;
+}
+
+export async function withProviderSpan<T>(
+  options: ProviderSpanOptions,
+  fn: (span: Span) => Promise<T>
+): Promise<T> {
+  const { providerName, operationType, operationName, attributes = {} } = options;
+  const metrics = getMetrics();
+  const spanName = `provider.${providerName}.${operationType}${operationName ? `.${operationName}` : ''}`;
+  
+  const startTime = Date.now();
+  metrics.providerCallCounter.add(1, {
+    'provider.name': providerName,
+    'provider.operation.type': operationType,
+    'provider.operation.name': operationName || 'unknown',
+  });
+
+  return withSpan(
+    spanName,
+    async (span) => {
+      setSpanAttributes(span, {
+        'provider.name': providerName,
+        'provider.operation.type': operationType,
+        'provider.operation.name': operationName,
+        ...attributes,
+      });
+
+      // Span kind is set via options in withSpan
+
+      try {
+        const result = await fn(span);
+        
+        const duration = Date.now() - startTime;
+        metrics.providerCallDuration.record(duration, {
+          'provider.name': providerName,
+          'provider.operation.type': operationType,
+          'provider.operation.name': operationName || 'unknown',
+          'status': 'success',
+        });
+
+        return result;
+      } catch (error) {
+        const duration = Date.now() - startTime;
+        metrics.providerCallDuration.record(duration, {
+          'provider.name': providerName,
+          'provider.operation.type': operationType,
+          'provider.operation.name': operationName || 'unknown',
+          'status': 'error',
+        });
+
+        metrics.errorCounter.add(1, {
+          'provider.name': providerName,
+          'provider.operation.type': operationType,
+          'provider.operation.name': operationName || 'unknown',
+        });
+
+        throw error;
+      }
+    },
+    { kind: SpanKind.CLIENT }
+  );
+}
+
+export function createProviderInstrumentation(providerName: string) {
+  return {
+    traceQuery: <T>(
+      operationName: string,
+      fn: (span: Span) => Promise<T>,
+      attributes?: Record<string, unknown>
+    ) => {
+      return withProviderSpan(
+        {
+          providerName,
+          operationType: 'query',
+          operationName,
+          attributes,
+        },
+        fn
+      );
+    },
+    
+    traceMutation: <T>(
+      operationName: string,
+      fn: (span: Span) => Promise<T>,
+      attributes?: Record<string, unknown>
+    ) => {
+      return withProviderSpan(
+        {
+          providerName,
+          operationType: 'mutation',
+          operationName,
+          attributes,
+        },
+        fn
+      );
+    },
+  };
+}

package/otel/src/sdk.ts

@@ -0,0 +1,57 @@
+import { NodeSDK } from '@opentelemetry/sdk-node';
+
+let sdk: NodeSDK | null = null;
+let isInitialized = false;
+let initializationPromise: Promise<void> | null = null;
+
+// Detect if we're running in a browser environment
+function isBrowser(): boolean {
+  return typeof window !== 'undefined' && typeof process === 'undefined';
+}
+
+// Auto-initialize OTEL on first use with standard env vars
+function ensureInitialized(): void {
+  if (isInitialized || initializationPromise) {
+    return;
+  }
+
+  // Skip initialization in browser environments
+  if (isBrowser()) {
+    isInitialized = true;
+    return;
+  }
+
+  // Prevent multiple initialization attempts
+  initializationPromise = Promise.resolve().then(() => {
+    // Let NodeSDK handle everything automatically via env vars
+    // The SDK will automatically pick up OTEL_* environment variables
+    sdk = new NodeSDK();
+
+    sdk.start();
+    isInitialized = true;
+
+    process.on('SIGTERM', async () => {
+      try {
+        await shutdownOtel();
+        if (process.env['OTEL_LOG_LEVEL'] === 'debug') {
+          console.log('OpenTelemetry terminated successfully');
+        }
+      } catch (error) {
+        console.error('Error terminating OpenTelemetry', error);
+      }
+    });
+  });
+}
+
+export async function shutdownOtel(): Promise<void> {
+  if (sdk) {
+    await sdk.shutdown();
+    sdk = null;
+    isInitialized = false;
+  }
+}
+
+export function isOtelInitialized(): boolean {
+  ensureInitialized();
+  return isInitialized;
+}

package/otel/src/tracer.ts

@@ -0,0 +1,82 @@
+import { 
+  trace, 
+  Tracer, 
+  Span, 
+  SpanStatusCode,
+  context as otelContext,
+  Context,
+  SpanOptions,
+  Attributes,
+} from '@opentelemetry/api';
+import { isOtelInitialized } from './sdk';
+
+const TRACER_NAME = '@reactionary/otel';
+const TRACER_VERSION = '0.0.1';
+
+let globalTracer: Tracer | null = null;
+
+export function getTracer(): Tracer {
+  if (!globalTracer) {
+    // Ensure OTEL is initialized before creating tracer
+    isOtelInitialized();
+    globalTracer = trace.getTracer(TRACER_NAME, TRACER_VERSION);
+  }
+  return globalTracer;
+}
+
+export function startSpan(
+  name: string,
+  options?: SpanOptions,
+  context?: Context
+): Span {
+  const tracer = getTracer();
+  if (context) {
+    return tracer.startActiveSpan(name, options || {}, context, (span) => span);
+  }
+  return tracer.startSpan(name, options);
+}
+
+export function withSpan<T>(
+  name: string,
+  fn: (span: Span) => T | Promise<T>,
+  options?: SpanOptions
+): Promise<T> {
+  const tracer = getTracer();
+  return tracer.startActiveSpan(name, options || {}, async (span) => {
+    try {
+      const result = await fn(span);
+      span.setStatus({ code: SpanStatusCode.OK });
+      return result;
+    } catch (error) {
+      span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: error instanceof Error ? error.message : String(error),
+      });
+      if (error instanceof Error) {
+        span.recordException(error);
+      }
+      throw error;
+    } finally {
+      span.end();
+    }
+  });
+}
+
+export function setSpanAttributes(span: Span, attributes: Attributes): void {
+  Object.entries(attributes).forEach(([key, value]) => {
+    if (value !== undefined && value !== null) {
+      span.setAttribute(key, value);
+    }
+  });
+}
+
+export function createChildSpan(
+  parentSpan: Span,
+  name: string,
+  options?: SpanOptions
+): Span {
+  const ctx = trace.setSpan(otelContext.active(), parentSpan);
+  return getTracer().startSpan(name, options, ctx);
+}
+
+export { SpanKind, SpanStatusCode } from '@opentelemetry/api';

package/otel/src/trpc-middleware.ts

@@ -0,0 +1,127 @@
+import { TRPCError } from '@trpc/server';
+import { 
+  Span,
+  SpanKind,
+  SpanStatusCode,
+} from '@opentelemetry/api';
+import { getTracer } from './tracer';
+import { getMetrics } from './metrics';
+
+export interface TRPCMiddlewareOptions {
+  /** Whether to include input data in span attributes */
+  includeInput?: boolean;
+  /** Whether to include output data in span attributes */
+  includeOutput?: boolean;
+  /** Maximum string length for attributes */
+  maxAttributeLength?: number;
+}
+
+const defaultOptions: TRPCMiddlewareOptions = {
+  includeInput: true,
+  includeOutput: false,
+  maxAttributeLength: 1000,
+};
+
+export function createTRPCTracing(options: TRPCMiddlewareOptions = {}) {
+  const opts = { ...defaultOptions, ...options };
+  const metrics = getMetrics();
+
+  return ({ path, type, next, input, rawInput }: any) => {
+    const pathStr = path || 'unknown';
+    const tracer = getTracer();
+    const spanName = `trpc.${type}.${pathStr}`;
+    
+    const startTime = Date.now();
+    metrics.requestCounter.add(1, {
+      'rpc.method': pathStr,
+      'rpc.system': 'trpc',
+      'rpc.service': type,
+    });
+    metrics.activeRequests.add(1);
+
+    return tracer.startActiveSpan(
+      spanName,
+      {
+        kind: type === 'mutation' ? SpanKind.CLIENT : SpanKind.SERVER,
+        attributes: {
+          'rpc.system': 'trpc',
+          'rpc.method': pathStr,
+          'rpc.service': type,
+          'trpc.type': type,
+          'trpc.path': pathStr,
+        },
+      },
+      async (span: Span) => {
+        try {
+          if (opts.includeInput && (rawInput !== undefined || input !== undefined)) {
+            const inputData = rawInput || input;
+            const inputStr = truncateString(JSON.stringify(inputData), opts.maxAttributeLength || 1000);
+            span.setAttribute('trpc.input', inputStr);
+          }
+
+          const result = await next();
+
+          if (opts.includeOutput && result !== undefined) {
+            const outputStr = truncateString(JSON.stringify(result), opts.maxAttributeLength || 1000);
+            span.setAttribute('trpc.output', outputStr);
+          }
+
+          span.setStatus({ code: SpanStatusCode.OK });
+          
+          const duration = Date.now() - startTime;
+          metrics.requestDuration.record(duration, {
+            'rpc.method': pathStr,
+            'rpc.system': 'trpc',
+            'rpc.service': type,
+            'status': 'success',
+          });
+
+          return result;
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          const errorCode = error instanceof TRPCError ? error.code : 'INTERNAL_SERVER_ERROR';
+          
+          span.setStatus({
+            code: SpanStatusCode.ERROR,
+            message: errorMessage,
+          });
+          
+          span.setAttribute('trpc.error.code', errorCode);
+          span.setAttribute('trpc.error.message', errorMessage);
+          
+          if (error instanceof Error) {
+            span.recordException(error);
+          }
+
+          const duration = Date.now() - startTime;
+          metrics.requestDuration.record(duration, {
+            'rpc.method': pathStr,
+            'rpc.system': 'trpc',
+            'rpc.service': type,
+            'status': 'error',
+            'error.code': errorCode,
+          });
+          
+          metrics.errorCounter.add(1, {
+            'rpc.method': pathStr,
+            'rpc.system': 'trpc',
+            'rpc.service': type,
+            'error.code': errorCode,
+          });
+
+          throw error;
+        } finally {
+          span.end();
+          metrics.activeRequests.add(-1);
+        }
+      }
+    );
+  };
+};
+
+function truncateString(str: string, maxLength: number): string {
+  if (str.length <= maxLength) {
+    return str;
+  }
+  return str.substring(0, maxLength) + '...';
+}

package/otel/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "extends": "../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "importHelpers": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noPropertyAccessFromIndexSignature": true
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/otel/tsconfig.lib.json

@@ -0,0 +1,23 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../dist/out-tsc",
+    "declaration": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.js",
+    "src/**/*.spec.js",
+    "src/**/*.test.jsx",
+    "src/**/*.spec.jsx"
+  ]
+}

package/otel/tsconfig.spec.json

@@ -0,0 +1,28 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../dist/out-tsc",
+    "types": [
+      "vitest/globals",
+      "vitest/importMeta",
+      "vite/client",
+      "node",
+      "vitest"
+    ]
+  },
+  "include": [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.js",
+    "src/**/*.spec.js",
+    "src/**/*.test.jsx",
+    "src/**/*.spec.jsx",
+    "src/**/*.d.ts"
+  ]
+}

package/otel/vite.config.ts

@@ -0,0 +1,24 @@
+import { defineConfig } from 'vite';
+import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';
+import { nxCopyAssetsPlugin } from '@nx/vite/plugins/nx-copy-assets.plugin';
+
+export default defineConfig(() => ({
+  root: __dirname,
+  cacheDir: '../node_modules/.vite/otel',
+  plugins: [nxViteTsPaths(), nxCopyAssetsPlugin(['*.md'])],
+  // Uncomment this if you are using workers.
+  // worker: {
+  //  plugins: [ nxViteTsPaths() ],
+  // },
+  test: {
+    watch: false,
+    globals: true,
+    environment: 'node',
+    include: ['src/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+    reporters: ['default'],
+    coverage: {
+      reportsDirectory: '../coverage/otel',
+      provider: 'v8' as const,
+    },
+  },
+}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reactionary/source",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "license": "MIT",
   "private": false,
   "dependencies": {
@@ -14,6 +14,19 @@
     "@commercetools/platform-sdk": "^8.8.0",
     "@commercetools/ts-client": "^3.2.2",
     "@faker-js/faker": "^9.8.0",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/core": "^2.0.1",
+    "@opentelemetry/exporter-metrics-otlp-http": "^0.203.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.203.0",
+    "@opentelemetry/instrumentation": "^0.203.0",
+    "@opentelemetry/instrumentation-express": "^0.52.0",
+    "@opentelemetry/instrumentation-http": "^0.203.0",
+    "@opentelemetry/resources": "^2.0.1",
+    "@opentelemetry/sdk-metrics": "^2.0.1",
+    "@opentelemetry/sdk-node": "^0.203.0",
+    "@opentelemetry/sdk-trace-base": "^2.0.1",
+    "@opentelemetry/sdk-trace-node": "^2.0.1",
+    "@opentelemetry/semantic-conventions": "^1.36.0",
     "@trpc/client": "^11.1.2",
     "@trpc/server": "^11.1.2",
     "@upstash/redis": "^1.34.9",
@@ -71,6 +84,7 @@
     "@types/react-dom": "19.0.0",
     "@typescript-eslint/utils": "^8.19.0",
     "@vitejs/plugin-vue": "^5.2.3",
+    "@vitest/coverage-v8": "^3.0.5",
     "@vitest/ui": "^3.0.0",
     "@vue/eslint-config-prettier": "7.1.0",
     "@vue/eslint-config-typescript": "^11.0.3",

package/project.json

@@ -0,0 +1,14 @@
+{
+  "name": "@reactionary/source",
+  "$schema": "node_modules/nx/schemas/project-schema.json",
+  "targets": {
+    "local-registry": {
+      "executor": "@nx/js:verdaccio",
+      "options": {
+        "port": 4873,
+        "config": ".verdaccio/config.yml",
+        "storage": "tmp/local-registry/storage"
+      }
+    }
+  }
+}

package/trpc/package.json

@@ -7,6 +7,7 @@
   "dependencies": {
     "@trpc/server": "^11.1.2",
     "@reactionary/core": "0.0.1",
+    "@reactionary/otel": "0.0.1",
     "superjson": "^2.2.2",
     "zod": "4.0.0-beta.20250430T185432"
   }