@sentio/runtime 2.43.3-rc.3 → 2.44.0-rc.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentio/runtime",
-  "version": "2.43.3-rc.3",
+  "version": "2.44.0-rc.10",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {

package/src/gen/processor/protos/processor.ts

@@ -213,6 +213,7 @@ export enum HandlerType {
   COSMOS_CALL = 14,
   STARKNET_EVENT = 15,
   BTC_TRANSACTION = 16,
+  BTC_BLOCK = 18,
   UNRECOGNIZED = -1,
 }
 
@@ -272,6 +273,9 @@ export function handlerTypeFromJSON(object: any): HandlerType {
     case 16:
     case "BTC_TRANSACTION":
       return HandlerType.BTC_TRANSACTION;
+    case 18:
+    case "BTC_BLOCK":
+      return HandlerType.BTC_BLOCK;
     case -1:
     case "UNRECOGNIZED":
     default:
@@ -317,6 +321,8 @@ export function handlerTypeToJSON(object: HandlerType): string {
       return "STARKNET_EVENT";
     case HandlerType.BTC_TRANSACTION:
       return "BTC_TRANSACTION";
+    case HandlerType.BTC_BLOCK:
+      return "BTC_BLOCK";
     case HandlerType.UNRECOGNIZED:
     default:
       return "UNRECOGNIZED";
@@ -1032,6 +1038,7 @@ export interface Data {
   cosmosCall?: Data_CosmosCall | undefined;
   starknetEvents?: Data_StarknetEvent | undefined;
   btcTransaction?: Data_BTCTransaction | undefined;
+  btcBlock?: Data_BTCBlock | undefined;
 }
 
 export interface Data_EthLog {
@@ -1135,6 +1142,11 @@ export interface Data_BTCTransaction {
   timestamp: Date | undefined;
 }
 
+export interface Data_BTCBlock {
+  block: { [key: string]: any } | undefined;
+  timestamp: Date | undefined;
+}
+
 export interface DataBinding {
   data: Data | undefined;
   handlerType: HandlerType;
@@ -8349,6 +8361,7 @@ function createBaseData(): Data {
     cosmosCall: undefined,
     starknetEvents: undefined,
     btcTransaction: undefined,
+    btcBlock: undefined,
   };
 }
 
@@ -8408,6 +8421,9 @@ export const Data = {
     if (message.btcTransaction !== undefined) {
       Data_BTCTransaction.encode(message.btcTransaction, writer.uint32(138).fork()).ldelim();
     }
+    if (message.btcBlock !== undefined) {
+      Data_BTCBlock.encode(message.btcBlock, writer.uint32(154).fork()).ldelim();
+    }
     return writer;
   },
 
@@ -8544,6 +8560,13 @@ export const Data = {
 
           message.btcTransaction = Data_BTCTransaction.decode(reader, reader.uint32());
           continue;
+        case 19:
+          if (tag !== 154) {
+            break;
+          }
+
+          message.btcBlock = Data_BTCBlock.decode(reader, reader.uint32());
+          continue;
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -8575,6 +8598,7 @@ export const Data = {
       cosmosCall: isSet(object.cosmosCall) ? Data_CosmosCall.fromJSON(object.cosmosCall) : undefined,
       starknetEvents: isSet(object.starknetEvents) ? Data_StarknetEvent.fromJSON(object.starknetEvents) : undefined,
       btcTransaction: isSet(object.btcTransaction) ? Data_BTCTransaction.fromJSON(object.btcTransaction) : undefined,
+      btcBlock: isSet(object.btcBlock) ? Data_BTCBlock.fromJSON(object.btcBlock) : undefined,
     };
   },
 
@@ -8634,6 +8658,9 @@ export const Data = {
     if (message.btcTransaction !== undefined) {
       obj.btcTransaction = Data_BTCTransaction.toJSON(message.btcTransaction);
     }
+    if (message.btcBlock !== undefined) {
+      obj.btcBlock = Data_BTCBlock.toJSON(message.btcBlock);
+    }
     return obj;
   },
 
@@ -8694,6 +8721,9 @@ export const Data = {
     message.btcTransaction = (object.btcTransaction !== undefined && object.btcTransaction !== null)
       ? Data_BTCTransaction.fromPartial(object.btcTransaction)
       : undefined;
+    message.btcBlock = (object.btcBlock !== undefined && object.btcBlock !== null)
+      ? Data_BTCBlock.fromPartial(object.btcBlock)
+      : undefined;
     return message;
   },
 };
@@ -10229,6 +10259,80 @@ export const Data_BTCTransaction = {
   },
 };
 
+function createBaseData_BTCBlock(): Data_BTCBlock {
+  return { block: undefined, timestamp: undefined };
+}
+
+export const Data_BTCBlock = {
+  encode(message: Data_BTCBlock, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.block !== undefined) {
+      Struct.encode(Struct.wrap(message.block), writer.uint32(10).fork()).ldelim();
+    }
+    if (message.timestamp !== undefined) {
+      Timestamp.encode(toTimestamp(message.timestamp), writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Data_BTCBlock {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseData_BTCBlock();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.block = Struct.unwrap(Struct.decode(reader, reader.uint32()));
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.timestamp = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Data_BTCBlock {
+    return {
+      block: isObject(object.block) ? object.block : undefined,
+      timestamp: isSet(object.timestamp) ? fromJsonTimestamp(object.timestamp) : undefined,
+    };
+  },
+
+  toJSON(message: Data_BTCBlock): unknown {
+    const obj: any = {};
+    if (message.block !== undefined) {
+      obj.block = message.block;
+    }
+    if (message.timestamp !== undefined) {
+      obj.timestamp = message.timestamp.toISOString();
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<Data_BTCBlock>): Data_BTCBlock {
+    return Data_BTCBlock.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<Data_BTCBlock>): Data_BTCBlock {
+    const message = createBaseData_BTCBlock();
+    message.block = object.block ?? undefined;
+    message.timestamp = object.timestamp ?? undefined;
+    return message;
+  },
+};
+
 function createBaseDataBinding(): DataBinding {
   return { data: undefined, handlerType: 0, handlerIds: [] };
 }

package/src/metrics.ts

@@ -1,13 +1,18 @@
 import { Attributes, Counter, metrics, Gauge } from '@opentelemetry/api'
 
-const meter = metrics.getMeter('processor')
+const getMeter = () => metrics.getMeter('processor')
 
 class C {
-  private counter: Counter<Attributes>
+  private _counter: Counter<Attributes>
   private value: number = 0
 
-  constructor(name: string) {
-    this.counter = meter.createCounter(name)
+  constructor(private name: string) {}
+
+  get counter(): Counter<Attributes> {
+    if (!this._counter) {
+      this._counter = getMeter().createCounter(this.name)
+    }
+    return this._counter
   }
 
   add(value: number, attributes?: Attributes) {
@@ -21,11 +26,16 @@ class C {
 }
 
 class G {
-  private gauge: Gauge<Attributes>
+  private _gauge: Gauge<Attributes>
   private value: number = 0
 
-  constructor(name: string) {
-    this.gauge = meter.createGauge(name)
+  constructor(private name: string) {}
+
+  get gauge(): Gauge<Attributes> {
+    if (!this._gauge) {
+      this._gauge = getMeter().createGauge(this.name)
+    }
+    return this._gauge
   }
 
   record(value: number, attributes?: Attributes) {

package/src/otlp.ts

@@ -5,9 +5,13 @@ import { PrometheusExporter } from '@opentelemetry/exporter-prometheus'
 import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'
 import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-grpc'
 import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base'
-import { metrics, trace, ProxyTracerProvider } from '@opentelemetry/api'
+import { diag, DiagConsoleLogger, DiagLogLevel, metrics, trace, ProxyTracerProvider } from '@opentelemetry/api'
+
+export async function setupOTLP(debug?: boolean) {
+  if (debug) {
+    diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.DEBUG)
+  }
 
-export async function setupOTLP() {
   const resource = await envDetector.detect()
 
   const meterProvider = new MeterProvider({
@@ -29,12 +33,15 @@ export async function setupOTLP() {
   const exporter = new OTLPTraceExporter() // new ConsoleSpanExporter();
   const processor = new BatchSpanProcessor(exporter)
   traceProvider.addSpanProcessor(processor)
+  traceProvider.register()
 
   metrics.setGlobalMeterProvider(meterProvider)
   trace.setGlobalTracerProvider(traceProvider)
   ;['SIGINT', 'SIGTERM'].forEach((signal) => {
     process.on(signal as any, () => shutdownProvider())
   })
+
+  metrics.getMeter('processor').createGauge('up').record(1)
 }
 
 export async function shutdownProvider() {

package/src/processor-runner.ts

@@ -21,15 +21,7 @@ import { FullProcessorServiceImpl } from './full-service.js'
 import { ChainConfig } from './chain-config.js'
 import { setupLogger } from './logger.js'
 
-// import { NodeSDK } from '@opentelemetry/sdk-node'
-import { envDetector } from '@opentelemetry/resources'
-import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-grpc'
-import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-grpc'
-import { PeriodicExportingMetricReader, MeterProvider } from '@opentelemetry/sdk-metrics'
-import { BatchSpanProcessor } from '@opentelemetry/sdk-trace-base'
-import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node'
-import { diag, DiagConsoleLogger, DiagLogLevel, metrics, trace } from '@opentelemetry/api'
-import { PrometheusExporter } from '@opentelemetry/exporter-prometheus'
+import { setupOTLP } from './otlp.js'
 
 // const mergedRegistry = Registry.merge([globalRegistry, niceGrpcRegistry])
 
@@ -58,51 +50,7 @@ const logLevel = process.env['LOG_LEVEL']?.toUpperCase()
 setupLogger(options['log-format'] === 'json', logLevel === 'debug' ? true : options.debug)
 console.debug('Starting with', options.target)
 
-if (options.debug) {
-  diag.setLogger(new DiagConsoleLogger(), DiagLogLevel.DEBUG)
-}
-
-const resource = await envDetector.detect()
-
-const meterProvider = new MeterProvider({
-  resource,
-  readers: [
-    new PeriodicExportingMetricReader({
-      exporter: new OTLPMetricExporter()
-    }),
-    new PrometheusExporter({
-      // http://localhost:4041/metrics
-      port: 4041
-    })
-  ]
-})
-
-const traceProvider = new NodeTracerProvider({
-  resource: resource
-})
-const exporter = new OTLPTraceExporter() // new ConsoleSpanExporter();
-const processor = new BatchSpanProcessor(exporter)
-traceProvider.addSpanProcessor(processor)
-traceProvider.register()
-
-metrics.setGlobalMeterProvider(meterProvider)
-trace.setGlobalTracerProvider(traceProvider)
-;['SIGINT', 'SIGTERM'].forEach((signal) => {
-  process.on(signal as any, () => shutdownProvider())
-})
-
-export async function shutdownProvider() {
-  const traceProvider = trace.getTracerProvider()
-  if (traceProvider instanceof NodeTracerProvider) {
-    traceProvider.shutdown().catch(console.error)
-  }
-  const meterProvider = metrics.getMeterProvider()
-  if (meterProvider instanceof MeterProvider) {
-    meterProvider.shutdown().catch(console.error)
-  }
-}
-
-metrics.getMeter('processor').createGauge('up').record(1)
+await setupOTLP(options.debug)
 
 Error.stackTraceLimit = 20
 

package/src/state.ts

@@ -29,6 +29,12 @@ export abstract class StateStorage<T> {
     }
     return metricState
   }
+
+  unregister(): T {
+    const value = State.INSTANCE.stateMap.get(this.key())
+    State.INSTANCE.stateMap.delete(this.key())
+    return value
+  }
 }
 
 export abstract class MapStateStorage<T> extends StateStorage<Map<string, T>> {