@cravery/firebase 0.0.45 → 0.0.46

package/src/lib/monitoring.ts

@@ -4,50 +4,112 @@ import {
 } from "@opentelemetry/sdk-metrics";
 import { resourceFromAttributes } from "@opentelemetry/resources";
 import { MetricExporter } from "@google-cloud/opentelemetry-cloud-monitoring-exporter";
-import { Counter, Histogram, ObservableGauge, Meter } from "@opentelemetry/api";
+import {
+  Counter,
+  Histogram,
+  ObservableGauge,
+  Meter,
+  Attributes as OtelAttributes,
+} from "@opentelemetry/api";
+
+const METRIC_NAME_REGEX = /^[a-zA-Z][a-zA-Z0-9_.-]*$/;
+const MAX_CACHED_METRICS = 1000;
+
+const validateMetricName = (name: string): void => {
+  if (!METRIC_NAME_REGEX.test(name)) {
+    throw new Error(
+      `Invalid metric name "${name}": must start with a letter and contain only alphanumeric characters, underscores, dots, or hyphens`,
+    );
+  }
+};
 
 const resource = resourceFromAttributes({
   "service.name": "cravery-backend",
 });
 
-const exporter = new MetricExporter();
-
-const meterProvider = new MeterProvider({
-  resource,
-  readers: [
-    new PeriodicExportingMetricReader({
-      exporter,
-      exportIntervalMillis: 60000,
-    }),
-  ],
-});
+let meterProvider: MeterProvider | null = null;
+let meter: Meter | null = null;
+let isShutdown = false;
+
+const initializeProvider = (): void => {
+  if (meterProvider) return;
+
+  try {
+    const exporter = new MetricExporter();
+    meterProvider = new MeterProvider({
+      resource,
+      readers: [
+        new PeriodicExportingMetricReader({
+          exporter,
+          exportIntervalMillis: 60000,
+        }),
+      ],
+    });
+    meter = meterProvider.getMeter("cravery");
+  } catch (error) {
+    console.error("Failed to initialize metrics provider:", error);
+    throw error;
+  }
+};
 
-const meter: Meter = meterProvider.getMeter("cravery");
+const getMeter = (): Meter => {
+  if (isShutdown) {
+    throw new Error("Metrics provider has been shut down");
+  }
+  if (!meter) {
+    initializeProvider();
+  }
+  return meter!;
+};
 
 const counters = new Map<string, Counter>();
 const histograms = new Map<string, Histogram>();
+const gauges = new Map<string, ObservableGauge>();
 
 const getCounter = (name: string, description?: string): Counter => {
+  validateMetricName(name);
+  if (counters.size >= MAX_CACHED_METRICS && !counters.has(name)) {
+    throw new Error(
+      `Maximum number of cached counters (${MAX_CACHED_METRICS}) exceeded. Avoid dynamic metric names.`,
+    );
+  }
   if (!counters.has(name)) {
-    counters.set(name, meter.createCounter(`cravery.${name}`, { description }));
+    counters.set(
+      name,
+      getMeter().createCounter(`cravery.${name}`, { description }),
+    );
   }
   return counters.get(name)!;
 };
 
-const getHistogram = (name: string, description?: string): Histogram => {
+interface HistogramOptions {
+  description?: string;
+  unit?: string;
+}
+
+const getHistogram = (
+  name: string,
+  options: HistogramOptions = {},
+): Histogram => {
+  validateMetricName(name);
+  if (histograms.size >= MAX_CACHED_METRICS && !histograms.has(name)) {
+    throw new Error(
+      `Maximum number of cached histograms (${MAX_CACHED_METRICS}) exceeded. Avoid dynamic metric names.`,
+    );
+  }
   if (!histograms.has(name)) {
     histograms.set(
       name,
-      meter.createHistogram(`cravery.${name}`, {
-        description,
-        unit: "ms",
+      getMeter().createHistogram(`cravery.${name}`, {
+        description: options.description,
+        unit: options.unit ?? "ms",
       }),
     );
   }
   return histograms.get(name)!;
 };
 
-type Attributes = Record<string, string>;
+type Attributes = OtelAttributes;
 
 export const incrementCounter = (
   name: string,
@@ -71,21 +133,34 @@ export const withTiming = async <T>(
   attributes?: Attributes,
 ): Promise<T> => {
   const start = Date.now();
-  const result = await fn();
-  recordTiming(name, Date.now() - start, attributes);
-  return result;
+  try {
+    return await fn();
+  } finally {
+    recordTiming(name, Date.now() - start, attributes);
+  }
 };
 
 export const registerGauge = (
   name: string,
-  callback: () => number | Promise<number>,
+  callback: () => number,
   attributes?: Attributes,
 ): ObservableGauge => {
-  const gauge = meter.createObservableGauge(`cravery.${name}`);
-  gauge.addCallback(async (observableResult) => {
-    const value = await callback();
-    observableResult.observe(value, attributes);
+  validateMetricName(name);
+  if (gauges.has(name)) {
+    throw new Error(
+      `Gauge "${name}" is already registered. Gauges cannot be re-registered.`,
+    );
+  }
+  const gauge = getMeter().createObservableGauge(`cravery.${name}`);
+  gauge.addCallback((observableResult) => {
+    try {
+      const value = callback();
+      observableResult.observe(value, attributes);
+    } catch (error) {
+      console.error(`Error in gauge callback for "${name}":`, error);
+    }
   });
+  gauges.set(name, gauge);
   return gauge;
 };
 
@@ -102,11 +177,24 @@ export const createMetricsScope = (defaultAttributes: Attributes) => ({
     attributes?: Attributes,
   ) => withTiming(name, fn, { ...defaultAttributes, ...attributes }),
 
-  registerGauge: (
-    name: string,
-    callback: () => number | Promise<number>,
-    attributes?: Attributes,
-  ) => registerGauge(name, callback, { ...defaultAttributes, ...attributes }),
+  registerGauge: (name: string, callback: () => number, attributes?: Attributes) =>
+    registerGauge(name, callback, { ...defaultAttributes, ...attributes }),
 });
 
-export const shutdown = (): Promise<void> => meterProvider.shutdown();
+export const forceFlush = async (): Promise<void> => {
+  if (!meterProvider || isShutdown) {
+    return;
+  }
+  await meterProvider.forceFlush();
+};
+
+export const shutdown = async (): Promise<void> => {
+  if (!meterProvider || isShutdown) {
+    return;
+  }
+  isShutdown = true;
+  await meterProvider.shutdown();
+  counters.clear();
+  histograms.clear();
+  gauges.clear();
+};