Added static dependency factories

packages/api/src/metrics/OpenTelemetryTracer.ts

@@ -1,7 +1,21 @@
 import opentelemetry, { SpanStatusCode } from "@opentelemetry/api";
 import { Tracer } from "@proto-kit/sequencer";
+import { inject, injectable } from "tsyringe";
+import { noop } from "@proto-kit/common";
 
+import type { OpenTelemetryServer } from "./OpenTelemetryServer";
+
+@injectable()
 export class OpenTelemetryTracer implements Tracer {
+  public constructor(
+    // We need to import this here, so that the OpenTelemetryServer will be resolved
+    // before this module, and therefore will be already started when this module is
+    // eventually consumed and used
+    @inject("OpenTelemetryServer") openTelemetryServer: OpenTelemetryServer
+  ) {
+    noop();
+  }
+
   private tracer: ReturnType<typeof opentelemetry.trace.getTracer> | undefined =
     undefined;
 

packages/common/src/config/ModuleContainer.ts

@@ -263,6 +263,10 @@ export class ModuleContainer<
         this.onAfterModuleResolution(moduleName);
 
         this.registerAliases(moduleName, useClass);
+
+        if (this.isDependencyFactory(useClass)) {
+          this.useDependencyFactory(useClass);
+        }
       }
     });
   }
@@ -285,16 +289,6 @@ export class ModuleContainer<
     });
   }
 
-  protected registerClasses(modules: Record<string, TypedClass<unknown>>) {
-    Object.entries(modules).forEach(([moduleName, useClass]) => {
-      this.container.register(
-        moduleName,
-        { useClass },
-        { lifecycle: Lifecycle.ContainerScoped }
-      );
-    });
-  }
-
   /**
    * Provide additional configuration after the ModuleContainer was created.
    *
@@ -403,14 +397,18 @@ export class ModuleContainer<
   protected useDependencyFactory(factory: DependencyFactory) {
     const dependencies = factory.dependencies();
 
+    // eslint-disable-next-line sonarjs/cognitive-complexity
     Object.entries(dependencies).forEach(([rawKey, declaration]) => {
       const key = rawKey.charAt(0).toUpperCase() + rawKey.slice(1);
 
       if (
         !this.container.isRegistered(key) ||
         declaration.forceOverwrite === true
       ) {
-        if (this.container.isRegistered(key) && declaration.forceOverwrite) {
+        if (
+          this.container.isRegistered(key) &&
+          (declaration?.forceOverwrite ?? false)
+        ) {
           log.warn(
             `You are trying to overwrite dependency ${key}, which is already registered. This is currently not supported. Try to define your dependency earlier.`
           );
@@ -434,6 +432,11 @@ export class ModuleContainer<
             // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
             declaration.useClass as TypedClass<unknown>
           );
+
+          // Register static dependencies
+          if (this.isDependencyFactory(declaration.useClass)) {
+            this.useDependencyFactory(declaration.useClass);
+          }
         } else if (isTokenProvider(declaration)) {
           this.container.register(key, declaration, {
             lifecycle: Lifecycle.Singleton,

packages/deployment/docker/monitoring/grafana/grafana-datasources.yaml

@@ -30,4 +30,4 @@ datasources:
       serviceMap:
         datasourceUid: prometheus
       streamingEnabled:
-        search: true
+        search: true

packages/deployment/docker/monitoring/otel-collector/otel-collector.yaml

@@ -13,4 +13,4 @@ service:
   pipelines:
     traces:
       receivers: [otlp]
-      exporters: [otlp]
+      exporters: [otlp]

packages/deployment/docker/monitoring/promtail/promtail.yaml

@@ -17,10 +17,10 @@ scrape_configs:
           - name: label
             values: ["logging=promtail"]
     relabel_configs:
-      - source_labels: ['__meta_docker_container_name']
-        regex: '/(.*)'
-        target_label: 'container'
-      - source_labels: ['__meta_docker_container_log_stream']
-        target_label: 'logstream'
-      - source_labels: ['__meta_docker_container_label_logging_jobname']
-        target_label: 'job'
+      - source_labels: ["__meta_docker_container_name"]
+        regex: "/(.*)"
+        target_label: "container"
+      - source_labels: ["__meta_docker_container_log_stream"]
+        target_label: "logstream"
+      - source_labels: ["__meta_docker_container_label_logging_jobname"]
+        target_label: "job"

packages/deployment/docker/monitoring/tempo/tempo.yaml

@@ -1,4 +1,3 @@
-
 stream_over_http_enabled: true
 server:
   http_listen_port: 3200
@@ -22,11 +21,11 @@ distributor:
           endpoint: "tempo:4317"
 
 ingester:
-  max_block_duration: 5m               # cut the headblock when this much time passes. this is being set for demo purposes and should probably be left alone normally
+  max_block_duration: 5m # cut the headblock when this much time passes. this is being set for demo purposes and should probably be left alone normally
 
 compactor:
   compaction:
-    block_retention: 1h                # overall Tempo trace retention. set for demo purposes
+    block_retention: 1h # overall Tempo trace retention. set for demo purposes
 
 metrics_generator:
   registry:
@@ -43,9 +42,9 @@ metrics_generator:
 
 storage:
   trace:
-    backend: local                     # backend configuration to use
+    backend: local # backend configuration to use
     wal:
-      path: /var/tempo/wal             # where to store the wal locally
+      path: /var/tempo/wal # where to store the wal locally
     local:
       path: /var/tempo/blocks
 

packages/module/src/factories/MethodIdFactory.ts

@@ -1,9 +1,9 @@
-import { DependencyFactory, DependencyRecord } from "@proto-kit/common";
+import { DependencyRecord } from "@proto-kit/common";
 
 import { MethodIdResolver } from "../runtime/MethodIdResolver";
 
-export class MethodIdFactory implements DependencyFactory {
-  public dependencies() {
+export class MethodIdFactory {
+  public static dependencies() {
     return {
       methodIdResolver: {
         useClass: MethodIdResolver,

packages/module/src/runtime/Runtime.ts

@@ -303,7 +303,7 @@ export class Runtime<Modules extends RuntimeModulesRecord>
   public create(childContainerProvider: ChildContainerProvider) {
     super.create(childContainerProvider);
 
-    this.useDependencyFactory(this.container.resolve(MethodIdFactory));
+    this.useDependencyFactory(MethodIdFactory);
   }
 
   public get areProofsEnabled(): AreProofsEnabled | undefined {

packages/persistance/src/PrismaDatabaseConnection.ts

@@ -58,7 +58,7 @@ export class PrismaDatabaseConnection
   > {
     return {
       asyncStateService: {
-        useFactory: () => new PrismaStateService(this, "batch", this.tracer),
+        useFactory: () => new PrismaStateService(this, this.tracer, "batch"),
       },
       batchStorage: {
         useClass: PrismaBatchStore,
@@ -70,7 +70,7 @@ export class PrismaDatabaseConnection
         useClass: PrismaBlockStorage,
       },
       unprovenStateService: {
-        useFactory: () => new PrismaStateService(this, "block", this.tracer),
+        useFactory: () => new PrismaStateService(this, this.tracer, "block"),
       },
       settlementStorage: {
         useClass: PrismaSettlementStorage,

packages/persistance/src/PrismaRedisDatabase.ts

@@ -9,6 +9,7 @@ import {
 import { ChildContainerProvider } from "@proto-kit/common";
 import { PrismaClient } from "@prisma/client";
 import { RedisClientType } from "redis";
+import { inject } from "tsyringe";
 
 import {
   PrismaConnection,
@@ -21,7 +22,6 @@ import {
   RedisConnectionModule,
   RedisTransaction,
 } from "./RedisConnection";
-import { inject } from "tsyringe";
 
 export interface PrismaRedisCombinedConfig {
   prisma: PrismaDatabaseConfig;

packages/persistance/src/services/prisma/PrismaStateService.ts

@@ -28,8 +28,8 @@ export class PrismaStateService implements AsyncStateService {
    */
   public constructor(
     private readonly connection: PrismaConnection,
-    private readonly mask: string,
-    public readonly tracer: Tracer
+    public readonly tracer: Tracer,
+    private readonly mask: string
   ) {}
 
   @trace("db.state.commit")

packages/persistance/src/services/prisma/mappers/EventMapper.ts

@@ -4,45 +4,53 @@ import { Field } from "o1js";
 
 import { ObjectMapper } from "../../../ObjectMapper";
 
+type EventData = {
+  eventName: string;
+  data: Field[];
+  source: "afterTxHook" | "beforeTxHook" | "runtime";
+};
+
 @singleton()
-export class EventMapper
-  implements
-    ObjectMapper<{ eventName: string; data: Field[] }, Prisma.JsonObject>
-{
-  public mapIn(input: Prisma.JsonObject): { eventName: string; data: Field[] } {
-    if (input === undefined) return { eventName: "", data: [] };
+export class EventMapper implements ObjectMapper<EventData, Prisma.JsonObject> {
+  public mapIn(input: Prisma.JsonObject): EventData {
     return {
       eventName: input.eventName as string,
       data: (input.data as Prisma.JsonArray).map((field) =>
         Field.fromJSON(field as string)
       ),
+      source: this.sourceConvert(input.source as string),
     };
   }
 
-  public mapOut(input: {
-    eventName: string;
-    data: Field[];
-  }): Prisma.JsonObject {
+  public mapOut(input: EventData): Prisma.JsonObject {
     return {
       eventName: input.eventName,
       data: input.data.map((field) => field.toString()),
+      source: input.source,
     } as Prisma.JsonObject;
   }
+
+  private sourceConvert(input: string) {
+    if (
+      input === "beforeTxHook" ||
+      input === "afterTxHook" ||
+      input === "runtime"
+    ) {
+      return input;
+    }
+    throw new Error(
+      "Event Source must be one of 'beforeTxHook', 'afterTxHook' or 'runtime'"
+    );
+  }
 }
 
 @singleton()
 export class EventArrayMapper
-  implements
-    ObjectMapper<
-      { eventName: string; data: Field[] }[],
-      Prisma.JsonValue | undefined
-    >
+  implements ObjectMapper<EventData[], Prisma.JsonValue | undefined>
 {
   public constructor(private readonly eventMapper: EventMapper) {}
 
-  public mapIn(
-    input: Prisma.JsonValue | undefined
-  ): { eventName: string; data: Field[] }[] {
+  public mapIn(input: Prisma.JsonValue | undefined): EventData[] {
     if (input === undefined) return [];
 
     if (Array.isArray(input)) {
@@ -53,9 +61,7 @@ export class EventArrayMapper
     return [];
   }
 
-  public mapOut(
-    input: { eventName: string; data: Field[] }[]
-  ): Prisma.JsonValue {
+  public mapOut(input: EventData[]): Prisma.JsonValue {
     return input.map((event) =>
       this.eventMapper.mapOut(event)
     ) as Prisma.JsonArray;

packages/persistance/test/connection.test.ts

@@ -1,7 +1,7 @@
 import "reflect-metadata";
 import { describe } from "@jest/globals";
 import { Field } from "o1js";
-import { CachedMerkleTreeStore } from "@proto-kit/sequencer";
+import { CachedMerkleTreeStore, ConsoleTracer } from "@proto-kit/sequencer";
 import { expectDefined, RollupMerkleTree } from "@proto-kit/common";
 
 import {
@@ -14,15 +14,17 @@ import {
 // TODO Pull apart and test properly
 // Needs redis instance
 describe.skip("prisma", () => {
+  const tracer = new ConsoleTracer();
+
   it("merkle store", async () => {
-    const db = new RedisConnectionModule();
+    const db = new RedisConnectionModule(tracer);
     db.config = {
       host: "localhost",
       port: 6379,
       password: "password",
     };
     await db.start();
-    const store = new RedisMerkleTreeStore(db);
+    const store = new RedisMerkleTreeStore(db, tracer);
 
     const cached = new CachedMerkleTreeStore(store);
     const tree = new RollupMerkleTree(cached);
@@ -38,7 +40,7 @@ describe.skip("prisma", () => {
 
     console.log(`Root ${tree.getRoot().toBigInt()}`);
 
-    const store2 = new RedisMerkleTreeStore(db);
+    const store2 = new RedisMerkleTreeStore(db, tracer);
 
     const cached2 = new CachedMerkleTreeStore(store2);
     const tree2 = new RollupMerkleTree(cached2);
@@ -57,10 +59,10 @@ describe.skip("prisma", () => {
   });
 
   it("fill and get", async () => {
-    const db = new PrismaDatabaseConnection();
+    const db = new PrismaDatabaseConnection(tracer);
     db.config = {};
     await db.start();
-    const service = new PrismaStateService(db, "testMask");
+    const service = new PrismaStateService(db, tracer, "testMask");
 
     await service.openTransaction();
     service.writeStates([

packages/sdk/src/appChain/AppChain.ts

@@ -313,9 +313,9 @@ export class AppChain<
   ) {
     this.create(() => dependencyContainer);
 
-    this.useDependencyFactory(this.container.resolve(AreProofsEnabledFactory));
-    this.useDependencyFactory(this.container.resolve(SharedDependencyFactory));
-    this.useDependencyFactory(this.container.resolve(ConsoleLoggingFactory));
+    this.useDependencyFactory(AreProofsEnabledFactory);
+    this.useDependencyFactory(SharedDependencyFactory);
+    this.useDependencyFactory(ConsoleLoggingFactory);
 
     this.container
       .resolve<AreProofsEnabled>("AreProofsEnabled")

packages/sdk/src/appChain/AreProofsEnabledFactory.ts

@@ -1,9 +1,5 @@
 import { injectable } from "tsyringe";
-import {
-  AreProofsEnabled,
-  DependencyFactory,
-  DependencyRecord,
-} from "@proto-kit/common";
+import { AreProofsEnabled, DependencyRecord } from "@proto-kit/common";
 
 @injectable()
 export class InMemoryAreProofsEnabled implements AreProofsEnabled {
@@ -18,8 +14,8 @@ export class InMemoryAreProofsEnabled implements AreProofsEnabled {
   }
 }
 
-export class AreProofsEnabledFactory implements DependencyFactory {
-  public dependencies() {
+export class AreProofsEnabledFactory {
+  public static dependencies() {
     return {
       areProofsEnabled: {
         useClass: InMemoryAreProofsEnabled,