Merge pull request #7901 from devbugging/gregor/callbacks/metrics

[Scheduled Callbacks] Add scheduled transaction metrics

Author: j1010001

engine/execution/computation/computer/computer.go

@@ -650,6 +650,21 @@ func (e *blockComputer) executeProcessCallback(
 		return nil, 0, err
 	}
 
+	if len(callbackTxs) > 0 {
+		// calculate total computation limits for execute callback transactions
+		var totalExecuteComputationLimits uint64
+		for _, tx := range callbackTxs {
+			totalExecuteComputationLimits += tx.GasLimit
+		}
+
+		// report metrics for callbacks executed
+		e.metrics.ExecutionCallbacksExecuted(
+			len(callbackTxs),
+			txn.Output().ComputationUsed,
+			totalExecuteComputationLimits,
+		)
+	}
+
 	return callbackTxs, txnIndex, nil
 }
 

engine/execution/computation/computer/computer_test.go

@@ -1529,6 +1529,16 @@ func testScheduledCallbackWithError(t *testing.T, chain flow.Chain, callbackEven
 		Return(nil).
 		Times(1)
 
+	// expect callback execution metrics if there are callbacks
+	if len(callbackEvents) > 0 {
+		exemetrics.On("ExecutionCallbacksExecuted",
+			mock.Anything,
+			mock.Anything,
+			mock.Anything).
+			Return(nil).
+			Times(1)
+	}
+
 	bservice := requesterunit.MockBlobService(blockstore.NewBlockstore(dssync.MutexWrap(datastore.NewMapDatastore())))
 	trackerStorage := mocktracker.NewMockStorage()
 

module/metrics.go

@@ -1027,6 +1027,9 @@ type ExecutionMetrics interface {
 	// ExecutionScriptExecuted reports the time and memory spent on executing an script
 	ExecutionScriptExecuted(dur time.Duration, compUsed, memoryUsed, memoryEstimate uint64)
 
+	// ExecutionCallbacksExecuted reports the number of callbacks executed, computation used by process transaction, and total computation limits for execute transactions
+	ExecutionCallbacksExecuted(callbackCount int, processComputationUsed, executeComputationLimits uint64)
+
 	// ExecutionCollectionRequestSent reports when a request for a collection is sent to a collection node
 	ExecutionCollectionRequestSent()
 

module/metrics/execution.go

@@ -98,6 +98,10 @@ type ExecutionCollector struct {
 	evmTransactionGasUsed                   prometheus.Histogram
 	evmBlockTxCount                         prometheus.Histogram
 	evmBlockGasUsed                         prometheus.Histogram
+	callbacksExecutedCount                  prometheus.Histogram
+	callbacksExecutedTotal                  prometheus.Counter
+	callbacksProcessComputationUsed         prometheus.Histogram
+	callbacksExecuteComputationLimits       prometheus.Histogram
 }
 
 func NewExecutionCollector(tracer module.Tracer) *ExecutionCollector {
@@ -793,6 +797,37 @@ func NewExecutionCollector(tracer module.Tracer) *ExecutionCollector {
 			Name:      "evm_block_total_supply",
 			Help:      "the total amount of flow deposited to EVM (in FLOW)",
 		}),
+
+		callbacksExecutedCount: promauto.NewHistogram(prometheus.HistogramOpts{
+			Namespace: namespaceExecution,
+			Subsystem: subsystemRuntime,
+			Name:      "callbacks_executed_count",
+			Help:      "the number of callbacks executed",
+			Buckets:   prometheus.ExponentialBuckets(1, 2, 8),
+		}),
+
+		callbacksExecutedTotal: promauto.NewCounter(prometheus.CounterOpts{
+			Namespace: namespaceExecution,
+			Subsystem: subsystemRuntime,
+			Name:      "callbacks_executed_total",
+			Help:      "the total number of callbacks executed",
+		}),
+
+		callbacksProcessComputationUsed: promauto.NewHistogram(prometheus.HistogramOpts{
+			Namespace: namespaceExecution,
+			Subsystem: subsystemRuntime,
+			Name:      "callbacks_process_computation_used",
+			Help:      "the computation used by the process callback transaction",
+			Buckets:   prometheus.ExponentialBuckets(10_000, 2, 12),
+		}),
+
+		callbacksExecuteComputationLimits: promauto.NewHistogram(prometheus.HistogramOpts{
+			Namespace: namespaceExecution,
+			Subsystem: subsystemRuntime,
+			Name:      "callbacks_execute_computation_limits",
+			Help:      "the total computation limits for execute callback transactions",
+			Buckets:   prometheus.ExponentialBuckets(10_000, 2, 12),
+		}),
 	}
 
 	return ec
@@ -883,6 +918,14 @@ func (ec *ExecutionCollector) ExecutionScriptExecuted(dur time.Duration, compUse
 	ec.scriptMemoryDifference.Observe(float64(memoryEstimated) - float64(memoryUsed))
 }
 
+// ExecutionCallbacksExecuted reports callback execution metrics
+func (ec *ExecutionCollector) ExecutionCallbacksExecuted(callbackCount int, processComputationUsed, executeComputationLimits uint64) {
+	ec.callbacksExecutedCount.Observe(float64(callbackCount))
+	ec.callbacksExecutedTotal.Add(float64(callbackCount))
+	ec.callbacksProcessComputationUsed.Observe(float64(processComputationUsed))
+	ec.callbacksExecuteComputationLimits.Observe(float64(executeComputationLimits))
+}
+
 // ExecutionStateStorageDiskTotal reports the total storage size of the execution state on disk in bytes
 func (ec *ExecutionCollector) ExecutionStateStorageDiskTotal(bytes int64) {
 	ec.stateStorageDiskTotal.Set(float64(bytes))

module/metrics/noop.go

@@ -181,6 +181,7 @@ func (nc *NoopCollector) ExecutionTransactionExecuted(_ time.Duration, _ module.
 }
 func (nc *NoopCollector) ExecutionChunkDataPackGenerated(_, _ int)                              {}
 func (nc *NoopCollector) ExecutionScriptExecuted(dur time.Duration, compUsed, _, _ uint64)      {}
+func (nc *NoopCollector) ExecutionCallbacksExecuted(int, uint64, uint64)                        {}
 func (nc *NoopCollector) ForestApproxMemorySize(bytes uint64)                                   {}
 func (nc *NoopCollector) ForestNumberOfTrees(number uint64)                                     {}
 func (nc *NoopCollector) LatestTrieRegCount(number uint64)                                      {}