npm - @reactionary/source - Versions diffs - 0.0.38 → 0.0.39 - Mend

@reactionary/source 0.0.38 → 0.0.39

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (32) hide show

package/core/package.json +1 -2
package/core/src/index.ts +0 -2
package/examples/next/.swcrc +30 -0
package/examples/next/eslint.config.mjs +21 -0
package/examples/next/index.d.ts +6 -0
package/examples/next/next-env.d.ts +5 -0
package/examples/next/next.config.js +20 -0
package/examples/next/project.json +9 -0
package/examples/next/public/.gitkeep +0 -0
package/examples/next/public/favicon.ico +0 -0
package/examples/next/src/app/global.css +0 -0
package/examples/next/src/app/layout.tsx +18 -0
package/examples/next/src/app/page.module.scss +2 -0
package/examples/next/src/app/page.tsx +51 -0
package/examples/next/src/instrumentation.ts +9 -0
package/examples/next/tsconfig.json +44 -0
package/examples/node/src/basic/basic-node-provider-model-extension.spec.ts +0 -1
package/examples/node/src/basic/basic-node-setup.spec.ts +0 -1
package/otel/README.md +152 -172
package/otel/package.json +0 -1
package/otel/src/index.ts +16 -6
package/otel/src/metrics.ts +3 -3
package/otel/src/trace-decorator.ts +76 -97
package/otel/src/tracer.ts +3 -3
package/package.json +1 -1
package/providers/fake/src/providers/cart.provider.ts +1 -1
package/providers/fake/src/providers/search.provider.ts +11 -2
package/trpc/package.json +1 -2
package/trpc/src/client.ts +1 -3
package/tsconfig.base.json +2 -0
package/core/src/decorators/trpc.decorators.ts +0 -144
package/otel/src/sdk.ts +0 -57

package/core/package.json CHANGED Viewed

@@ -5,7 +5,6 @@
   "types": "src/index.d.ts",
   "dependencies": {
     "zod": "4.0.0-beta.20250430T185432",
-    "@upstash/redis": "^1.34.9",
-    "reflect-metadata": "0.2.2"
+    "@upstash/redis": "^1.34.9"
   }
 }

package/core/src/index.ts CHANGED Viewed

@@ -6,8 +6,6 @@ export * from './cache/noop-cache';
 export * from './client/client';
 export * from './client/client-builder';
-export * from './decorators/trpc.decorators';
 export * from './providers/analytics.provider';
 export * from './providers/base.provider';
 export * from './providers/cart.provider';

package/examples/next/.swcrc ADDED Viewed

@@ -0,0 +1,30 @@
+{
+  "jsc": {
+    "target": "es2017",
+    "parser": {
+      "syntax": "typescript",
+      "decorators": true,
+      "dynamicImport": true
+    },
+    "transform": {
+      "decoratorMetadata": true,
+      "legacyDecorator": true
+    },
+    "keepClassNames": true,
+    "externalHelpers": true,
+    "loose": true
+  },
+  "module": {
+    "type": "commonjs"
+  },
+  "sourceMaps": true,
+  "exclude": [
+    "jest.config.ts",
+    ".*\\.spec.tsx?$",
+    ".*\\.test.tsx?$",
+    "./src/jest-setup.ts$",
+    "./**/jest-setup.ts$",
+    ".*.js$",
+    ".*.d.ts$"
+  ]
+}

package/examples/next/eslint.config.mjs ADDED Viewed

@@ -0,0 +1,21 @@
+import { FlatCompat } from '@eslint/eslintrc';
+import { dirname } from 'path';
+import { fileURLToPath } from 'url';
+import js from '@eslint/js';
+import { fixupConfigRules } from '@eslint/compat';
+import nx from '@nx/eslint-plugin';
+import baseConfig from '../../eslint.config.mjs';
+const compat = new FlatCompat({
+  baseDirectory: dirname(fileURLToPath(import.meta.url)),
+  recommendedConfig: js.configs.recommended,
+});
+export default [
+  ...fixupConfigRules(compat.extends('next')),
+  ...fixupConfigRules(compat.extends('next/core-web-vitals')),
+  ...baseConfig,
+  ...nx.configs['flat/react-typescript'],
+  {
+    ignores: ['.next/**/*'],
+  },
+];

package/examples/next/index.d.ts ADDED Viewed

@@ -0,0 +1,6 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+declare module '*.svg' {
+  const content: any;
+  export const ReactComponent: any;
+  export default content;
+}

package/examples/next/next-env.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/examples/next/next.config.js ADDED Viewed

@@ -0,0 +1,20 @@
+//@ts-check
+const { composePlugins, withNx } = require('@nx/next');
+/**
+ * @type {import('@nx/next/plugins/with-nx').WithNxOptions}
+ **/
+const nextConfig = {
+  // Use this to set Nx-specific options
+  // See: https://nx.dev/recipes/next/next-config-setup
+  nx: {},
+};
+const plugins = [
+  // Add more Next.js plugins to this list if needed.
+  withNx,
+];
+module.exports = composePlugins(...plugins)(nextConfig);

package/examples/next/project.json ADDED Viewed

@@ -0,0 +1,9 @@
+{
+  "name": "next",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "examples/next",
+  "projectType": "application",
+  "tags": [],
+  "// targets": "to see all targets run: nx show project next --web",
+  "targets": {}
+}

package/examples/next/public/.gitkeep ADDED Viewed

File without changes

package/examples/next/public/favicon.ico ADDED Viewed

Binary file

package/examples/next/src/app/global.css ADDED Viewed

File without changes

package/examples/next/src/app/layout.tsx ADDED Viewed

@@ -0,0 +1,18 @@
+import './global.css';
+export const metadata = {
+  title: 'Welcome to next',
+  description: 'Generated by create-nx-workspace',
+};
+export default function RootLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return (
+    <html lang="en">
+      <body>{children}</body>
+    </html>
+  );
+}

package/examples/next/src/app/page.module.scss ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ .page {
2	+ }

package/examples/next/src/app/page.tsx ADDED Viewed

@@ -0,0 +1,51 @@
+import styles from './page.module.scss';
+import { ClientBuilder, NoOpCache, SessionSchema } from '@reactionary/core';
+import { withFakeCapabilities } from '@reactionary/provider-fake';
+export default async function Index() {
+  const client = new ClientBuilder()
+    .withCapability(
+      withFakeCapabilities(
+        {
+          jitter: {
+            mean: 0,
+            deviation: 0,
+          },
+          seeds: {
+            product: 1,
+            search: 1,
+            category: 1,
+          },
+        },
+        { search: true, product: false, identity: false }
+      )
+    )
+    .withCache(new NoOpCache())
+    .build();
+  const session = SessionSchema.parse({
+    id: '1234567890',
+    languageContext: {
+      countryCode: 'US',
+      languageCode: 'en',
+      currencyCode: 'USD',
+    },
+  });
+  const search = await client.search?.queryByTerm({
+    search: {
+      facets: [],
+      page: 0,
+      pageSize: 12,
+      term: 'glass',
+    },
+  }, session);
+  return <div className={styles.page}>
+        {search?.products.map((product, index) => (
+          <div key={index}>
+            { product.name }
+          </div>
+        ))}
+  </div>;
+}

package/examples/next/src/instrumentation.ts ADDED Viewed

@@ -0,0 +1,9 @@
+export async function register() {
+  if (process.env.NEXT_RUNTIME === 'nodejs') {
+    const { NodeSDK } = await import('@opentelemetry/sdk-node');
+    const sdk = new NodeSDK();
+    sdk.start();
+  }
+}

package/examples/next/tsconfig.json ADDED Viewed

@@ -0,0 +1,44 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "jsx": "preserve",
+    "strict": true,
+    "noEmit": true,
+    "emitDeclarationOnly": false,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "allowJs": true,
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ]
+  },
+  "include": [
+    "**/*.js",
+    "**/*.jsx",
+    "**/*.ts",
+    "**/*.tsx",
+    "../../dist/examples/next/.next/types/**/*.ts",
+    "../../examples/next/.next/types/**/*.ts",
+    "next-env.d.ts",
+    ".next/types/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules",
+    "jest.config.ts",
+    "**/*.spec.ts",
+    "**/*.test.ts"
+  ]
+}

package/examples/node/src/basic/basic-node-provider-model-extension.spec.ts CHANGED Viewed

@@ -68,7 +68,6 @@ describe('basic node provider extension (models)', () => {
   it('should get the enabled set of capabilities across providers', async () => {
     expect(client.product).toBeDefined();
     expect(client.search).toBeDefined();
-    expect(client.identity).toBeUndefined();
   });
   it('should be able to call the regular methods and get the default value', async () => {

package/examples/node/src/basic/basic-node-setup.spec.ts CHANGED Viewed

@@ -26,7 +26,6 @@ describe('basic node setup', () => {
   it('should only get back the enabled capabilities', async () => {
     expect(client.product).toBeDefined();
     expect(client.search).toBeDefined();
-    expect(client.identity).toBeUndefined();
   });
   it('should be able to call the enabled capabilities', async () => {

package/otel/README.md CHANGED Viewed

@@ -1,16 +1,18 @@
 # @reactionary/otel
-Zero-configuration OpenTelemetry instrumentation for Reactionary framework. Automatically instruments tRPC routes and providers using standard OTEL environment variables.
+OpenTelemetry instrumentation for the Reactionary framework. Provides decorators and utilities for tracing function execution and performance monitoring.
+## Important: SDK Initialization Required
+This library provides **instrumentation only**. The host application is responsible for initializing the OpenTelemetry SDK. Without proper SDK initialization, traces will be created as `NonRecordingSpan` instances with zero trace/span IDs.
 ## Features
-- **Zero Configuration**: Auto-initializes on first use with standard OTEL env vars
-- **Automatic tRPC Route Tracing**: All tRPC procedures automatically traced
-- **Provider Instrumentation**: BaseProvider operations automatically instrumented
-- **Standard Compliance**: Uses official OpenTelemetry environment variables
-- **Multiple Exporters**: Console, OTLP/HTTP, or custom exporters
-- **Metrics Collection**: Request counts, durations, errors automatically tracked
-- **Lazy Initialization**: Only starts when actually used
+- **Tracing Decorators**: Automatic span creation for decorated methods
+- **Manual Instrumentation**: Utilities for custom tracing
+- **Framework Integration**: Built-in support for tRPC and providers
+- **Zero Dependencies**: Only requires OpenTelemetry API
+- **Graceful Degradation**: Works without SDK initialization (produces no-op spans)
 ## Installation
@@ -18,230 +20,208 @@ Zero-configuration OpenTelemetry instrumentation for Reactionary framework. Auto
 pnpm add @reactionary/otel
 ```
-That's it! No initialization code needed.
+**Important**: You must also install and configure the OpenTelemetry SDK in your host application.
-## How It Works
+## Usage
-The OTEL package automatically initializes itself on first use, reading configuration from standard OpenTelemetry environment variables. When your code first creates a span or metric, the SDK initializes with your environment configuration.
+### Basic Tracing with Decorators
 ```typescript
-// No imports or initialization needed!
-// Just use your tRPC router or providers normally
-import { createTRPCRouter } from '@reactionary/trpc';
-const router = createTRPCRouter(client);
-// ↑ Automatically instrumented when OTEL env vars are set
-```
-## Configuration
-Use standard OpenTelemetry environment variables. No code changes needed.
-### Standard Environment Variables
-```bash
-# Service identification
-OTEL_SERVICE_NAME=my-service
-OTEL_SERVICE_VERSION=1.0.0
-# Traces exporter (console | otlp | otlp/http | none)
-OTEL_TRACES_EXPORTER=otlp
-# Metrics exporter (console | otlp | otlp/http | none)
-OTEL_METRICS_EXPORTER=otlp
-# OTLP endpoint and headers
-OTEL_EXPORTER_OTLP_ENDPOINT=https://api.honeycomb.io
-OTEL_EXPORTER_OTLP_HEADERS=x-honeycomb-team=your-api-key
-# Or use specific endpoints
-OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=https://api.honeycomb.io/v1/traces
-OTEL_EXPORTER_OTLP_METRICS_ENDPOINT=https://api.honeycomb.io/v1/metrics
-# Debug logging
-OTEL_LOG_LEVEL=debug
-# Metrics export interval (milliseconds)
-OTEL_METRIC_EXPORT_INTERVAL=60000
-```
+import { traced } from '@reactionary/otel';
-See the [OpenTelemetry specification](https://opentelemetry.io/docs/specs/otel/configuration/sdk-environment-variables/) for all available options.
-## Exporters
-### Console (Development)
-```bash
-OTEL_TRACES_EXPORTER=console
-OTEL_METRICS_EXPORTER=console
-```
-### OTLP (Production)
-Works with any OTLP-compatible backend:
-```bash
-OTEL_TRACES_EXPORTER=otlp
-OTEL_METRICS_EXPORTER=otlp
-OTEL_EXPORTER_OTLP_ENDPOINT=https://api.honeycomb.io
-OTEL_EXPORTER_OTLP_HEADERS=x-honeycomb-team=your-api-key
-```
+class MyService {
+  @traced()
+  async fetchData(id: string): Promise<Data> {
+    // This method will be automatically traced
+    return await dataSource.get(id);
+  }
-### Disable
-```bash
-OTEL_TRACES_EXPORTER=none
-OTEL_METRICS_EXPORTER=none
+  @traced({
+    spanName: 'custom-operation',
+    captureResult: false
+  })
+  processData(data: Data): void {
+    // Custom span name and no result capture
+  }
+}
 ```
-## Custom Instrumentation
-### Manual Spans
-Create custom spans for specific operations:
+### Manual Instrumentation
 ```typescript
 import { withSpan, getTracer } from '@reactionary/otel';
 // Using withSpan helper
-const result = await withSpan('custom-operation', async (span) => {
-  span.setAttribute('custom.attribute', 'value');
-  // Your operation here
-  return someAsyncOperation();
+const result = await withSpan('my-operation', async (span) => {
+  span.setAttribute('operation.id', operationId);
+  return await performOperation();
 });
 // Using tracer directly
 const tracer = getTracer();
 const span = tracer.startSpan('manual-span');
 try {
-  // Your operation
+  // Your code here
   span.setStatus({ code: SpanStatusCode.OK });
 } catch (error) {
-  span.recordException(error);
   span.setStatus({ code: SpanStatusCode.ERROR });
-  throw error;
+  span.recordException(error);
 } finally {
   span.end();
 }
 ```
-### Provider Instrumentation
+## Setting Up OpenTelemetry SDK
-Providers are automatically instrumented when extending BaseProvider:
+### Next.js Applications
-```typescript
-import { BaseProvider } from '@reactionary/core';
+1. Create an `instrumentation.ts` file in your project root:
-class MyProvider extends BaseProvider {
-  // Automatically traced when OTEL is initialized
-  protected async fetch(queries, session) {
-    // Your implementation
-  }
-  protected async process(mutations, session) {
-    // Your implementation
+```typescript
+// instrumentation.ts
+export async function register() {
+  if (process.env.NEXT_RUNTIME === 'nodejs') {
+    const { NodeSDK } = await import('@opentelemetry/sdk-node');
+    const { getNodeAutoInstrumentations } = await import('@opentelemetry/auto-instrumentations-node');
+    const sdk = new NodeSDK({
+      instrumentations: [getNodeAutoInstrumentations()],
+    });
+    sdk.start();
   }
 }
 ```
-### Custom Metrics
+2. Enable instrumentation in `next.config.js`:
-Track custom business metrics:
+```javascript
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  experimental: {
+    instrumentationHook: true,
+  },
+};
-```typescript
-import { getMetrics } from '@reactionary/otel';
+module.exports = nextConfig;
+```
-const metrics = getMetrics();
+3. Configure environment variables:
-// Increment counter
-metrics.requestCounter.add(1, {
-  'endpoint': '/api/users',
-  'method': 'GET'
-});
+```bash
+# .env.local
+OTEL_SERVICE_NAME=my-nextjs-app
+OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318
+OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf
+```
+### Node.js Applications
-// Record histogram
-metrics.requestDuration.record(150, {
-  'endpoint': '/api/users',
-  'status': 'success'
+```typescript
+// Initialize at the very beginning of your application
+import { NodeSDK } from '@opentelemetry/sdk-node';
+import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
+const sdk = new NodeSDK({
+  instrumentations: [getNodeAutoInstrumentations()],
 });
+sdk.start();
+// Now import and use your application code
+import './app';
 ```
-## Examples
+### Environment Variables
-### Honeycomb
+The OpenTelemetry SDK can be configured using environment variables:
 ```bash
-OTEL_SERVICE_NAME=my-service
-OTEL_TRACES_EXPORTER=otlp
-OTEL_EXPORTER_OTLP_ENDPOINT=https://api.honeycomb.io
-OTEL_EXPORTER_OTLP_HEADERS=x-honeycomb-team=your-api-key
-```
+# Service identification
+OTEL_SERVICE_NAME=my-app
+OTEL_SERVICE_VERSION=1.0.0
-### Local Development
+# OTLP Exporter (for Jaeger, etc.)
+OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318
+OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf
-```bash
-OTEL_SERVICE_NAME=my-service-dev
+# Console exporter (for development)
 OTEL_TRACES_EXPORTER=console
-OTEL_METRICS_EXPORTER=none  # Disable metrics in dev
+# Sampling (optional)
+OTEL_TRACES_SAMPLER=always_on
+# Debug logging
+OTEL_LOG_LEVEL=debug
 ```
-### Docker Compose with Jaeger
-```yaml
-services:
-  app:
-    environment:
-      - OTEL_EXPORTER_TYPE=otlp
-      - OTEL_COLLECTOR_ENDPOINT=http://jaeger:4318
-      - OTEL_SERVICE_NAME=my-service
-  jaeger:
-    image: jaegertracing/all-in-one:latest
-    ports:
-      - "16686:16686"  # Jaeger UI
-      - "4318:4318"    # OTLP HTTP
+## Troubleshooting
+### ProxyTracer with NonRecordingSpan
+If you see logs like:
+```
+tracer: ProxyTracer { _provider: ProxyTracerProvider {} }
+ending span: NonRecordingSpan { _spanContext: { traceId: '00000000000000000000000000000000' } }
 ```
-## Metrics Reference
+This means the OpenTelemetry SDK has not been initialized. Ensure you have:
+1. Created an `instrumentation.ts` file (Next.js)
+2. Initialized the SDK at application startup (Node.js)
+3. Set the required environment variables
-The following metrics are automatically collected:
+### Missing Traces
-| Metric | Type | Description |
-|--------|------|-------------|
-| `reactionary.requests` | Counter | Total number of requests |
-| `reactionary.request.duration` | Histogram | Request duration in milliseconds |
-| `reactionary.requests.active` | UpDownCounter | Number of active requests |
-| `reactionary.errors` | Counter | Total number of errors |
-| `reactionary.provider.calls` | Counter | Total provider calls |
-| `reactionary.provider.duration` | Histogram | Provider call duration |
-| `reactionary.cache.hits` | Counter | Cache hit count |
-| `reactionary.cache.misses` | Counter | Cache miss count |
+If the decorator is being applied but you don't see traces:
+1. Verify the OTEL exporter is configured correctly
+2. Check that your tracing backend is running
+3. Ensure sampling is enabled (`OTEL_TRACES_SAMPLER=always_on`)
-## Best Practices
+## API Reference
-1. **Use Standard Variables**: Stick to OpenTelemetry standard environment variables
-2. **Set Service Name**: Always set `OTEL_SERVICE_NAME` for service identification
-3. **Environment-based Config**: Use different configs for dev/staging/production
-4. **Add Context**: Use span attributes to add business context to traces
-5. **Handle Errors**: Ensure spans are properly closed even on errors
-6. **Sample Wisely**: Consider sampling strategies for high-volume services
-7. **Monitor Performance**: Watch for overhead in high-throughput scenarios
+### Decorators
-## Troubleshooting
+#### `@traced(options?)`
-### Traces Not Appearing
+Decorates a method to automatically create spans for its execution.
-1. Check OTEL is initialized before other components
-2. Verify `OTEL_TRACE_ENABLED` is not set to `false`
-3. Check exporter configuration and endpoint connectivity
-4. Look for initialization errors in console
+**Options:**
+- `captureArgs?: boolean` - Capture function arguments (default: true)
+- `captureResult?: boolean` - Capture return value (default: true)
+- `spanName?: string` - Custom span name (default: ClassName.methodName)
+- `spanKind?: SpanKind` - OpenTelemetry span kind (default: INTERNAL)
-### Performance Impact
+### Utility Functions
+- `getTracer(): Tracer` - Get the library's tracer instance
+- `startSpan(name, options?, context?): Span` - Start a new span
+- `withSpan<T>(name, fn, options?): Promise<T>` - Execute function within a span
+- `setSpanAttributes(span, attributes): void` - Set multiple span attributes
+- `createChildSpan(parent, name, options?): Span` - Create child span
+### Constants
+- `SpanKind` - OpenTelemetry span kinds
+- `SpanStatusCode` - OpenTelemetry span status codes
+## Examples
-- Use sampling to reduce overhead
-- Disable metrics if not needed
-- Consider using batch exporters
-- Increase export intervals for metrics
+### Console Output (Development)
+```bash
+OTEL_SERVICE_NAME=my-service-dev
+OTEL_TRACES_EXPORTER=console
+```
-### Memory Usage
+### Jaeger (Local)
+```bash
+OTEL_SERVICE_NAME=my-service
+OTEL_EXPORTER_OTLP_ENDPOINT=http://localhost:4318
+OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf
+```
-- Monitor span processor queue size
-- Adjust batch size and timeout
-- Consider using sampling for high-volume services
+### Honeycomb (Production)
+```bash
+OTEL_SERVICE_NAME=my-service
+OTEL_EXPORTER_OTLP_ENDPOINT=https://api.honeycomb.io
+OTEL_EXPORTER_OTLP_HEADERS=x-honeycomb-team=your-api-key
+```

package/otel/package.json CHANGED Viewed

@@ -6,7 +6,6 @@
   "types": "./src/index.d.ts",
   "dependencies": {
     "@opentelemetry/api": "^1.9.0",
-    "@opentelemetry/sdk-node": "^0.203.0",
     "@trpc/server": "^11.1.2"
   }
 }

package/otel/src/index.ts CHANGED Viewed

@@ -1,12 +1,22 @@
-// OpenTelemetry auto-initialization based on standard environment variables
-// See: https://opentelemetry.io/docs/specs/otel/configuration/sdk-environment-variables/
+// 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, TracedOptions } from './trace-decorator';
-export { getTracer } from './tracer';
-// Graceful shutdown for process termination
-export { shutdownOtel } from './sdk';
+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 CHANGED Viewed

@@ -1,5 +1,4 @@
 import { metrics, Meter, Counter, Histogram, UpDownCounter } from '@opentelemetry/api';
-import { isOtelInitialized } from './sdk';
 const METER_NAME = '@reactionary/otel';
 const METER_VERSION = '0.0.1';
@@ -8,8 +7,9 @@ let globalMeter: Meter | null = null;
 export function getMeter(): Meter {
   if (!globalMeter) {
-    // Ensure OTEL is initialized before creating meter
-    isOtelInitialized();
+    // 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;

package/otel/src/trace-decorator.ts CHANGED Viewed

@@ -84,8 +84,8 @@ function safeSerialize(value: unknown, maxDepth = 3, currentDepth = 0): string {
 /**
  * TypeScript decorator for tracing function execution
  * Automatically creates OpenTelemetry spans for decorated methods
- * Supports both Stage 2 (legacy) and Stage 3 decorator syntax
- *
+ * Uses Stage 2 (legacy) decorator syntax
+ *
  * @example
  * ```typescript
  * class MyService {
@@ -101,7 +101,7 @@ function safeSerialize(value: unknown, maxDepth = 3, currentDepth = 0): string {
  * }
  * ```
  */
-export function traced(options: TracedOptions = {}): any {
+export function traced(options: TracedOptions = {}): MethodDecorator {
   const {
     captureArgs = false,
     captureResult = false,
@@ -109,42 +109,22 @@ export function traced(options: TracedOptions = {}): any {
     spanKind = SpanKind.INTERNAL
   } = options;
-  // Stage 2 (legacy) decorator
   return function (
     target: any,
-    propertyKey?: string | symbol,
-    descriptor?: PropertyDescriptor
-  ): any {
-    // Handle Stage 3 decorator (when called with context)
-    if (typeof propertyKey === 'object' && propertyKey && 'kind' in propertyKey) {
-      const context = propertyKey as any;
-      const originalMethod = target;
-      const methodName = String(context.name);
-      return createTracedMethod(originalMethod, methodName, {
-        captureArgs,
-        captureResult,
-        spanName,
-        spanKind
-      });
-    }
-    // Handle Stage 2 decorator
-    if (descriptor && typeof descriptor.value === 'function') {
-      const originalMethod = descriptor.value;
-      const methodName = String(propertyKey);
-      descriptor.value = createTracedMethod(originalMethod, methodName, {
-        captureArgs,
-        captureResult,
-        spanName,
-        spanKind
-      });
-      return descriptor;
-    }
-    return target;
+    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;
   };
 }
@@ -159,81 +139,80 @@ function createTracedMethod(
   }
 ): any {
   const { captureArgs, captureResult, spanName, spanKind } = options;
-  function tracedMethod(this: any, ...args: any[]): any {
+  async function tracedMethod(this: any, ...args: any[]): Promise<any> {
     const tracer = getTracer();
     const className = this?.constructor?.name || 'Unknown';
     const effectiveSpanName = spanName || `${className}.${methodName}`;
-    // Start the span
-    const span = tracer.startSpan(effectiveSpanName, {
+    // Use startActiveSpan to ensure proper context propagation
+    return tracer.startActiveSpan(effectiveSpanName, {
       kind: spanKind,
       attributes: {
         'function.name': methodName,
         'function.class': className,
       }
-    });
-    // 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 finalize span with result
-    const finalizeSpan = (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)
+    }, async (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]');
+          }
         });
-        if (result instanceof Error) {
-          span.recordException(result);
-        }
-      } else {
-        span.setStatus({ code: SpanStatusCode.OK });
+        span.setAttribute('function.args.count', args.length);
       }
-      span.end();
-    };
-    try {
-      const result = originalMethod.apply(this, args);
-      // Handle async functions
-      if (result instanceof Promise) {
-        return result
-          .then((value) => {
-            finalizeSpan(value);
+      // 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 {
+            const value = await result;
+            setSpanResult(value);
             return value;
-          })
-          .catch((error) => {
-            finalizeSpan(error, true);
+          } catch (error) {
+            setSpanResult(error, true);
             throw error;
-          });
+          }
+        }
+        // Handle sync functions
+        setSpanResult(result);
+        return result;
+      } catch (error) {
+        setSpanResult(error, true);
+        throw error;
       }
-      // Handle sync functions
-      finalizeSpan(result);
-      return result;
-    } catch (error) {
-      finalizeSpan(error, true);
-      throw error;
-    }
+    });
   }
   // Preserve the original function's name and properties

package/otel/src/tracer.ts CHANGED Viewed

@@ -8,7 +8,6 @@ import {
   SpanOptions,
   Attributes,
 } from '@opentelemetry/api';
-import { isOtelInitialized } from './sdk';
 const TRACER_NAME = '@reactionary/otel';
 const TRACER_VERSION = '0.0.1';
@@ -17,8 +16,9 @@ let globalTracer: Tracer | null = null;
 export function getTracer(): Tracer {
   if (!globalTracer) {
-    // Ensure OTEL is initialized before creating tracer
-    isOtelInitialized();
+    // 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;

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@reactionary/source",
-  "version": "0.0.38",
+  "version": "0.0.39",
   "license": "MIT",
   "private": false,
   "dependencies": {

package/providers/fake/src/providers/cart.provider.ts CHANGED Viewed

@@ -10,7 +10,7 @@ import {
 } from '@reactionary/core';
 import z from 'zod';
 import { FakeConfiguration } from '../schema/configuration.schema';
-import { Faker, en, base } from '@faker-js/faker/.';
+import { Faker, en, base } from '@faker-js/faker';
 export class FakeCartProvider<
   T extends Cart = Cart

package/providers/fake/src/providers/search.provider.ts CHANGED Viewed

@@ -1,16 +1,16 @@
 import {
   SearchProvider,
-  SearchQueryByTerm,
   SearchResult,
   SearchResultFacet,
   SearchResultProduct,
-  Session,
   Cache as ReactionaryCache,
 } from '@reactionary/core';
+import type { SearchQueryByTerm, Session } from '@reactionary/core';
 import z from 'zod';
 import { FakeConfiguration } from '../schema/configuration.schema';
 import { Faker, en, base } from '@faker-js/faker';
 import { jitter } from '../utilities/jitter';
+import { traced } from '@reactionary/otel';
 export class FakeSearchProvider<
   T extends SearchResult = SearchResult
@@ -23,6 +23,7 @@ export class FakeSearchProvider<
     this.config = config;
   }
+  @traced()
   public override async queryByTerm(
     payload: SearchQueryByTerm,
     _session: Session
@@ -119,6 +120,14 @@ export class FakeSearchProvider<
       },
     } satisfies SearchResult;
+    const foo = this.childFunction();
     return this.schema.parse(result);
   }
+  @traced()
+  protected childFunction() {
+    const foo = 42;
+    return foo;
+  }
 }

package/trpc/package.json CHANGED Viewed

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

package/trpc/src/client.ts CHANGED Viewed

@@ -1,7 +1,5 @@
-import { Client, Session, isTRPCQuery, isTRPCMutation, isTRPCMethod } from '@reactionary/core';
+import { Client, Session } from '@reactionary/core';
 import type { TransparentClient } from './types';
-import type { inferRouterInputs, inferRouterOutputs } from '@trpc/server';
-import type { TRPCClientError } from '@trpc/client';
 /**
  * Configuration options for TRPC client creation

package/tsconfig.base.json CHANGED Viewed

@@ -5,6 +5,8 @@
     "sourceMap": true,
     "declaration": false,
     "moduleResolution": "node",
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
     "importHelpers": true,
     "target": "es2015",
     "module": "esnext",

package/core/src/decorators/trpc.decorators.ts DELETED Viewed

@@ -1,144 +0,0 @@
-import 'reflect-metadata';
-/**
- * Metadata keys for TRPC method decorators
- */
-export const TRPC_QUERY_METADATA_KEY = Symbol('trpc:query');
-export const TRPC_MUTATION_METADATA_KEY = Symbol('trpc:mutation');
-/**
- * Options for TRPC method decorators
- */
-export interface TRPCMethodOptions {
-  /** Custom name for the TRPC procedure (defaults to method name) */
-  name?: string;
-  /** Description for documentation purposes */
-  description?: string;
-}
-/**
- * Decorator to mark a provider method as a TRPC query procedure
- * Query procedures are read-only operations (GET-like)
- *
- * @example
- * ```typescript
- * class ProductProvider extends BaseProvider {
- *   @trpcQuery()
- *   async getById(payload: ProductQueryById, session: Session): Promise<Product> {
- *     // implementation
- *   }
- *
- *   @trpcQuery({ name: 'findBySlug', description: 'Find product by URL slug' })
- *   async getBySlug(payload: ProductQueryBySlug, session: Session): Promise<Product> {
- *     // implementation
- *   }
- * }
- * ```
- */
-export function trpcQuery(options: TRPCMethodOptions = {}): MethodDecorator {
-  return function (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) {
-    // Store metadata about this method being a TRPC query
-    const metadata = {
-      methodName: String(propertyKey),
-      isQuery: true,
-      isMutation: false,
-      options
-    };
-    // Store on the prototype so it's inherited
-    Reflect.defineMetadata(TRPC_QUERY_METADATA_KEY, metadata, target, propertyKey);
-    // Also store a list of all TRPC methods on the class
-    const existingMethods = Reflect.getMetadata(TRPC_QUERY_METADATA_KEY, target.constructor) || [];
-    existingMethods.push({ propertyKey, metadata });
-    Reflect.defineMetadata(TRPC_QUERY_METADATA_KEY, existingMethods, target.constructor);
-  };
-}
-/**
- * Decorator to mark a provider method as a TRPC mutation procedure
- * Mutation procedures are write operations that modify state (POST/PUT/DELETE-like)
- *
- * @example
- * ```typescript
- * class CartProvider extends BaseProvider {
- *   @trpcMutation()
- *   async add(payload: CartAddMutation, session: Session): Promise<Cart> {
- *     // implementation
- *   }
- *
- *   @trpcMutation({ name: 'removeItem' })
- *   async remove(payload: CartRemoveMutation, session: Session): Promise<Cart> {
- *     // implementation
- *   }
- * }
- * ```
- */
-export function trpcMutation(options: TRPCMethodOptions = {}): MethodDecorator {
-  return function (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) {
-    // Store metadata about this method being a TRPC mutation
-    const metadata = {
-      methodName: String(propertyKey),
-      isQuery: false,
-      isMutation: true,
-      options
-    };
-    // Store on the prototype so it's inherited
-    Reflect.defineMetadata(TRPC_MUTATION_METADATA_KEY, metadata, target, propertyKey);
-    // Also store a list of all TRPC methods on the class
-    const existingMethods = Reflect.getMetadata(TRPC_MUTATION_METADATA_KEY, target.constructor) || [];
-    existingMethods.push({ propertyKey, metadata });
-    Reflect.defineMetadata(TRPC_MUTATION_METADATA_KEY, existingMethods, target.constructor);
-  };
-}
-/**
- * Get all TRPC query methods from a class or instance
- */
-export function getTRPCQueryMethods(target: any): Array<{ propertyKey: string | symbol; metadata: any }> {
-  const constructor = typeof target === 'function' ? target : target.constructor;
-  return Reflect.getMetadata(TRPC_QUERY_METADATA_KEY, constructor) || [];
-}
-/**
- * Get all TRPC mutation methods from a class or instance
- */
-export function getTRPCMutationMethods(target: any): Array<{ propertyKey: string | symbol; metadata: any }> {
-  const constructor = typeof target === 'function' ? target : target.constructor;
-  return Reflect.getMetadata(TRPC_MUTATION_METADATA_KEY, constructor) || [];
-}
-/**
- * Get all TRPC methods (both queries and mutations) from a class or instance
- */
-export function getAllTRPCMethods(target: any): Array<{ propertyKey: string | symbol; metadata: any }> {
-  return [
-    ...getTRPCQueryMethods(target),
-    ...getTRPCMutationMethods(target)
-  ];
-}
-/**
- * Check if a method is marked as a TRPC query
- */
-export function isTRPCQuery(target: any, methodName: string | symbol): boolean {
-  return !!Reflect.getMetadata(TRPC_QUERY_METADATA_KEY, target, methodName);
-}
-/**
- * Check if a method is marked as a TRPC mutation
- */
-export function isTRPCMutation(target: any, methodName: string | symbol): boolean {
-  return !!Reflect.getMetadata(TRPC_MUTATION_METADATA_KEY, target, methodName);
-}
-/**
- * Check if a method is marked for TRPC exposure (query or mutation)
- */
-export function isTRPCMethod(target: any, methodName: string | symbol): boolean {
-  return isTRPCQuery(target, methodName) || isTRPCMutation(target, methodName);
-}

package/otel/src/sdk.ts DELETED Viewed

@@ -1,57 +0,0 @@
-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;
-}