@reactionary/core 0.1.8 → 0.1.9

package/cache/memory-cache.js

@@ -1,14 +1,22 @@
+import { getReactionaryCacheMeter } from "../metrics/metrics.js";
 class MemoryCache {
   constructor() {
     this.entries = new Array();
+    this.meter = getReactionaryCacheMeter();
   }
   async get(key, schema) {
     const c = this.entries.find((x) => x.key === key);
     if (!c) {
+      this.meter.misses.add(1, {
+        "labels.cache_type": "memory"
+      });
       return null;
     }
     const parsed = schema.parse(c.value);
     parsed.meta.cache.hit = true;
+    this.meter.hits.add(1, {
+      "labels.cache_type": "memory"
+    });
     return parsed;
   }
   async put(key, value, options) {
@@ -17,6 +25,9 @@ class MemoryCache {
       value,
       options
     });
+    this.meter.items.record(this.entries.length, {
+      "labels.cache_type": "memory"
+    });
     return;
   }
   async invalidate(dependencyIds) {
@@ -29,9 +40,15 @@ class MemoryCache {
       }
       index++;
     }
+    this.meter.items.record(this.entries.length, {
+      "labels.cache_type": "memory"
+    });
   }
   async clear() {
     this.entries = [];
+    this.meter.items.record(this.entries.length, {
+      "labels.cache_type": "memory"
+    });
   }
 }
 export {

package/cache/noop-cache.js

@@ -1,14 +1,30 @@
+import { getReactionaryCacheMeter } from "../metrics/metrics.js";
 class NoOpCache {
+  constructor() {
+    this.meter = getReactionaryCacheMeter();
+  }
   async get(_key, _schema) {
+    this.meter.misses.add(1, {
+      "labels.cache_type": "noop"
+    });
     return null;
   }
   async put(_key, _value, options) {
+    this.meter.items.record(0, {
+      "labels.cache_type": "noop"
+    });
     return;
   }
   async invalidate(dependencyIds) {
+    this.meter.items.record(0, {
+      "labels.cache_type": "noop"
+    });
     return;
   }
   async clear() {
+    this.meter.items.record(0, {
+      "labels.cache_type": "noop"
+    });
     return;
   }
 }

package/cache/redis-cache.js

@@ -1,6 +1,8 @@
 import { Redis } from "@upstash/redis";
+import { getReactionaryCacheMeter } from "../metrics/metrics.js";
 class RedisCache {
   constructor() {
+    this.meter = getReactionaryCacheMeter();
     this.redis = Redis.fromEnv();
   }
   async get(key, schema) {
@@ -10,6 +12,9 @@ class RedisCache {
     const unvalidated = await this.redis.get(key);
     const parsed = schema.safeParse(unvalidated);
     if (parsed.success) {
+      this.meter.hits.add(1, {
+        "labels.cache_type": "redis"
+      });
       return parsed.data;
     }
     return null;
@@ -24,6 +29,9 @@ class RedisCache {
     for (const depId of options.dependencyIds) {
       multi.sadd(`dep:${depId}`, key);
     }
+    this.meter.items.record(await this.redis.dbsize(), {
+      "labels.cache_type": "redis"
+    });
     await multi.exec();
   }
   async invalidate(dependencyIds) {
@@ -35,8 +43,14 @@ class RedisCache {
       }
       await this.redis.del(depKey);
     }
+    this.meter.items.record(await this.redis.dbsize(), {
+      "labels.cache_type": "redis"
+    });
   }
   async clear() {
+    this.meter.items.record(await this.redis.dbsize(), {
+      "labels.cache_type": "redis"
+    });
   }
 }
 export {

package/decorators/reactionary.decorator.js

@@ -1,4 +1,5 @@
-import { trace, SpanKind } from "@opentelemetry/api";
+import { trace } from "@opentelemetry/api";
+import { getReactionaryMeter } from "../metrics/metrics.js";
 const TRACER_NAME = "@reactionary";
 const TRACER_VERSION = "0.0.1";
 let globalTracer = null;
@@ -38,6 +39,13 @@ function Reactionary(options) {
     const original = descriptor.value;
     const scope = `${target.constructor.name}.${propertyKey.toString()}`;
     const configuration = { ...new ReactionaryDecoratorOptions(), ...options };
+    const meter = getReactionaryMeter();
+    const attributes = {
+      "labels.scope": scope
+    };
+    const startTime = performance.now();
+    let status = "ok";
+    let cacheStatus = "miss";
     if (!original) {
       throw new Error(
         "@Reactionary decorator may only be applied to methods on classes extending BaseProvider."
@@ -45,19 +53,40 @@ function Reactionary(options) {
     }
     descriptor.value = async function(...args) {
       return traceSpan(scope, async () => {
-        const input = validateInput(args[0], configuration.inputSchema);
-        const cacheKey = this.generateCacheKeyForQuery(scope, input);
-        const fromCache = await this.cache.get(cacheKey, options.inputSchema);
-        let result = fromCache;
-        if (!result) {
-          result = await original.apply(this, [input]);
-          const dependencyIds = this.generateDependencyIdsForModel(result);
-          this.cache.put(cacheKey, result, {
-            ttlSeconds: configuration.cacheTimeToLiveInSeconds,
-            dependencyIds
-          });
+        meter.requestInProgress.add(1, attributes);
+        try {
+          const input = validateInput(args[0], configuration.inputSchema);
+          const cacheKey = this.generateCacheKeyForQuery(scope, input);
+          const fromCache = await this.cache.get(
+            cacheKey,
+            options.inputSchema
+          );
+          let result = fromCache;
+          if (!result) {
+            result = await original.apply(this, [input]);
+            const dependencyIds = this.generateDependencyIdsForModel(result);
+            this.cache.put(cacheKey, result, {
+              ttlSeconds: configuration.cacheTimeToLiveInSeconds,
+              dependencyIds
+            });
+          } else {
+            cacheStatus = "hit";
+          }
+          return validateOutput(result, configuration.outputSchema);
+        } catch (err) {
+          status = "error";
+          throw err;
+        } finally {
+          const duration = performance.now() - startTime;
+          const finalAttributes = {
+            ...attributes,
+            "labels.status": status,
+            "labels.cache_status": cacheStatus
+          };
+          meter.requestInProgress.add(-1, finalAttributes);
+          meter.requests.add(1, finalAttributes);
+          meter.requestDuration.record(duration, finalAttributes);
         }
-        return validateOutput(result, configuration.outputSchema);
       });
     };
     return descriptor;

package/metrics/metrics.js

@@ -0,0 +1,50 @@
+import { metrics } from "@opentelemetry/api";
+const METRICS_NAME = "@reactionary";
+const TRACER_VERSION = "0.0.1";
+let globalCacheMetrics = null;
+function getReactionaryCacheMeter() {
+  if (!globalCacheMetrics) {
+    const meter = metrics.getMeter(METRICS_NAME, TRACER_VERSION);
+    globalCacheMetrics = {
+      items: meter.createGauge("reactionary_cache_items", {
+        description: "Tracks the number of items in the cache"
+      }),
+      hits: meter.createCounter("reactionary_cache_hits", {
+        description: "Counts the number of cache hits"
+      }),
+      misses: meter.createCounter("reactionary_cache_misses", {
+        description: "Counts the number of cache misses"
+      })
+    };
+  }
+  return globalCacheMetrics;
+}
+let globalMetrics = null;
+function getReactionaryMeter() {
+  if (!globalMetrics) {
+    const meter = metrics.getMeter(METRICS_NAME, TRACER_VERSION);
+    globalMetrics = {
+      requests: meter.createCounter("reactionary_provider_requests", {
+        description: "Counts the number of requests made to provider queries and mutations"
+      }),
+      requestDuration: meter.createHistogram(
+        "reactionary_provider_request_duration",
+        {
+          description: "Records the duration of provider query and mutation requests",
+          unit: "ms"
+        }
+      ),
+      requestInProgress: meter.createUpDownCounter(
+        "reactionary_provider_requests_in_progress",
+        {
+          description: "Tracks the number of in-progress requests to provider queries and mutations"
+        }
+      )
+    };
+  }
+  return globalMetrics;
+}
+export {
+  getReactionaryCacheMeter,
+  getReactionaryMeter
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reactionary/core",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {

package/src/cache/memory-cache.d.ts

@@ -11,6 +11,7 @@ export declare class MemoryCache implements Cache {
         value: unknown;
         options: CacheEntryOptions;
     }[];
+    protected meter: import("../metrics/metrics.js").ReactionaryCacheMetrics;
     get<T extends BaseModel>(key: string, schema: z.ZodType<T>): Promise<T | null>;
     put(key: string, value: unknown, options: CacheEntryOptions): Promise<void>;
     invalidate(dependencyIds: Array<string>): Promise<void>;

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

@@ -5,6 +5,7 @@ import type z from 'zod';
  * Useful for testing or when caching should be disabled.
  */
 export declare class NoOpCache implements Cache {
+    protected meter: import("../metrics/metrics.js").ReactionaryCacheMetrics;
     get<T>(_key: string, _schema: z.ZodType<T>): Promise<T | null>;
     put(_key: string, _value: unknown, options: CacheEntryOptions): Promise<void>;
     invalidate(dependencyIds: Array<string>): Promise<void>;

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

@@ -3,6 +3,7 @@ import type { Cache, CacheEntryOptions } from './cache.interface.js';
 import type z from 'zod';
 export declare class RedisCache implements Cache {
     protected redis: Redis;
+    protected meter: import("../metrics/metrics.js").ReactionaryCacheMetrics;
     constructor();
     get<T>(key: string, schema: z.ZodType<T>): Promise<T | null>;
     put(key: string, value: unknown, options: CacheEntryOptions): Promise<void>;

package/src/decorators/reactionary.decorator.d.ts

@@ -1,6 +1,6 @@
-import type { BaseProvider } from '../providers/index.js';
 import type { Tracer } from '@opentelemetry/api';
 import type { z } from 'zod';
+import type { BaseProvider } from '../providers/index.js';
 export declare function getTracer(): Tracer;
 /**
  * The options associated with annotating a provider function and marking

package/src/metrics/metrics.d.ts

@@ -0,0 +1,14 @@
+import type { Counter, Gauge } from '@opentelemetry/api';
+import { type Histogram, type UpDownCounter } from '@opentelemetry/api';
+export interface ReactionaryCacheMetrics {
+    items: Gauge;
+    hits: Counter;
+    misses: Counter;
+}
+export declare function getReactionaryCacheMeter(): ReactionaryCacheMetrics;
+export interface ReactionaryMetrics {
+    requests: Counter;
+    requestDuration: Histogram;
+    requestInProgress: UpDownCounter;
+}
+export declare function getReactionaryMeter(): ReactionaryMetrics;