@reactionary/source 0.0.29 → 0.0.31

package/CLAUDE.md

@@ -0,0 +1,11 @@
+# Verification commands
+- `npx nx affected:build` builds the projects affected by current changes.
+- `npx nx affected:lint` lints and verifies the projects affected by current changes.
+
+# Code style
+- Use ES modules (import/export) syntax, not CommonJS (require).
+- Keep things strongly typed. Do not use `as any` or similar unchecked type casts.
+
+# Workflow
+- Be sure to ensure that changes lint and build.
+- Avoid introducing changes that would be breaking for any client consumer of the library without asking for clearance.

package/core/src/cache/cache-evaluation.interface.ts

@@ -0,0 +1,19 @@
+/**
+ * Cache evaluation result that determines how and if a query should be cached
+ */
+export interface CacheEvaluation {
+  /**
+   * The cache key to use for storing/retrieving the value
+   */
+  key: string;
+  
+  /**
+   * How long to cache the value in seconds
+   */
+  cacheDurationInSeconds: number;
+  
+  /**
+   * Whether this query result can be cached
+   */
+  canCache: boolean;
+}

package/core/src/cache/cache.interface.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+
+/**
+ * Generic cache interface that can be implemented by different cache backends
+ * (Redis, memory, file-based, etc.)
+ */
+export interface Cache {
+  /**
+   * Retrieves a value from cache and validates it against the provided schema
+   */
+  get<T>(key: string, schema: z.ZodType<T>): Promise<T | null>;
+
+  /**
+   * Stores a value in cache with optional expiration time
+   */
+  put(key: string, value: unknown, ttlSeconds?: number): Promise<void>;
+
+  /**
+   * Removes one or more keys from cache
+   * Supports wildcard patterns (implementation dependent)
+   */
+  del(keys: string | string[]): Promise<void>;
+
+  /**
+   * Finds all keys matching a pattern (implementation dependent)
+   */
+  keys(pattern: string): Promise<string[]>;
+
+  /**
+   * Clears all cache entries or entries matching a pattern
+   */
+  clear(pattern?: string): Promise<void>;
+
+  /**
+   * Gets basic cache statistics (implementation dependent)
+   */
+  getStats(): Promise<{ hits: number; misses: number; size: number }>;
+}

package/core/src/cache/noop-cache.ts

@@ -0,0 +1,42 @@
+import { Cache } from './cache.interface';
+import z from 'zod';
+
+/**
+ * No-op cache implementation that never stores or returns data.
+ * Useful for testing or when caching should be disabled.
+ */
+export class NoOpCache implements Cache {
+  public async get<T>(_key: string, _schema: z.ZodType<T>): Promise<T | null> {
+    // Always return null - never a cache hit
+    return null;
+  }
+
+  public async put(_key: string, _value: unknown, _ttlSeconds?: number): Promise<void> {
+    // No-op - silently ignore cache write requests
+    return;
+  }
+
+  public async del(_keys: string | string[]): Promise<void> {
+    // No-op - silently ignore delete requests
+    return;
+  }
+
+  public async keys(_pattern: string): Promise<string[]> {
+    // Always return empty array
+    return [];
+  }
+
+  public async clear(_pattern?: string): Promise<void> {
+    // No-op - silently ignore clear requests
+    return;
+  }
+
+  public async getStats(): Promise<{ hits: number; misses: number; size: number }> {
+    // Always return zeros
+    return {
+      hits: 0,
+      misses: 0,
+      size: 0
+    };
+  }
+}

package/core/src/cache/redis-cache.ts

@@ -1,41 +1,74 @@
 import { Redis } from '@upstash/redis';
-import { CachingStrategy } from './caching-strategy';
-import { BaseQuery } from '../schemas/queries/base.query';
-import { Session } from '../schemas/session.schema';
-import { BaseModel } from '../schemas/models/base.model';
+import { Cache } from './cache.interface';
 import z from 'zod';
 
-export class RedisCache {
-  protected strategy: CachingStrategy;
+export class RedisCache implements Cache {
   protected redis: Redis;
 
-  constructor(strategy: CachingStrategy) {
-    this.strategy = strategy;
+  constructor() {
     this.redis = Redis.fromEnv();
   }
 
-  public async get<T extends BaseModel>(query: BaseQuery, session: Session, schema: z.ZodType<T>): Promise<T | null> {
-    let result = null;
+  public async get<T>(key: string, schema: z.ZodType<T>): Promise<T | null> {
+    if (!key) {
+      return null;
+    }
     
-    const cacheInformation = this.strategy.get(query, session);
+    const unvalidated = await this.redis.get(key);
+    const parsed = schema.safeParse(unvalidated);
+
+    if (parsed.success) {
+      return parsed.data;
+    }
     
-    if (cacheInformation.canCache && cacheInformation.key) {
-      const unvalidated = await this.redis.get(cacheInformation.key);
-      const parsed = schema.safeParse(unvalidated);
+    return null;
+  }
 
-      if (parsed.success) {
-        result = parsed.data;
-      }
+  public async put(key: string, value: unknown, ttlSeconds?: number): Promise<void> {
+    if (!key) {
+      return;
     }
+
+    const options = ttlSeconds ? { ex: ttlSeconds } : undefined;
+    await this.redis.set(key, value, options);
+  }
+
+  public async del(keys: string | string[]): Promise<void> {
+    const keyArray = Array.isArray(keys) ? keys : [keys];
     
-    return result;
+    for (const key of keyArray) {
+      if (key.includes('*')) {
+        // Handle wildcard patterns
+        const matchingKeys = await this.redis.keys(key);
+        if (matchingKeys.length > 0) {
+          await this.redis.del(...matchingKeys);
+        }
+      } else {
+        // Delete specific key
+        await this.redis.del(key);
+      }
+    }
   }
 
-  public put(query: BaseQuery, session: Session, value: unknown): void {
-    const cacheInformation = this.strategy.get(query, session);
+  public async keys(pattern: string): Promise<string[]> {
+    return await this.redis.keys(pattern);
+  }
 
-    if (cacheInformation.canCache && cacheInformation.key) {
-      this.redis.set(cacheInformation.key, value, { ex: cacheInformation.cacheDurationInSeconds });
+  public async clear(pattern?: string): Promise<void> {
+    const searchPattern = pattern || '*';
+    const keys = await this.redis.keys(searchPattern);
+    if (keys.length > 0) {
+      await this.redis.del(...keys);
     }
   }
+
+  public async getStats(): Promise<{ hits: number; misses: number; size: number }> {
+    // Basic cache statistics (could be enhanced with actual Redis metrics)
+    const keys = await this.redis.keys('*');
+    return {
+      hits: 0, // Would need to track this separately
+      misses: 0, // Would need to track this separately  
+      size: keys.length
+    };
+  }
 }

package/core/src/client/client.ts

@@ -5,6 +5,8 @@ import { IdentityProvider } from '../providers/identity.provider';
 import { CartProvider } from "../providers/cart.provider";
 import { PriceProvider } from "../providers/price.provider";
 import { InventoryProvider } from "../providers/inventory.provider";
+import { Cache } from "../cache/cache.interface";
+import { RedisCache } from "../cache/redis-cache";
 
 export interface Client {
     product: ProductProvider,
@@ -17,12 +19,23 @@ export interface Client {
     inventory: InventoryProvider
 }
 
-export function buildClient<T extends Partial<Client>>(providers: Array<T>): Required<T> {
+export interface BuildClientOptions {
+    cache?: Cache;
+}
+
+export function buildClient<T extends Partial<Client>>(
+    providerFactories: Array<(cache: Cache) => T>,
+    options: BuildClientOptions = {}
+): Required<T> {
     let client = { } as Required<T>;
 
+    // Create shared cache instance
+    const sharedCache = options.cache || new RedisCache();
+
     const mergedAnalytics = [];
 
-    for (const provider of providers) {
+    for (const factory of providerFactories) {
+        const provider = factory(sharedCache);
         client = {
             ...client,
             ...provider
@@ -34,6 +47,17 @@ export function buildClient<T extends Partial<Client>>(providers: Array<T>): Req
     }
 
     client.analytics = mergedAnalytics;
+    
+    // Add cache to complete the client
+    const completeClient = {
+        ...client,
+        cache: sharedCache
+    } as Required<T>;
+
+    return completeClient;
+}
 
-    return client satisfies T;
+// Convenience function to create a shared cache instance
+export function createCache(): Cache {
+    return new RedisCache();
 }

package/core/src/index.ts

@@ -1,5 +1,7 @@
-export * from './cache/caching-strategy';
+export * from './cache/cache.interface';
+export * from './cache/cache-evaluation.interface';
 export * from './cache/redis-cache';
+export * from './cache/noop-cache';
 
 export * from './client/client';
 

package/core/src/providers/analytics.provider.ts

@@ -2,9 +2,32 @@ import { AnalyticsEvent } from '../schemas/models/analytics.model';
 import { AnalyticsMutation } from '../schemas/mutations/analytics.mutation';
 import { AnalyticsQuery } from '../schemas/queries/analytics.query';
 import { BaseProvider } from './base.provider';
+import { CacheEvaluation } from '../cache/cache-evaluation.interface';
+import { Session } from '../schemas/session.schema';
+import * as crypto from 'crypto';
 
 export abstract class AnalyticsProvider<
   T extends AnalyticsEvent = AnalyticsEvent,
   Q extends AnalyticsQuery = AnalyticsQuery,
   M extends AnalyticsMutation = AnalyticsMutation
-> extends BaseProvider<T, Q, M> {}
+> extends BaseProvider<T, Q, M> {
+  
+  protected override getCacheEvaluation(query: Q, _session: Session): CacheEvaluation {
+    const providerName = this.constructor.name.toLowerCase();
+    
+    // Hash analytics query parameters
+    const relevantFields = {
+      type: typeof query === 'object' && query !== null && 'type' in query ? (query as any).type : undefined,
+      dateRange: typeof query === 'object' && query !== null && 'dateRange' in query ? (query as any).dateRange : undefined,
+      filters: typeof query === 'object' && query !== null && 'filters' in query ? (query as any).filters : undefined
+    };
+    const analyticsHash = crypto.createHash('md5').update(JSON.stringify(relevantFields)).digest('hex').substring(0, 12);
+    const key = `${providerName}:analytics:${analyticsHash}`;
+    
+    return {
+      key,
+      cacheDurationInSeconds: 0,
+      canCache: false
+    };
+  }
+}

package/core/src/providers/base.provider.ts

@@ -4,6 +4,9 @@ import { BaseQuery } from '../schemas/queries/base.query';
 import { BaseMutation } from '../schemas/mutations/base.mutation';
 import { BaseModel } from '../schemas/models/base.model';
 import { createProviderInstrumentation } from '@reactionary/otel';
+import { Cache } from '../cache/cache.interface';
+import { CacheEvaluation } from '../cache/cache-evaluation.interface';
+import * as crypto from 'crypto';
 
 /**
  * Base capability provider, responsible for mutations (changes) and queries (fetches)
@@ -14,10 +17,17 @@ export abstract class BaseProvider<
   Q extends BaseQuery = BaseQuery,
   M extends BaseMutation = BaseMutation
 > {
-  private instrumentation: ReturnType<typeof createProviderInstrumentation>;
+  protected instrumentation: ReturnType<typeof createProviderInstrumentation>;
+  protected cache: Cache;
   
-  constructor(public readonly schema: z.ZodType<T>, public readonly querySchema: z.ZodType<Q, Q>, public readonly mutationSchema: z.ZodType<M, M>) {
+  constructor(
+    public readonly schema: z.ZodType<T>, 
+    public readonly querySchema: z.ZodType<Q, Q>, 
+    public readonly mutationSchema: z.ZodType<M, M>,
+    cache: Cache
+  ) {
     this.instrumentation = createProviderInstrumentation(this.constructor.name);
+    this.cache = cache;
   }
 
   /**
@@ -46,13 +56,60 @@ export abstract class BaseProvider<
       'query',
       async (span) => {
         span.setAttribute('provider.query.count', queries.length);
-        const results = await this.fetch(queries, session);
+        
+        let cacheHits = 0;
+        let cacheMisses = 0;
+        const results: T[] = [];
 
-        for (const result of results) {
-          this.assert(result);
+        // Process each query individually for cache efficiency
+        for (const query of queries) {
+          let result: T | null = null;
+          
+          // Get cache evaluation from provider
+          const cacheInfo = this.getCacheEvaluation(query, session);
+          
+          // Try cache first if caching is enabled
+          if (cacheInfo.canCache && cacheInfo.key) {
+            try {
+              result = await this.cache.get(cacheInfo.key, this.schema);
+              if (result) {
+                cacheHits++;
+                span.setAttribute('provider.cache.hit', true);
+              }
+            } catch (error) {
+              // Cache error shouldn't break the query - log and continue
+              console.warn(`Cache get error for ${this.constructor.name}:`, error);
+            }
+          }
+          
+          // If not in cache, fetch from source
+          if (!result) {
+            const singleResult = await this.fetch([query], session);
+            result = singleResult[0];
+            cacheMisses++;
+            
+            // Store in cache if caching is enabled
+            if (result && cacheInfo.canCache && cacheInfo.key) {
+              try {
+                await this.cache.put(cacheInfo.key, result, cacheInfo.cacheDurationInSeconds);
+              } catch (error) {
+                // Cache put error shouldn't break the query - log and continue
+                console.warn(`Cache put error for ${this.constructor.name}:`, error);
+              }
+            }
+          }
+          
+          if (result) {
+            this.assert(result);
+            results.push(result);
+          }
         }
 
         span.setAttribute('provider.result.count', results.length);
+        span.setAttribute('provider.cache.hits', cacheHits);
+        span.setAttribute('provider.cache.misses', cacheMisses);
+        span.setAttribute('provider.cache.hit_ratio', cacheHits / (cacheHits + cacheMisses));
+        
         return results;
       },
       { queryCount: queries.length }
@@ -68,8 +125,9 @@ export abstract class BaseProvider<
       'mutate',
       async (span) => {
         span.setAttribute('provider.mutation.count', mutations.length);
+        
+        // Perform the mutation
         const result = await this.process(mutations, session);
-
         this.assert(result);
 
         return result;
@@ -92,4 +150,24 @@ export abstract class BaseProvider<
     mutations: M[],
     session: Session
   ): Promise<T>;
+
+  /**
+   * Provider-specific cache evaluation logic.
+   * Returns information about how this query should be cached.
+   * Override this method to enable caching with custom keys and TTL.
+   * Default implementation returns no caching.
+   */
+  protected getCacheEvaluation(query: Q, session: Session): CacheEvaluation {
+    // Default implementation: generate a cache key but don't cache
+    const providerName = this.constructor.name.toLowerCase();
+    const userId = session.identity?.id || 'anonymous';
+    const queryHash = crypto.createHash('md5').update(JSON.stringify(query)).digest('hex').substring(0, 12);
+    const key = `${providerName}:${userId}:${queryHash}`;
+    
+    return {
+      key,
+      cacheDurationInSeconds: 0,
+      canCache: false
+    };
+  }
 }

package/core/src/providers/cart.provider.ts

@@ -2,9 +2,26 @@ import { CartQuery } from "../schemas/queries/cart.query";
 import { CartMutation } from "../schemas/mutations/cart.mutation";
 import { BaseProvider } from "./base.provider";
 import { Cart } from "../schemas/models/cart.model";
+import { CacheEvaluation } from '../cache/cache-evaluation.interface';
+import { Session } from '../schemas/session.schema';
+import * as crypto from 'crypto';
 
 export abstract class CartProvider<
   T extends Cart = Cart,
   Q extends CartQuery = CartQuery,
   M extends CartMutation = CartMutation
-> extends BaseProvider<T, Q, M> {}
+> extends BaseProvider<T, Q, M> {
+  
+  protected override getCacheEvaluation(query: Q, session: Session): CacheEvaluation {
+    const providerName = this.constructor.name.toLowerCase();
+    const userId = session.identity?.id || 'anonymous';
+    const queryHash = crypto.createHash('md5').update(JSON.stringify(query)).digest('hex').substring(0, 12);
+    const key = `${providerName}:cart:${userId}:${queryHash}`;
+    
+    return {
+      key,
+      cacheDurationInSeconds: 0,
+      canCache: false
+    };
+  }
+}

package/core/src/providers/identity.provider.ts

@@ -2,9 +2,26 @@ import { Identity } from "../schemas/models/identity.model";
 import { IdentityQuery } from "../schemas/queries/identity.query";
 import { IdentityMutation } from "../schemas/mutations/identity.mutation";
 import { BaseProvider } from "./base.provider";
+import { CacheEvaluation } from '../cache/cache-evaluation.interface';
+import { Session } from '../schemas/session.schema';
 
 export abstract class IdentityProvider<
   T extends Identity = Identity,
   Q extends IdentityQuery = IdentityQuery,
   M extends IdentityMutation = IdentityMutation
-> extends BaseProvider<T, Q, M> {}
+> extends BaseProvider<T, Q, M> {
+  
+  protected override getCacheEvaluation(_query: Q, session: Session): CacheEvaluation {
+    const providerName = this.constructor.name.toLowerCase();
+    const userId = session.identity?.id;
+    const key = userId 
+      ? `${providerName}:identity:${userId}`
+      : `${providerName}:identity:anonymous`;
+    
+    return {
+      key,
+      cacheDurationInSeconds: 0,
+      canCache: false
+    };
+  }
+}

package/core/src/providers/inventory.provider.ts

@@ -1,11 +1,24 @@
-import z from 'zod';
 import { Inventory } from '../schemas/models/inventory.model';
 import { InventoryQuery } from '../schemas/queries/inventory.query';
 import { InventoryMutation } from '../schemas/mutations/inventory.mutation';
 import { BaseProvider } from './base.provider';
+import { CacheEvaluation } from '../cache/cache-evaluation.interface';
+import { Session } from '../schemas/session.schema';
 
 export abstract class InventoryProvider<
   T extends Inventory = Inventory,
   Q extends InventoryQuery = InventoryQuery,
   M extends InventoryMutation = InventoryMutation
-> extends BaseProvider<T, Q, M> {}
+> extends BaseProvider<T, Q, M> {
+  
+  protected override getCacheEvaluation(query: Q, _session: Session): CacheEvaluation {
+    const providerName = this.constructor.name.toLowerCase();
+    const key = `${providerName}:inventory:${query.sku}`;
+    
+    return {
+      key,
+      cacheDurationInSeconds: 0,
+      canCache: false
+    };
+  }
+}

package/core/src/providers/price.provider.ts

@@ -2,9 +2,26 @@ import { Price } from '../schemas/models/price.model';
 import { PriceMutation } from '../schemas/mutations/price.mutation';
 import { PriceQuery } from '../schemas/queries/price.query';
 import { BaseProvider } from './base.provider';
+import { CacheEvaluation } from '../cache/cache-evaluation.interface';
+import { Session } from '../schemas/session.schema';
+import * as crypto from 'crypto';
 
 export abstract class PriceProvider<
   T extends Price = Price,
   Q extends PriceQuery = PriceQuery,
   M extends PriceMutation = PriceMutation
-> extends BaseProvider<T, Q, M> {}
+> extends BaseProvider<T, Q, M> {
+  
+  protected override getCacheEvaluation(query: Q, _session: Session): CacheEvaluation {
+    const providerName = this.constructor.name.toLowerCase();
+    // Hash complex SKU objects (price queries with currency, customer group, etc.)
+    const skuHash = crypto.createHash('md5').update(JSON.stringify(query.sku)).digest('hex').substring(0, 12);
+    const key = `${providerName}:price:${skuHash}`;
+    
+    return {
+      key,
+      cacheDurationInSeconds: 0,
+      canCache: false
+    };
+  }
+}

package/core/src/providers/product.provider.ts

@@ -1,11 +1,34 @@
 import { Product } from '../schemas/models/product.model';
 import { ProductMutation } from '../schemas/mutations/product.mutation';
-import { ProductQuery } from '../schemas/queries/product.query';
+import { ProductQuery, ProductQueryById, ProductQueryBySlug } from '../schemas/queries/product.query';
 import { BaseProvider } from './base.provider';
+import { Session } from '../schemas/session.schema';
+import { CacheEvaluation } from '../cache/cache-evaluation.interface';
+import * as crypto from 'crypto';
 
 export abstract class ProductProvider<
   T extends Product = Product,
   Q extends ProductQuery = ProductQuery,
   M extends ProductMutation = ProductMutation
 > extends BaseProvider<T, Q, M> {
+  
+  protected override getCacheEvaluation(query: Q, _session: Session): CacheEvaluation {
+    const providerName = this.constructor.name.toLowerCase();
+    
+    let key: string;
+    if (query.query === 'slug') {
+      key = `${providerName}:product:slug:${(query as ProductQueryBySlug).slug}`;
+    } else if (query.query === 'id') {
+      key = `${providerName}:product:id:${(query as ProductQueryById).id}`;
+    } else {
+      const queryHash = crypto.createHash('md5').update(JSON.stringify(query)).digest('hex').substring(0, 12);
+      key = `${providerName}:product:${queryHash}`;
+    }
+    
+    return {
+      key,
+      cacheDurationInSeconds: 300, // Products are moderately stable - 5 minutes
+      canCache: true
+    };
+  }
 }

package/core/src/providers/search.provider.ts

@@ -2,11 +2,28 @@ import { SearchResult } from '../schemas/models/search.model';
 import { SearchQuery } from '../schemas/queries/search.query';
 import { SearchMutation } from '../schemas/mutations/search.mutation';
 import { BaseProvider } from './base.provider';
+import { CacheEvaluation } from '../cache/cache-evaluation.interface';
+import { Session } from '../schemas/session.schema';
+import * as crypto from 'crypto';
 
 export abstract class SearchProvider<
   T extends SearchResult = SearchResult,
   Q extends SearchQuery = SearchQuery,
   M extends SearchMutation = SearchMutation
-> extends BaseProvider<T, Q, M> {}
+> extends BaseProvider<T, Q, M> {
+  
+  protected override getCacheEvaluation(query: Q, _session: Session): CacheEvaluation {
+    const providerName = this.constructor.name.toLowerCase();
+    // Hash search parameters (term, filters, pagination, etc.)
+    const searchHash = crypto.createHash('md5').update(JSON.stringify(query.search)).digest('hex').substring(0, 12);
+    const key = `${providerName}:search:${searchHash}`;
+    
+    return {
+      key,
+      cacheDurationInSeconds: 0,
+      canCache: false
+    };
+  }
+}
 
 

package/core/src/schemas/mutations/product.mutation.ts

@@ -1,5 +1,4 @@
 import { z } from 'zod';
-import { BaseMutationSchema } from './base.mutation';
 
 export const ProductMutationSchema = z.union([]);
 

package/examples/node/src/providers/custom-algolia-product.provider.ts

@@ -3,8 +3,8 @@ import { CustomProduct, CustomProductSchema } from '../schemas/custom-product.sc
 import { ProductMutationSchema, ProductQuerySchema } from '@reactionary/core';
 
 export class CustomAlgoliaProductProvider extends AlgoliaProductProvider<CustomProduct> {    
-    constructor(config: AlgoliaConfiguration) {
-        super(config, CustomProductSchema, ProductQuerySchema, ProductMutationSchema);
+    constructor(config: AlgoliaConfiguration, cache: any) {
+        super(config, CustomProductSchema, ProductQuerySchema, ProductMutationSchema, cache);
       }
     
     public parse(data: any): CustomProduct {

package/examples/trpc-node/.env.example

@@ -5,7 +5,6 @@
 # Service identification
 OTEL_SERVICE_NAME=reactionary-trpc-example
 OTEL_SERVICE_VERSION=1.0.0
-DEPLOYMENT_ENVIRONMENT=development
 
 # Traces exporter: console | otlp | otlp/http | none
 OTEL_TRACES_EXPORTER=console
@@ -16,6 +15,7 @@ OTEL_METRICS_EXPORTER=console
 # For OTLP exporters (e.g., Honeycomb, Jaeger, Grafana)
 # OTEL_EXPORTER_OTLP_ENDPOINT=https://api.honeycomb.io
 # OTEL_EXPORTER_OTLP_HEADERS=x-honeycomb-team=your-api-key
+# OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf
 
 # Or use specific endpoints for traces/metrics
 # OTEL_EXPORTER_OTLP_TRACES_ENDPOINT=https://api.honeycomb.io/v1/traces

package/examples/trpc-node/src/main.ts

@@ -54,10 +54,6 @@ app.use(
 
 const server = app.listen(3000, () => {
   console.log('Server started on http://localhost:3000');
-  // OTEL auto-initializes based on standard env vars
-  if (process.env['OTEL_LOG_LEVEL'] === 'debug') {
-    console.log('OTEL traces exporter:', process.env['OTEL_TRACES_EXPORTER'] || 'console');
-    console.log('OTEL metrics exporter:', process.env['OTEL_METRICS_EXPORTER'] || 'console');
-  }
+  // OpenTelemetry automatically initializes based on OTEL_* environment variables
 });