@reactionary/source 0.0.48 → 0.0.52

package/otel/project.json

@@ -1,33 +0,0 @@
-{
-  "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

@@ -1,22 +0,0 @@
-// OpenTelemetry instrumentation library
-// This library provides instrumentation only - the host application
-// is responsible for initializing the OpenTelemetry SDK
-
-// Framework integration exports (internal use only)
-export { createTRPCTracing } from './trpc-middleware';
-export { createProviderInstrumentation } from './provider-instrumentation';
-
-// Decorator for tracing functions
-export { traced } from './trace-decorator';
-export type { TracedOptions } from './trace-decorator';
-
-// Utility functions for manual instrumentation
-export { 
-  getTracer, 
-  startSpan, 
-  withSpan, 
-  setSpanAttributes, 
-  createChildSpan,
-  SpanKind,
-  SpanStatusCode
-} from './tracer';

package/otel/src/metrics.ts

@@ -1,76 +0,0 @@
-import type { Meter, Counter, Histogram, UpDownCounter } from '@opentelemetry/api';
-import { metrics } from '@opentelemetry/api';
-
-const METER_NAME = '@reactionary/otel';
-const METER_VERSION = '0.0.1';
-
-let globalMeter: Meter | null = null;
-
-export function getMeter(): Meter {
-  if (!globalMeter) {
-    // Simply get the meter from the API
-    // If the SDK is not initialized by the host application,
-    // this will return a NoopMeter
-    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

@@ -1,108 +0,0 @@
-import type { Span} from '@opentelemetry/api';
-import { 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/test/otel.spec.ts

@@ -1,8 +0,0 @@
-import { getTracer } from '../tracer';
-describe('Otel Integration', () => {
-    it('should initialize OpenTelemetry without errors', async () => {
-      const tracer =  getTracer();
-
-      expect(tracer).toBeDefined();
-    });
-});

package/otel/src/trace-decorator.ts

@@ -1,226 +0,0 @@
-import { SpanKind, SpanStatusCode } from '@opentelemetry/api';
-import { getTracer } from './tracer';
-
-/**
- * Options for the @traced decorator
- */
-export interface TracedOptions {
-  /** Whether to capture function arguments as span attributes (default: true) */
-  captureArgs?: boolean;
-  /** Whether to capture the return value as a span attribute (default: true) */
-  captureResult?: boolean;
-  /** Custom span name to use instead of the function name */
-  spanName?: string;
-  /** OpenTelemetry SpanKind (default: INTERNAL) */
-  spanKind?: SpanKind;
-}
-
-/**
- * Safely serializes a value for use as a span attribute
- * Handles circular references and large objects
- */
-function safeSerialize(value: unknown, maxDepth = 3, currentDepth = 0): string {
-  if (currentDepth >= maxDepth) {
-    return '[Max depth reached]';
-  }
-
-  if (value === null) return 'null';
-  if (value === undefined) return 'undefined';
-
-  const type = typeof value;
-
-  if (type === 'string' || type === 'number' || type === 'boolean') {
-    return String(value);
-  }
-
-  if (type === 'function') {
-    return `[Function: ${(value as { name?: string }).name || 'anonymous'}]`;
-  }
-
-  if (value instanceof Date) {
-    return value.toISOString();
-  }
-
-  if (value instanceof Error) {
-    return `[Error: ${value.message}]`;
-  }
-
-  if (Array.isArray(value)) {
-    if (value.length > 10) {
-      return `[Array(${value.length})]`;
-    }
-    try {
-      return JSON.stringify(value.map(item =>
-        safeSerialize(item, maxDepth, currentDepth + 1)
-      ));
-    } catch {
-      return '[Array - circular reference]';
-    }
-  }
-
-  if (type === 'object') {
-    try {
-      const keys = Object.keys(value as object);
-      if (keys.length > 20) {
-        return `[Object with ${keys.length} keys]`;
-      }
-      const simplified: Record<string, unknown> = {};
-      for (const key of keys.slice(0, 10)) {
-        simplified[key] = safeSerialize(
-          (value as Record<string, unknown>)[key],
-          maxDepth,
-          currentDepth + 1
-        );
-      }
-      return JSON.stringify(simplified);
-    } catch {
-      return '[Object - circular reference]';
-    }
-  }
-
-  return String(value);
-}
-
-/**
- * TypeScript decorator for tracing function execution
- * Automatically creates OpenTelemetry spans for decorated methods
- * Uses Stage 2 (legacy) decorator syntax
- * 
- * @example
- * ```typescript
- * class MyService {
- *   @traced()
- *   async fetchData(id: string): Promise<Data> {
- *     // method implementation
- *   }
- *
- *   @traced({ spanName: 'custom-operation', captureResult: false })
- *   processData(data: Data): void {
- *     // method implementation
- *   }
- * }
- * ```
- */
-export function traced(options: TracedOptions = {}): MethodDecorator {
-  const {
-    captureArgs = false,
-    captureResult = false,
-    spanName,
-    spanKind = SpanKind.INTERNAL
-  } = options;
-
-  return function (
-    target: any,
-    propertyKey: string | symbol,
-    descriptor: PropertyDescriptor
-  ): PropertyDescriptor {
-    const originalMethod = descriptor.value;
-    const methodName = String(propertyKey);
-    
-    descriptor.value = createTracedMethod(originalMethod, methodName, {
-      captureArgs,
-      captureResult,
-      spanName,
-      spanKind
-    });
-    
-    return descriptor;
-  };
-}
-
-function createTracedMethod(
-  originalMethod: (...args: any[]) => any,
-  methodName: string,
-  options: {
-    captureArgs: boolean;
-    captureResult: boolean;
-    spanName?: string;
-    spanKind: SpanKind;
-  }
-): any {
-  const { captureArgs, captureResult, spanName, spanKind } = options;
-  
-  function tracedMethod(this: any, ...args: any[]): any {
-    const tracer = getTracer();
-    const className = this?.constructor?.name || 'Unknown';
-    const effectiveSpanName = spanName || `${className}.${methodName}`;
-
-    // Use startActiveSpan to ensure proper context propagation
-    return tracer.startActiveSpan(effectiveSpanName, {
-      kind: spanKind,
-      attributes: {
-        'function.name': methodName,
-        'function.class': className,
-      }
-    }, (span) => {
-      // Capture arguments if enabled
-      if (captureArgs && args.length > 0) {
-        args.forEach((arg, index) => {
-          try {
-            span.setAttribute(`function.args.${index}`, safeSerialize(arg));
-          } catch {
-            span.setAttribute(`function.args.${index}`, '[Serialization error]');
-          }
-        });
-        span.setAttribute('function.args.count', args.length);
-      }
-
-      // Helper function to set span attributes and status
-      const setSpanResult = (result: unknown, isError = false) => {
-        if (!isError && captureResult && result !== undefined) {
-          try {
-            span.setAttribute('function.result', safeSerialize(result));
-          } catch {
-            span.setAttribute('function.result', '[Serialization error]');
-          }
-        }
-        
-        if (isError) {
-          span.setStatus({
-            code: SpanStatusCode.ERROR,
-            message: result instanceof Error ? result.message : String(result)
-          });
-          if (result instanceof Error) {
-            span.recordException(result);
-          }
-        } else {
-          span.setStatus({ code: SpanStatusCode.OK });
-        }
-        
-        span.end();
-      };
-
-      try {
-        const result = originalMethod.apply(this, args);
-        
-        // Handle async functions - await them to keep span open
-        if (result instanceof Promise) {
-          try {
-            return result.then(value => {
-              setSpanResult(value);
-              return value;
-            });
-          } catch (error) {
-            setSpanResult(error, true);
-            throw error;
-          }
-        }
-        
-        // Handle sync functions
-        setSpanResult(result);
-        return result;
-      } catch (error) {
-        setSpanResult(error, true);
-        throw error;
-      }
-    });
-  }
-
-  // Preserve the original function's name and properties
-  Object.defineProperty(tracedMethod, 'name', {
-    value: methodName,
-    configurable: true
-  });
-
-  return tracedMethod;
-}

package/otel/src/tracer.ts

@@ -1,83 +0,0 @@
-import type { 
-  Tracer, 
-  Span,
-  Context,
-  SpanOptions,
-  Attributes} from '@opentelemetry/api';
-import { 
-  trace, 
-  SpanStatusCode,
-  context as otelContext
-} from '@opentelemetry/api';
-
-const TRACER_NAME = '@reactionary/otel';
-const TRACER_VERSION = '0.0.1';
-
-let globalTracer: Tracer | null = null;
-
-export function getTracer(): Tracer {
-  if (!globalTracer) {
-    // Simply get the tracer from the API
-    // If the SDK is not initialized by the host application,
-    // this will return a ProxyTracer that produces NonRecordingSpans
-    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

@@ -1,128 +0,0 @@
-import { TRPCError } from '@trpc/server';
-import type { 
-  Span} from '@opentelemetry/api';
-import {
-  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) + '...';
-}