Updated service runners to initialize the MetricsEngine and the existing metrics

Author: Rentacookie

service/src/metrics.ts

@@ -1,8 +1,17 @@
 import * as core from '@powersync/service-core';
+import {
+  createCoreAPIMetrics,
+  createCoreReplicationMetrics,
+  createCoreStorageMetrics,
+  initializeCoreAPIMetrics,
+  initializeCoreReplicationMetrics,
+  initializeCoreStorageMetrics
+} from '@powersync/service-core';
 
 export enum MetricModes {
   API = 'api',
-  REPLICATION = 'replication'
+  REPLICATION = 'replication',
+  STORAGE = 'storage'
 }
 
 export type MetricsRegistrationOptions = {
@@ -13,28 +22,38 @@ export type MetricsRegistrationOptions = {
 export const registerMetrics = async (options: MetricsRegistrationOptions) => {
   const { service_context, modes } = options;
 
-  // This requires an instantiated bucket storage, which is only created when the lifecycle starts
-  service_context.lifeCycleEngine.withLifecycle(null, {
-    start: async () => {
-      const instanceId = await service_context.storageEngine.activeBucketStorage.getPowerSyncInstanceId();
-      await core.metrics.Metrics.initialise({
-        powersync_instance_id: instanceId,
-        disable_telemetry_sharing: service_context.configuration.telemetry.disable_telemetry_sharing,
-        internal_metrics_endpoint: service_context.configuration.telemetry.internal_service_endpoint
-      });
-
-      // TODO remove singleton
-      const instance = core.Metrics.getInstance();
-      service_context.register(core.metrics.Metrics, instance);
-
-      if (modes.includes(MetricModes.API)) {
-        instance.configureApiMetrics();
-      }
+  const metricsFactory = core.metrics.createOpenTelemetryMetricsFactory(service_context);
+  const metricsEngine = new core.metrics.MetricsEngine({
+    factory: metricsFactory,
+    disable_telemetry_sharing: service_context.configuration.telemetry.disable_telemetry_sharing
+  });
+  service_context.register(core.metrics.MetricsEngine, metricsEngine);
+
+  if (modes.includes(MetricModes.API)) {
+    createCoreAPIMetrics(metricsEngine);
+    initializeCoreAPIMetrics(metricsEngine);
+  }
 
-      if (modes.includes(MetricModes.REPLICATION)) {
-        instance.configureReplicationMetrics(service_context.storageEngine.activeBucketStorage);
+  if (modes.includes(MetricModes.REPLICATION)) {
+    createCoreReplicationMetrics(metricsEngine);
+    initializeCoreReplicationMetrics(metricsEngine);
+  }
+
+  if (modes.includes(MetricModes.STORAGE)) {
+    createCoreStorageMetrics(metricsEngine);
+
+    // This requires an instantiated bucket storage, which is only created when the lifecycle starts
+    service_context.storageEngine.registerListener({
+      storageActivated: (bucketStorage) => {
+        initializeCoreStorageMetrics(metricsEngine, bucketStorage);
       }
+    });
+  }
+
+  service_context.lifeCycleEngine.withLifecycle(metricsEngine, {
+    start: async () => {
+      await metricsEngine.start();
     },
-    stop: () => service_context.metrics!.shutdown()
+    stop: () => metricsEngine.shutdown()
   });
 };

service/src/runners/stream-worker.ts

@@ -21,14 +21,14 @@ export const startStreamRunner = async (runnerConfig: core.utils.RunnerConfig) =
 
   const config = await core.utils.loadConfig(runnerConfig);
 
-  // Self hosted version allows for automatic migrations
+  // Self-hosted version allows for automatic migrations
   const serviceContext = new core.system.ServiceContextContainer(config);
 
   registerReplicationServices(serviceContext);
 
   await registerMetrics({
     service_context: serviceContext,
-    modes: [MetricModes.REPLICATION]
+    modes: [MetricModes.REPLICATION, MetricModes.STORAGE]
   });
 
   const moduleManager = container.getImplementation(core.modules.ModuleManager);

service/src/runners/unified-runner.ts

@@ -20,7 +20,7 @@ export const startUnifiedRunner = async (runnerConfig: core.utils.RunnerConfig)
 
   await registerMetrics({
     service_context: serviceContext,
-    modes: [MetricModes.API, MetricModes.REPLICATION]
+    modes: [MetricModes.API, MetricModes.REPLICATION, MetricModes.STORAGE]
   });
 
   const moduleManager = container.getImplementation(core.modules.ModuleManager);