From b4124f574828feb9c7ab654da52fcea0887cbcfd Mon Sep 17 00:00:00 2001 From: mpetrun5 Date: Fri, 11 Oct 2024 15:35:21 +0200 Subject: [PATCH 01/14] Add basic system metrics --- observability/metrics.go | 12 +++++++++++- observability/metrics/system.go | 31 +++++++++++++++++++++++++++++++ 2 files changed, 42 insertions(+), 1 deletion(-) create mode 100644 observability/metrics/system.go diff --git a/observability/metrics.go b/observability/metrics.go index 1b6e25c2..a38407c9 100644 --- a/observability/metrics.go +++ b/observability/metrics.go @@ -7,6 +7,7 @@ import ( "sync" "time" + "github.com/sygmaprotocol/sygma-core/observability/metrics" "go.opentelemetry.io/otel/attribute" "go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetrichttp" "go.opentelemetry.io/otel/metric" @@ -58,6 +59,8 @@ func InitMetricProvider(ctx context.Context, agentURL string) (*sdkmetric.MeterP } type RelayerMetrics struct { + *metrics.SystemMetrics + meter metric.Meter Opts api.MeasurementOption @@ -77,7 +80,7 @@ func NewRelayerMetrics(meter metric.Meter, attributes ...attribute.KeyValue) (*R opts := api.WithAttributes(attributes...) blockDeltaMap := make(map[uint8]*big.Int) - blockDeltaGauge, err := meter.Int64ObservableGauge( + blockDeltaGauge, _ := meter.Int64ObservableGauge( "relayer.BlockDelta", metric.WithInt64Callback(func(context context.Context, result metric.Int64Observer) error { for domainID, delta := range blockDeltaMap { @@ -90,7 +93,14 @@ func NewRelayerMetrics(meter metric.Meter, attributes ...attribute.KeyValue) (*R }), metric.WithDescription("Difference between chain head and current indexed block per domain"), ) + + systemMetrics, err := metrics.NewSystemMetrics(meter, opts) + if err != nil { + return nil, err + } + return &RelayerMetrics{ + SystemMetrics: systemMetrics, meter: meter, MessageEventTime: make(map[string]time.Time), Opts: opts, diff --git a/observability/metrics/system.go b/observability/metrics/system.go new file mode 100644 index 00000000..bd70e60b --- /dev/null +++ b/observability/metrics/system.go @@ -0,0 +1,31 @@ +package metrics + +import ( + "context" + "runtime" + + "go.opentelemetry.io/otel/metric" +) + +type SystemMetrics struct { + goRoutinesGauge metric.Int64ObservableGauge +} + +// NewSystemMetrics initializes system performance and resource utilization metrics +func NewSystemMetrics(meter metric.Meter, opts metric.MeasurementOption) (*SystemMetrics, error) { + goRoutinesGauge, err := meter.Int64ObservableGauge( + "relayer.GoRoutines", + metric.WithInt64Callback(func(context context.Context, result metric.Int64Observer) error { + result.Observe(int64(runtime.NumGoroutine()), opts) + return nil + }), + metric.WithDescription("Number of Go routines running."), + ) + if err != nil { + return nil, err + } + + return &SystemMetrics{ + goRoutinesGauge: goRoutinesGauge, + }, err +} From 2d3acf2c1f31f2232ce9498c98853cf2375e8c6c Mon Sep 17 00:00:00 2001 From: mpetrun5 Date: Fri, 11 Oct 2024 16:29:30 +0200 Subject: [PATCH 02/14] Add garbage cycle duration histogram --- observability/metrics/system.go | 23 +++++++++++++++++++++-- 1 file changed, 21 insertions(+), 2 deletions(-) diff --git a/observability/metrics/system.go b/observability/metrics/system.go index bd70e60b..04d3a2d9 100644 --- a/observability/metrics/system.go +++ b/observability/metrics/system.go @@ -3,12 +3,14 @@ package metrics import ( "context" "runtime" + "runtime/debug" "go.opentelemetry.io/otel/metric" ) type SystemMetrics struct { - goRoutinesGauge metric.Int64ObservableGauge + goRoutinesGauge metric.Int64ObservableGauge + gcDurationHistogram metric.Float64Histogram } // NewSystemMetrics initializes system performance and resource utilization metrics @@ -25,7 +27,24 @@ func NewSystemMetrics(meter metric.Meter, opts metric.MeasurementOption) (*Syste return nil, err } + gcDurationHistogram, err := meter.Float64Histogram( + "relayer.GcDurationSeconds", + metric.WithFloat64Callback(func(context context.Context, result metric.Float64Observer) error { + var gcStats debug.GCStats + debug.ReadGCStats(&gcStats) + if len(gcStats.Pause) > 0 { + recentPauseDuration := gcStats.Pause[0].Seconds() + result.Observe(recentPauseDuration, opts) + } + }), + metric.WithDescription("Duration of garbage collection cycles."), + ) + if err != nil { + return nil, err + } + return &SystemMetrics{ - goRoutinesGauge: goRoutinesGauge, + goRoutinesGauge: goRoutinesGauge, + gcDurationHistogram: gcDurationHistogram, }, err } From 96d646c7b287f5da6179e253dff7bc87dfb5adad Mon Sep 17 00:00:00 2001 From: mpetrun5 Date: Fri, 11 Oct 2024 16:45:10 +0200 Subject: [PATCH 03/14] Fix histogram callback --- observability/metrics/system.go | 20 ++++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/observability/metrics/system.go b/observability/metrics/system.go index 04d3a2d9..275014d8 100644 --- a/observability/metrics/system.go +++ b/observability/metrics/system.go @@ -2,6 +2,7 @@ package metrics import ( "context" + "fmt" "runtime" "runtime/debug" @@ -29,19 +30,22 @@ func NewSystemMetrics(meter metric.Meter, opts metric.MeasurementOption) (*Syste gcDurationHistogram, err := meter.Float64Histogram( "relayer.GcDurationSeconds", - metric.WithFloat64Callback(func(context context.Context, result metric.Float64Observer) error { - var gcStats debug.GCStats - debug.ReadGCStats(&gcStats) - if len(gcStats.Pause) > 0 { - recentPauseDuration := gcStats.Pause[0].Seconds() - result.Observe(recentPauseDuration, opts) - } - }), metric.WithDescription("Duration of garbage collection cycles."), ) if err != nil { return nil, err } + meter.RegisterCallback(func(ctx context.Context, result metric.Observer) error { + fmt.Println("CALLING CALLBACK") + + var gcStats debug.GCStats + debug.ReadGCStats(&gcStats) + if len(gcStats.Pause) > 0 { + recentPauseDuration := gcStats.Pause[0].Seconds() + gcDurationHistogram.Record(context.Background(), recentPauseDuration, opts) + } + return nil + }) return &SystemMetrics{ goRoutinesGauge: goRoutinesGauge, From 6409b739a2030b32b04341dc115390d9329f4225 Mon Sep 17 00:00:00 2001 From: mpetrun5 Date: Fri, 11 Oct 2024 17:25:00 +0200 Subject: [PATCH 04/14] Implement cpu, mem and network gauges --- go.mod | 2 +- observability/metrics/system.go | 165 +++++++++++++++++++++++++++++--- 2 files changed, 154 insertions(+), 13 deletions(-) diff --git a/go.mod b/go.mod index a1836255..5fab6f7f 100644 --- a/go.mod +++ b/go.mod @@ -70,7 +70,7 @@ require ( github.com/mitchellh/mapstructure v1.4.2 // indirect github.com/pierrec/xxHash v0.1.5 // indirect github.com/pmezard/go-difflib v1.0.0 // indirect - github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible // indirect + github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible github.com/tklauser/go-sysconf v0.3.12 // indirect github.com/tklauser/numcpus v0.6.1 // indirect go.opentelemetry.io/otel/sdk v1.16.0 diff --git a/observability/metrics/system.go b/observability/metrics/system.go index 275014d8..97a4374e 100644 --- a/observability/metrics/system.go +++ b/observability/metrics/system.go @@ -2,16 +2,29 @@ package metrics import ( "context" - "fmt" "runtime" "runtime/debug" + "time" + "github.com/shirou/gopsutil/cpu" + "github.com/shirou/gopsutil/disk" + "github.com/shirou/gopsutil/mem" + "github.com/shirou/gopsutil/net" "go.opentelemetry.io/otel/metric" ) type SystemMetrics struct { - goRoutinesGauge metric.Int64ObservableGauge - gcDurationHistogram metric.Float64Histogram + opts metric.MeasurementOption + + goRoutinesGauge metric.Int64ObservableGauge + totalMemoryGauge metric.Int64ObservableGauge + usedMemoryGauge metric.Int64ObservableGauge + cpuUsageGauge metric.Float64ObservableGauge + gcDurationHistogram metric.Float64Histogram + diskUsageGauge metric.Int64ObservableGauge + totalDiskGauge metric.Int64ObservableGauge + networkIOReceivedGauge metric.Int64ObservableGauge + networkIOSentGauge metric.Int64ObservableGauge } // NewSystemMetrics initializes system performance and resource utilization metrics @@ -28,6 +41,122 @@ func NewSystemMetrics(meter metric.Meter, opts metric.MeasurementOption) (*Syste return nil, err } + usedMemoryGauge, err := meter.Int64ObservableGauge( + "relayer.MemoryUsageBytes", + metric.WithInt64Callback(func(context context.Context, result metric.Int64Observer) error { + v, err := mem.VirtualMemory() + if err != nil { + return err + } + + result.Observe(int64(v.Used), opts) + return nil + }), + metric.WithDescription("Memory usage in bytes."), + ) + if err != nil { + return nil, err + } + totalMemoryGauge, err := meter.Int64ObservableGauge( + "relayer.FreeMemoryBytes", + metric.WithInt64Callback(func(context context.Context, result metric.Int64Observer) error { + v, err := mem.VirtualMemory() + if err != nil { + return err + } + + result.Observe(int64(v.Total), opts) + return nil + }), + metric.WithDescription("Total memory in bytes."), + ) + if err != nil { + return nil, err + } + + cpuUsageGauge, err := meter.Float64ObservableGauge( + "relayer.CpuUsagePercent", + metric.WithFloat64Callback(func(context context.Context, result metric.Float64Observer) error { + percents, err := cpu.Percent(0, false) + if err != nil { + return err + } + + result.Observe(percents[0], opts) + return nil + }), + metric.WithDescription("CPU usage percent."), + ) + if err != nil { + return nil, err + } + + diskUsageGauge, err := meter.Int64ObservableGauge( + "relayer.DiskUsageBytes", + metric.WithInt64Callback(func(context context.Context, result metric.Int64Observer) error { + usage, err := disk.Usage("/") + if err != nil { + return err + } + + result.Observe(int64(usage.Used), opts) + return nil + }), + metric.WithDescription("Disk space used by the relayer in bytes."), + ) + if err != nil { + return nil, err + } + totalDiskGauge, err := meter.Int64ObservableGauge( + "relayer.TotalDiskBytes", + metric.WithInt64Callback(func(context context.Context, result metric.Int64Observer) error { + usage, err := disk.Usage("/") + if err != nil { + return err + } + + result.Observe(int64(usage.Total), opts) + return nil + }), + metric.WithDescription("Total relayer disk space."), + ) + if err != nil { + return nil, err + } + + networkIOReceivedGauge, err := meter.Int64ObservableGauge( + "relayer.NetworkIOBytesReceived", + metric.WithInt64Callback(func(context context.Context, result metric.Int64Observer) error { + stat, err := net.IOCounters(false) + if err != nil { + return err + } + + result.Observe(int64(stat[0].BytesRecv), opts) + return nil + }), + metric.WithDescription("Total network bytes received."), + ) + if err != nil { + return nil, err + } + networkIOSentGauge, err := meter.Int64ObservableGauge( + "relayer.NetworkIOBytesSent", + metric.WithInt64Callback(func(context context.Context, result metric.Int64Observer) error { + stat, err := net.IOCounters(false) + if err != nil { + return err + } + + result.Observe(int64(stat[0].BytesSent), opts) + return nil + }), + metric.WithDescription("Total network bytes sent."), + ) + if err != nil { + return nil, err + } + gcDurationHistogram, err := meter.Float64Histogram( "relayer.GcDurationSeconds", metric.WithDescription("Duration of garbage collection cycles."), @@ -35,20 +164,32 @@ func NewSystemMetrics(meter metric.Meter, opts metric.MeasurementOption) (*Syste if err != nil { return nil, err } - meter.RegisterCallback(func(ctx context.Context, result metric.Observer) error { - fmt.Println("CALLING CALLBACK") + m := &SystemMetrics{ + opts: opts, + goRoutinesGauge: goRoutinesGauge, + totalMemoryGauge: totalMemoryGauge, + usedMemoryGauge: usedMemoryGauge, + gcDurationHistogram: gcDurationHistogram, + cpuUsageGauge: cpuUsageGauge, + totalDiskGauge: totalDiskGauge, + diskUsageGauge: diskUsageGauge, + networkIOReceivedGauge: networkIOReceivedGauge, + networkIOSentGauge: networkIOSentGauge, + } + go m.update() + return m, err +} + +func (m *SystemMetrics) update() { + for { var gcStats debug.GCStats debug.ReadGCStats(&gcStats) if len(gcStats.Pause) > 0 { recentPauseDuration := gcStats.Pause[0].Seconds() - gcDurationHistogram.Record(context.Background(), recentPauseDuration, opts) + m.gcDurationHistogram.Record(context.Background(), recentPauseDuration, m.opts) } - return nil - }) - return &SystemMetrics{ - goRoutinesGauge: goRoutinesGauge, - gcDurationHistogram: gcDurationHistogram, - }, err + time.Sleep(time.Second * 10) + } } From 9308c620c0ec05912f92f5f8e4aaecb7b7bdd23a Mon Sep 17 00:00:00 2001 From: mpetrun5 Date: Fri, 18 Oct 2024 16:57:03 +0200 Subject: [PATCH 05/14] Fix total memory ticker --- observability/metrics/system.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/observability/metrics/system.go b/observability/metrics/system.go index 97a4374e..6d0e5a9d 100644 --- a/observability/metrics/system.go +++ b/observability/metrics/system.go @@ -58,7 +58,7 @@ func NewSystemMetrics(meter metric.Meter, opts metric.MeasurementOption) (*Syste return nil, err } totalMemoryGauge, err := meter.Int64ObservableGauge( - "relayer.FreeMemoryBytes", + "relayer.TotalMemoryBytes", metric.WithInt64Callback(func(context context.Context, result metric.Int64Observer) error { v, err := mem.VirtualMemory() if err != nil { From 81cfa4e390f1177e8806c5ff483388b2ad4f722b Mon Sep 17 00:00:00 2001 From: mpetrun5 Date: Mon, 21 Oct 2024 15:51:26 +0200 Subject: [PATCH 06/14] Add context to shut down metrics collection gracefully --- observability/metrics.go | 4 ++-- observability/metrics/system.go | 40 ++++++++++++++++++++++++--------- 2 files changed, 32 insertions(+), 12 deletions(-) diff --git a/observability/metrics.go b/observability/metrics.go index a38407c9..afe10b93 100644 --- a/observability/metrics.go +++ b/observability/metrics.go @@ -76,7 +76,7 @@ type RelayerMetrics struct { } // NewRelayerMetrics initializes OpenTelemetry metrics -func NewRelayerMetrics(meter metric.Meter, attributes ...attribute.KeyValue) (*RelayerMetrics, error) { +func NewRelayerMetrics(ctx context.Context, meter metric.Meter, attributes ...attribute.KeyValue) (*RelayerMetrics, error) { opts := api.WithAttributes(attributes...) blockDeltaMap := make(map[uint8]*big.Int) @@ -94,7 +94,7 @@ func NewRelayerMetrics(meter metric.Meter, attributes ...attribute.KeyValue) (*R metric.WithDescription("Difference between chain head and current indexed block per domain"), ) - systemMetrics, err := metrics.NewSystemMetrics(meter, opts) + systemMetrics, err := metrics.NewSystemMetrics(ctx, meter, opts) if err != nil { return nil, err } diff --git a/observability/metrics/system.go b/observability/metrics/system.go index 6d0e5a9d..65208493 100644 --- a/observability/metrics/system.go +++ b/observability/metrics/system.go @@ -13,6 +13,10 @@ import ( "go.opentelemetry.io/otel/metric" ) +const ( + GC_STATS_UPDATE_PERIOD = time.Second * 10 +) + type SystemMetrics struct { opts metric.MeasurementOption @@ -28,7 +32,7 @@ type SystemMetrics struct { } // NewSystemMetrics initializes system performance and resource utilization metrics -func NewSystemMetrics(meter metric.Meter, opts metric.MeasurementOption) (*SystemMetrics, error) { +func NewSystemMetrics(ctx context.Context, meter metric.Meter, opts metric.MeasurementOption) (*SystemMetrics, error) { goRoutinesGauge, err := meter.Int64ObservableGauge( "relayer.GoRoutines", metric.WithInt64Callback(func(context context.Context, result metric.Int64Observer) error { @@ -177,19 +181,35 @@ func NewSystemMetrics(meter metric.Meter, opts metric.MeasurementOption) (*Syste networkIOReceivedGauge: networkIOReceivedGauge, networkIOSentGauge: networkIOSentGauge, } - go m.update() + + go m.updateGCStats(ctx) return m, err } -func (m *SystemMetrics) update() { +func (m *SystemMetrics) updateGCStats(ctx context.Context) { + ticker := time.NewTicker(GC_STATS_UPDATE_PERIOD) + var previousPauseDuration float64 for { - var gcStats debug.GCStats - debug.ReadGCStats(&gcStats) - if len(gcStats.Pause) > 0 { - recentPauseDuration := gcStats.Pause[0].Seconds() - m.gcDurationHistogram.Record(context.Background(), recentPauseDuration, m.opts) - } + select { + case <-ticker.C: + { + var gcStats debug.GCStats + debug.ReadGCStats(&gcStats) + if len(gcStats.Pause) == 0 { + continue + } + + recentPauseDuration := gcStats.Pause[0].Seconds() + if recentPauseDuration == previousPauseDuration { + continue + } + + m.gcDurationHistogram.Record(context.Background(), recentPauseDuration, m.opts) + previousPauseDuration = recentPauseDuration + } + case <-ctx.Done(): + return - time.Sleep(time.Second * 10) + } } } From 4425c96ab075f8157022fff017d51935ea000231 Mon Sep 17 00:00:00 2001 From: mpetrun5 Date: Mon, 21 Oct 2024 17:23:41 +0200 Subject: [PATCH 07/14] Implement chain specific metrics --- observability/metrics.go | 53 ++++------------ observability/metrics/network.go | 100 +++++++++++++++++++++++++++++++ 2 files changed, 110 insertions(+), 43 deletions(-) create mode 100644 observability/metrics/network.go diff --git a/observability/metrics.go b/observability/metrics.go index afe10b93..165e8704 100644 --- a/observability/metrics.go +++ b/observability/metrics.go @@ -2,10 +2,7 @@ package observability import ( "context" - "math/big" "net/url" - "sync" - "time" "github.com/sygmaprotocol/sygma-core/observability/metrics" "go.opentelemetry.io/otel/attribute" @@ -60,58 +57,28 @@ func InitMetricProvider(ctx context.Context, agentURL string) (*sdkmetric.MeterP type RelayerMetrics struct { *metrics.SystemMetrics + *metrics.NetworkMetrics - meter metric.Meter - Opts api.MeasurementOption - - DepositEventCount metric.Int64Counter - MessageEventTime map[string]time.Time - ExecutionErrorCount metric.Int64Counter - ExecutionLatency metric.Int64Histogram - ExecutionLatencyPerRoute metric.Int64Histogram - BlockDelta metric.Int64ObservableGauge - BlockDeltaMap map[uint8]*big.Int - - lock sync.Mutex + Opts api.MeasurementOption } // NewRelayerMetrics initializes OpenTelemetry metrics func NewRelayerMetrics(ctx context.Context, meter metric.Meter, attributes ...attribute.KeyValue) (*RelayerMetrics, error) { opts := api.WithAttributes(attributes...) - blockDeltaMap := make(map[uint8]*big.Int) - blockDeltaGauge, _ := meter.Int64ObservableGauge( - "relayer.BlockDelta", - metric.WithInt64Callback(func(context context.Context, result metric.Int64Observer) error { - for domainID, delta := range blockDeltaMap { - result.Observe(delta.Int64(), - opts, - metric.WithAttributes(attribute.Int64("domainID", int64(domainID))), - ) - } - return nil - }), - metric.WithDescription("Difference between chain head and current indexed block per domain"), - ) - systemMetrics, err := metrics.NewSystemMetrics(ctx, meter, opts) if err != nil { return nil, err } + networkMetrics, err := metrics.NewNetworkMetrics(ctx, meter, opts) + if err != nil { + return nil, err + } + return &RelayerMetrics{ - SystemMetrics: systemMetrics, - meter: meter, - MessageEventTime: make(map[string]time.Time), - Opts: opts, - BlockDelta: blockDeltaGauge, - BlockDeltaMap: blockDeltaMap, + SystemMetrics: systemMetrics, + NetworkMetrics: networkMetrics, + Opts: opts, }, err } - -func (t *RelayerMetrics) TrackBlockDelta(domainID uint8, head *big.Int, current *big.Int) { - t.lock.Lock() - defer t.lock.Unlock() - - t.BlockDeltaMap[domainID] = new(big.Int).Sub(head, current) -} diff --git a/observability/metrics/network.go b/observability/metrics/network.go new file mode 100644 index 00000000..55d0c611 --- /dev/null +++ b/observability/metrics/network.go @@ -0,0 +1,100 @@ +package metrics + +import ( + "context" + "math/big" + "sync" + + "go.opentelemetry.io/otel/attribute" + "go.opentelemetry.io/otel/metric" +) + +type NetworkMetrics struct { + opts metric.MeasurementOption + + blockDeltaGauge metric.Int64ObservableGauge + blockDeltaMap map[uint8]*big.Int + + processedBlockMap map[uint8]*big.Int + processedBlockGauge metric.Int64ObservableGauge + + chainHeadMap map[uint8]*big.Int + chainHeadGauge metric.Int64ObservableGauge + lock sync.Mutex +} + +// NewNetworkMetrics initializes metrics that provide insight into consensus and network activity +func NewNetworkMetrics(ctx context.Context, meter metric.Meter, opts metric.MeasurementOption) (*NetworkMetrics, error) { + blockDeltaMap := make(map[uint8]*big.Int) + blockDeltaGauge, err := meter.Int64ObservableGauge( + "relayer.BlockDelta", + metric.WithInt64Callback(func(context context.Context, result metric.Int64Observer) error { + for domainID, delta := range blockDeltaMap { + result.Observe(delta.Int64(), + opts, + metric.WithAttributes(attribute.Int64("domainID", int64(domainID))), + ) + } + return nil + }), + metric.WithDescription("Difference between chain head and current indexed block per domain"), + ) + if err != nil { + return nil, err + } + + chainHeadMap := make(map[uint8]*big.Int) + chainHeadGauge, err := meter.Int64ObservableGauge( + "relayer.ChainHead", + metric.WithInt64Callback(func(context context.Context, result metric.Int64Observer) error { + for domainID, head := range chainHeadMap { + result.Observe(head.Int64(), + opts, + metric.WithAttributes(attribute.Int64("domainID", int64(domainID))), + ) + } + return nil + }), + metric.WithDescription("Latest block of the chain."), + ) + if err != nil { + return nil, err + } + + processedBlockMap := make(map[uint8]*big.Int) + processedBlockGauge, err := meter.Int64ObservableGauge( + "relayer.ProcessedBlocks", + metric.WithInt64Callback(func(context context.Context, result metric.Int64Observer) error { + for domainID, block := range processedBlockMap { + result.Observe(block.Int64(), + opts, + metric.WithAttributes(attribute.Int64("domainID", int64(domainID))), + ) + } + return nil + }), + metric.WithDescription("Latest processed block."), + ) + if err != nil { + return nil, err + } + + return &NetworkMetrics{ + opts: opts, + blockDeltaMap: blockDeltaMap, + chainHeadMap: chainHeadMap, + blockDeltaGauge: blockDeltaGauge, + chainHeadGauge: chainHeadGauge, + processedBlockGauge: processedBlockGauge, + processedBlockMap: processedBlockMap, + }, nil +} + +func (m *NetworkMetrics) TrackBlockDelta(domainID uint8, head *big.Int, current *big.Int) { + m.lock.Lock() + defer m.lock.Unlock() + + m.blockDeltaMap[domainID] = new(big.Int).Sub(head, current) + m.processedBlockMap[domainID] = new(big.Int).Set(current) + m.chainHeadMap[domainID] = new(big.Int).Set(head) +} From d3d111042b49b7deedf1cda2a2ceba1b5edfe182 Mon Sep 17 00:00:00 2001 From: mpetrun5 Date: Mon, 21 Oct 2024 17:50:29 +0200 Subject: [PATCH 08/14] Add gas metrics --- chains/evm/transactor/monitored/monitored.go | 26 +++++++++--- observability/metrics/network.go | 42 +++++++++++++++++--- 2 files changed, 57 insertions(+), 11 deletions(-) diff --git a/chains/evm/transactor/monitored/monitored.go b/chains/evm/transactor/monitored/monitored.go index 785cf0e8..01143a5c 100644 --- a/chains/evm/transactor/monitored/monitored.go +++ b/chains/evm/transactor/monitored/monitored.go @@ -8,6 +8,7 @@ import ( "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/core/types" + "github.com/rs/zerolog" "github.com/rs/zerolog/log" "github.com/sygmaprotocol/sygma-core/chains/evm/client" @@ -19,6 +20,10 @@ type GasPricer interface { GasPrice(priority *uint8) ([]*big.Int, error) } +type GasTracker interface { + TrackGasUsage(domainID uint8, gasUsed uint64, gasPrice *big.Int) +} + type RawTx struct { nonce uint64 to *common.Address @@ -31,8 +36,12 @@ type RawTx struct { } type MonitoredTransactor struct { + domainID uint8 + log zerolog.Logger + txFabric transaction.TxFabric gasPriceClient GasPricer + gasTracker GasTracker client client.Client maxGasPrice *big.Int @@ -49,15 +58,20 @@ type MonitoredTransactor struct { // Gas price is increased by increasePercentage param which // is a percentage value with which old gas price should be increased (e.g 15) func NewMonitoredTransactor( + domainID uint8, txFabric transaction.TxFabric, gasPriceClient GasPricer, + gasTracker GasTracker, client client.Client, maxGasPrice *big.Int, increasePercentage *big.Int, ) *MonitoredTransactor { return &MonitoredTransactor{ + domainID: domainID, + log: log.With().Uint8("domainID", domainID).Logger(), client: client, gasPriceClient: gasPriceClient, + gasTracker: gasTracker, txFabric: txFabric, pendingTxns: make(map[common.Hash]RawTx), maxGasPrice: maxGasPrice, @@ -143,10 +157,12 @@ func (t *MonitoredTransactor) Monitor( for oldHash, tx := range pendingTxCopy { receipt, err := t.client.TransactionReceipt(context.Background(), oldHash) if err == nil { + t.gasTracker.TrackGasUsage(t.domainID, receipt.GasUsed, receipt.EffectiveGasPrice) + if receipt.Status == types.ReceiptStatusSuccessful { - log.Info().Uint64("nonce", tx.nonce).Msgf("Executed transaction %s with nonce %d", oldHash, tx.nonce) + t.log.Info().Uint64("nonce", tx.nonce).Msgf("Executed transaction %s with nonce %d", oldHash, tx.nonce) } else { - log.Error().Uint64("nonce", tx.nonce).Msgf("Transaction %s failed on chain", oldHash) + t.log.Error().Uint64("nonce", tx.nonce).Msgf("Transaction %s failed on chain", oldHash) } delete(t.pendingTxns, oldHash) @@ -154,7 +170,7 @@ func (t *MonitoredTransactor) Monitor( } if time.Since(tx.creationTime) > txTimeout { - log.Error().Uint64("nonce", tx.nonce).Msgf("Transaction %s has timed out", oldHash) + t.log.Error().Uint64("nonce", tx.nonce).Msgf("Transaction %s has timed out", oldHash) delete(t.pendingTxns, oldHash) continue } @@ -164,7 +180,7 @@ func (t *MonitoredTransactor) Monitor( hash, err := t.resendTransaction(&tx) if err != nil { - log.Warn().Uint64("nonce", tx.nonce).Err(err).Msgf("Failed resending transaction %s", hash) + t.log.Warn().Uint64("nonce", tx.nonce).Err(err).Msgf("Failed resending transaction %s", hash) continue } @@ -188,7 +204,7 @@ func (t *MonitoredTransactor) resendTransaction(tx *RawTx) (common.Hash, error) return common.Hash{}, err } - log.Debug().Uint64("nonce", tx.nonce).Msgf("Resent transaction with hash %s", hash) + t.log.Debug().Uint64("nonce", tx.nonce).Msgf("Resent transaction with hash %s", hash) return hash, nil } diff --git a/observability/metrics/network.go b/observability/metrics/network.go index 55d0c611..23046232 100644 --- a/observability/metrics/network.go +++ b/observability/metrics/network.go @@ -12,15 +12,16 @@ import ( type NetworkMetrics struct { opts metric.MeasurementOption - blockDeltaGauge metric.Int64ObservableGauge - blockDeltaMap map[uint8]*big.Int - + blockDeltaGauge metric.Int64ObservableGauge + blockDeltaMap map[uint8]*big.Int processedBlockMap map[uint8]*big.Int processedBlockGauge metric.Int64ObservableGauge + chainHeadMap map[uint8]*big.Int + chainHeadGauge metric.Int64ObservableGauge + lock sync.Mutex - chainHeadMap map[uint8]*big.Int - chainHeadGauge metric.Int64ObservableGauge - lock sync.Mutex + gasUsedHistogram metric.Int64Histogram + gasPriceHistogram metric.Int64Histogram } // NewNetworkMetrics initializes metrics that provide insight into consensus and network activity @@ -79,6 +80,22 @@ func NewNetworkMetrics(ctx context.Context, meter metric.Meter, opts metric.Meas return nil, err } + gasUsedHistogram, err := meter.Int64Histogram( + "relayer.GasUsed", + metric.WithDescription("Gas used per transaction."), + ) + if err != nil { + return nil, err + } + + gasPriceHistogram, err := meter.Int64Histogram( + "relayer.GasPrice", + metric.WithDescription("Gas price distribution per transaction."), + ) + if err != nil { + return nil, err + } + return &NetworkMetrics{ opts: opts, blockDeltaMap: blockDeltaMap, @@ -87,6 +104,8 @@ func NewNetworkMetrics(ctx context.Context, meter metric.Meter, opts metric.Meas chainHeadGauge: chainHeadGauge, processedBlockGauge: processedBlockGauge, processedBlockMap: processedBlockMap, + gasUsedHistogram: gasUsedHistogram, + gasPriceHistogram: gasPriceHistogram, }, nil } @@ -98,3 +117,14 @@ func (m *NetworkMetrics) TrackBlockDelta(domainID uint8, head *big.Int, current m.processedBlockMap[domainID] = new(big.Int).Set(current) m.chainHeadMap[domainID] = new(big.Int).Set(head) } + +func (m *NetworkMetrics) TrackGasUsage(domainID uint8, gasUsed uint64, gasPrice *big.Int) { + m.gasPriceHistogram.Record( + context.Background(), + gasPrice.Int64(), + metric.WithAttributes(attribute.Int64("domainID", int64(domainID)))) + m.gasUsedHistogram.Record( + context.Background(), + int64(gasUsed), + metric.WithAttributes(attribute.Int64("domainID", int64(domainID)))) +} From 5ee4eb562f49e7504a6c252df603a01b373cc2c0 Mon Sep 17 00:00:00 2001 From: mpetrun5 Date: Mon, 21 Oct 2024 18:12:22 +0200 Subject: [PATCH 09/14] Add debug logs --- chains/evm/transactor/monitored/monitored.go | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/chains/evm/transactor/monitored/monitored.go b/chains/evm/transactor/monitored/monitored.go index 01143a5c..45031c6b 100644 --- a/chains/evm/transactor/monitored/monitored.go +++ b/chains/evm/transactor/monitored/monitored.go @@ -2,6 +2,7 @@ package monitored import ( "context" + "fmt" "math/big" "sync" "time" @@ -157,6 +158,9 @@ func (t *MonitoredTransactor) Monitor( for oldHash, tx := range pendingTxCopy { receipt, err := t.client.TransactionReceipt(context.Background(), oldHash) if err == nil { + fmt.Println("TRACKING") + fmt.Println(receipt.EffectiveGasPrice) + t.gasTracker.TrackGasUsage(t.domainID, receipt.GasUsed, receipt.EffectiveGasPrice) if receipt.Status == types.ReceiptStatusSuccessful { From 2e3cf9976fb251f6772c09c095380b08a9aa6053 Mon Sep 17 00:00:00 2001 From: mpetrun5 Date: Mon, 21 Oct 2024 18:19:26 +0200 Subject: [PATCH 10/14] Use tx gas price instead of effective one --- chains/evm/transactor/monitored/monitored.go | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/chains/evm/transactor/monitored/monitored.go b/chains/evm/transactor/monitored/monitored.go index 45031c6b..7354eb51 100644 --- a/chains/evm/transactor/monitored/monitored.go +++ b/chains/evm/transactor/monitored/monitored.go @@ -2,7 +2,6 @@ package monitored import ( "context" - "fmt" "math/big" "sync" "time" @@ -158,10 +157,13 @@ func (t *MonitoredTransactor) Monitor( for oldHash, tx := range pendingTxCopy { receipt, err := t.client.TransactionReceipt(context.Background(), oldHash) if err == nil { - fmt.Println("TRACKING") - fmt.Println(receipt.EffectiveGasPrice) - - t.gasTracker.TrackGasUsage(t.domainID, receipt.GasUsed, receipt.EffectiveGasPrice) + var gasPrice *big.Int + if len(tx.gasPrice) == 1 { + gasPrice = tx.gasPrice[0] + } else { + gasPrice = tx.gasPrice[1] + } + t.gasTracker.TrackGasUsage(t.domainID, receipt.GasUsed, gasPrice) if receipt.Status == types.ReceiptStatusSuccessful { t.log.Info().Uint64("nonce", tx.nonce).Msgf("Executed transaction %s with nonce %d", oldHash, tx.nonce) From 50a0a3bd02febe41d3ec380ed9569aefa6210573 Mon Sep 17 00:00:00 2001 From: mpetrun5 Date: Tue, 22 Oct 2024 13:04:17 +0200 Subject: [PATCH 11/14] Refactor raw tx --- chains/evm/transactor/monitored/monitored.go | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/chains/evm/transactor/monitored/monitored.go b/chains/evm/transactor/monitored/monitored.go index 7354eb51..c2a59708 100644 --- a/chains/evm/transactor/monitored/monitored.go +++ b/chains/evm/transactor/monitored/monitored.go @@ -35,6 +35,14 @@ type RawTx struct { creationTime time.Time } +func (tx *RawTx) GasPrice() *big.Int { + if len(tx.gasPrice) == 1 { + return tx.gasPrice[0] + } else { + return tx.gasPrice[1] + } +} + type MonitoredTransactor struct { domainID uint8 log zerolog.Logger @@ -157,13 +165,7 @@ func (t *MonitoredTransactor) Monitor( for oldHash, tx := range pendingTxCopy { receipt, err := t.client.TransactionReceipt(context.Background(), oldHash) if err == nil { - var gasPrice *big.Int - if len(tx.gasPrice) == 1 { - gasPrice = tx.gasPrice[0] - } else { - gasPrice = tx.gasPrice[1] - } - t.gasTracker.TrackGasUsage(t.domainID, receipt.GasUsed, gasPrice) + t.gasTracker.TrackGasUsage(t.domainID, receipt.GasUsed, tx.GasPrice()) if receipt.Status == types.ReceiptStatusSuccessful { t.log.Info().Uint64("nonce", tx.nonce).Msgf("Executed transaction %s with nonce %d", oldHash, tx.nonce) From 926069617c6715ec9a2733ac304331071b37bb79 Mon Sep 17 00:00:00 2001 From: mpetrun5 Date: Tue, 22 Oct 2024 13:04:34 +0200 Subject: [PATCH 12/14] Implement custom histogram boundaries --- observability/metrics.go | 87 ++++++++++++++++++++++++++------ observability/metrics/network.go | 2 + observability/metrics/system.go | 1 + 3 files changed, 74 insertions(+), 16 deletions(-) diff --git a/observability/metrics.go b/observability/metrics.go index 165e8704..beb0d219 100644 --- a/observability/metrics.go +++ b/observability/metrics.go @@ -10,23 +10,12 @@ import ( "go.opentelemetry.io/otel/metric" api "go.opentelemetry.io/otel/metric" sdkmetric "go.opentelemetry.io/otel/sdk/metric" + "go.opentelemetry.io/otel/sdk/metric/aggregation" sdkresource "go.opentelemetry.io/otel/sdk/resource" semconv "go.opentelemetry.io/otel/semconv/v1.17.0" ) -func initResource() *sdkresource.Resource { - res, _ := sdkresource.New(context.Background(), - sdkresource.WithProcess(), - sdkresource.WithTelemetrySDK(), - sdkresource.WithHost(), - sdkresource.WithAttributes( - semconv.ServiceName("relayer"), - ), - ) - return res -} - -func InitMetricProvider(ctx context.Context, agentURL string) (*sdkmetric.MeterProvider, error) { +func InitMetricProvider(ctx context.Context, agentURL string, opts ...sdkmetric.Option) (*sdkmetric.MeterProvider, error) { collectorURL, err := url.Parse(agentURL) if err != nil { return nil, err @@ -47,14 +36,80 @@ func InitMetricProvider(ctx context.Context, agentURL string) (*sdkmetric.MeterP httpMetricReader := sdkmetric.NewPeriodicReader(metricHTTPExporter) + opts = append(opts, sdkmetric.WithReader(httpMetricReader)) + opts = append(opts, sdkmetric.WithResource(initResource())) + opts = append(opts, sdkmetric.WithView(initSecondView())) + opts = append(opts, sdkmetric.WithView(initGasView())) meterProvider := sdkmetric.NewMeterProvider( - sdkmetric.WithReader(httpMetricReader), - sdkmetric.WithResource(initResource()), + opts..., ) - return meterProvider, nil } +func initResource() *sdkresource.Resource { + res, _ := sdkresource.New(context.Background(), + sdkresource.WithProcess(), + sdkresource.WithTelemetrySDK(), + sdkresource.WithHost(), + sdkresource.WithAttributes( + semconv.ServiceName("relayer"), + ), + ) + return res +} + +func initSecondView() sdkmetric.View { + return sdkmetric.NewView( + sdkmetric.Instrument{ + Unit: "s", + }, + sdkmetric.Stream{ + Aggregation: aggregation.ExplicitBucketHistogram{ + Boundaries: []float64{ + 0.000001, // 1 µs + 0.00001, // 10 µs + 0.0001, // 100 µs + 0.001, // 1 ms + 0.005, // 5 ms + 0.01, // 10 ms + 0.05, // 50 ms + 0.1, // 100 ms + 0.5, // 500 ms + 1.0, // 1 s + 5.0, // 5 s + 10.0, // 10 s + }, + NoMinMax: false, + }, + }, + ) +} + +func initGasView() sdkmetric.View { + return sdkmetric.NewView( + sdkmetric.Instrument{ + Unit: "gas", + }, + sdkmetric.Stream{ + Aggregation: aggregation.ExplicitBucketHistogram{ + Boundaries: []float64{ + 10000, + 20000, + 50000, + 100000, + 500000, + 1000000, + 5000000, + 10000000, + 15000000, + 30000000, + }, + NoMinMax: false, + }, + }, + ) +} + type RelayerMetrics struct { *metrics.SystemMetrics *metrics.NetworkMetrics diff --git a/observability/metrics/network.go b/observability/metrics/network.go index 23046232..972c515a 100644 --- a/observability/metrics/network.go +++ b/observability/metrics/network.go @@ -83,6 +83,7 @@ func NewNetworkMetrics(ctx context.Context, meter metric.Meter, opts metric.Meas gasUsedHistogram, err := meter.Int64Histogram( "relayer.GasUsed", metric.WithDescription("Gas used per transaction."), + metric.WithUnit("gas"), ) if err != nil { return nil, err @@ -91,6 +92,7 @@ func NewNetworkMetrics(ctx context.Context, meter metric.Meter, opts metric.Meas gasPriceHistogram, err := meter.Int64Histogram( "relayer.GasPrice", metric.WithDescription("Gas price distribution per transaction."), + metric.WithUnit("gas"), ) if err != nil { return nil, err diff --git a/observability/metrics/system.go b/observability/metrics/system.go index 65208493..67c06a0e 100644 --- a/observability/metrics/system.go +++ b/observability/metrics/system.go @@ -164,6 +164,7 @@ func NewSystemMetrics(ctx context.Context, meter metric.Meter, opts metric.Measu gcDurationHistogram, err := meter.Float64Histogram( "relayer.GcDurationSeconds", metric.WithDescription("Duration of garbage collection cycles."), + metric.WithUnit("s"), ) if err != nil { return nil, err From 3fa0518d4ad638f1a30eae7dd34e368aa1591550 Mon Sep 17 00:00:00 2001 From: mpetrun5 Date: Tue, 22 Oct 2024 13:16:11 +0200 Subject: [PATCH 13/14] Convert gas price to gwei --- chains/evm/transactor/monitored/monitored.go | 7 +++++-- observability/metrics/network.go | 3 +-- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/chains/evm/transactor/monitored/monitored.go b/chains/evm/transactor/monitored/monitored.go index c2a59708..694e79b5 100644 --- a/chains/evm/transactor/monitored/monitored.go +++ b/chains/evm/transactor/monitored/monitored.go @@ -35,12 +35,15 @@ type RawTx struct { creationTime time.Time } +// GasPrice returns transaction gas price in gwei func (tx *RawTx) GasPrice() *big.Int { + var gasPrice *big.Int if len(tx.gasPrice) == 1 { - return tx.gasPrice[0] + gasPrice = tx.gasPrice[0] } else { - return tx.gasPrice[1] + gasPrice = tx.gasPrice[1] } + return new(big.Int).Div(gasPrice, big.NewInt(1e9)) } type MonitoredTransactor struct { diff --git a/observability/metrics/network.go b/observability/metrics/network.go index 972c515a..b9be4eff 100644 --- a/observability/metrics/network.go +++ b/observability/metrics/network.go @@ -91,8 +91,7 @@ func NewNetworkMetrics(ctx context.Context, meter metric.Meter, opts metric.Meas gasPriceHistogram, err := meter.Int64Histogram( "relayer.GasPrice", - metric.WithDescription("Gas price distribution per transaction."), - metric.WithUnit("gas"), + metric.WithDescription("Gas price distribution per transaction in gwei."), ) if err != nil { return nil, err From ef0a65fdee558a26e01ebb19eee88fdde26d28b9 Mon Sep 17 00:00:00 2001 From: mpetrun5 Date: Tue, 22 Oct 2024 14:20:54 +0200 Subject: [PATCH 14/14] Fix monitored tests --- Makefile | 2 +- .../transactor/monitored/monitored_test.go | 19 +++++++++ mock/{signAndSend.go => monitored.go} | 39 ++++++++++++++++++- 3 files changed, 57 insertions(+), 3 deletions(-) rename mock/{signAndSend.go => monitored.go} (50%) diff --git a/Makefile b/Makefile index 79eea798..c36e2f01 100644 --- a/Makefile +++ b/Makefile @@ -37,7 +37,7 @@ genmocks: mockgen -destination=./mock/gas.go -source=./chains/evm/transactor/gas/gas-pricer.go -package mock mockgen -destination=./mock/relayer.go -source=./relayer/relayer.go -package mock mockgen -source=chains/evm/transactor/transact.go -destination=./mock/transact.go -package mock - mockgen -source=chains/evm/transactor/signAndSend/signAndSend.go -destination=./mock/signAndSend.go -package mock + mockgen -source=chains/evm/transactor/monitored/monitored.go -destination=./mock/monitored.go -package mock mockgen -source=./store/store.go -destination=./mock/store.go -package mock mockgen -source=./relayer/message/handler.go -destination=./mock/message.go -package mock mockgen -source=./chains/evm/listener/listener.go -destination=./mock/evmListener.go -package mock diff --git a/chains/evm/transactor/monitored/monitored_test.go b/chains/evm/transactor/monitored/monitored_test.go index bcd10d28..e5e2a5fe 100644 --- a/chains/evm/transactor/monitored/monitored_test.go +++ b/chains/evm/transactor/monitored/monitored_test.go @@ -21,6 +21,7 @@ type TransactorTestSuite struct { suite.Suite gomockController *gomock.Controller mockClient *mock.MockClient + mockGasTracker *mock.MockGasTracker mockTransactor *mock.MockTransactor mockGasPricer *mock.MockGasPricer } @@ -34,6 +35,8 @@ func (s *TransactorTestSuite) SetupTest() { s.mockClient = mock.NewMockClient(s.gomockController) s.mockTransactor = mock.NewMockTransactor(s.gomockController) s.mockGasPricer = mock.NewMockGasPricer(s.gomockController) + s.mockGasTracker = mock.NewMockGasTracker(s.gomockController) + s.mockGasTracker.EXPECT().TrackGasUsage(gomock.Any(), gomock.Any(), gomock.Any()).AnyTimes() } func (s *TransactorTestSuite) TestTransactor_SignAndSend_Success() { @@ -47,8 +50,10 @@ func (s *TransactorTestSuite) TestTransactor_SignAndSend_Success() { s.mockClient.EXPECT().UnlockNonce() t := monitored.NewMonitoredTransactor( + 1, transaction.NewTransaction, s.mockGasPricer, + s.mockGasTracker, s.mockClient, big.NewInt(1000), big.NewInt(15)) @@ -72,8 +77,10 @@ func (s *TransactorTestSuite) TestTransactor_SignAndSend_Fail() { s.mockClient.EXPECT().UnlockNonce() t := monitored.NewMonitoredTransactor( + 1, transaction.NewTransaction, s.mockGasPricer, + s.mockGasTracker, s.mockClient, big.NewInt(1000), big.NewInt(15)) @@ -99,8 +106,10 @@ func (s *TransactorTestSuite) TestTransactor_MonitoredTransaction_SuccessfulExec ctx, cancel := context.WithCancel(context.Background()) t := monitored.NewMonitoredTransactor( + 1, transaction.NewTransaction, s.mockGasPricer, + s.mockGasTracker, s.mockClient, big.NewInt(1000), big.NewInt(15)) @@ -134,8 +143,10 @@ func (s *TransactorTestSuite) TestTransactor_MonitoredTransaction_TxTimeout() { ctx, cancel := context.WithCancel(context.Background()) t := monitored.NewMonitoredTransactor( + 1, transaction.NewTransaction, s.mockGasPricer, + s.mockGasTracker, s.mockClient, big.NewInt(1000), big.NewInt(15)) @@ -169,8 +180,10 @@ func (s *TransactorTestSuite) TestTransactor_MonitoredTransaction_TransactionRes ctx, cancel := context.WithCancel(context.Background()) t := monitored.NewMonitoredTransactor( + 1, transaction.NewTransaction, s.mockGasPricer, + s.mockGasTracker, s.mockClient, big.NewInt(1000), big.NewInt(15)) @@ -208,8 +221,10 @@ func (s *TransactorTestSuite) TestTransactor_MonitoredTransaction_MaxGasPriceRea ctx, cancel := context.WithCancel(context.Background()) t := monitored.NewMonitoredTransactor( + 1, transaction.NewTransaction, s.mockGasPricer, + s.mockGasTracker, s.mockClient, big.NewInt(10), big.NewInt(15)) @@ -233,8 +248,10 @@ func (s *TransactorTestSuite) TestTransactor_MonitoredTransaction_MaxGasPriceRea func (s *TransactorTestSuite) TestTransactor_IncreaseGas_15PercentIncrease() { t := monitored.NewMonitoredTransactor( + 1, transaction.NewTransaction, s.mockGasPricer, + s.mockGasTracker, s.mockClient, big.NewInt(150), big.NewInt(15)) @@ -246,8 +263,10 @@ func (s *TransactorTestSuite) TestTransactor_IncreaseGas_15PercentIncrease() { func (s *TransactorTestSuite) TestTransactor_IncreaseGas_MaxGasReached() { t := monitored.NewMonitoredTransactor( + 1, transaction.NewTransaction, s.mockGasPricer, + s.mockGasTracker, s.mockClient, big.NewInt(15), big.NewInt(15)) diff --git a/mock/signAndSend.go b/mock/monitored.go similarity index 50% rename from mock/signAndSend.go rename to mock/monitored.go index a91de2db..4a2f5cc0 100644 --- a/mock/signAndSend.go +++ b/mock/monitored.go @@ -1,9 +1,9 @@ // Code generated by MockGen. DO NOT EDIT. -// Source: chains/evm/transactor/signAndSend/signAndSend.go +// Source: chains/evm/transactor/monitored/monitored.go // // Generated by this command: // -// mockgen -source=chains/evm/transactor/signAndSend/signAndSend.go -destination=./mock/signAndSend.go -package mock +// mockgen -source=chains/evm/transactor/monitored/monitored.go -destination=./mock/monitored.go -package mock // // Package mock is a generated GoMock package. package mock @@ -52,3 +52,38 @@ func (mr *MockGasPricerMockRecorder) GasPrice(priority any) *gomock.Call { mr.mock.ctrl.T.Helper() return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GasPrice", reflect.TypeOf((*MockGasPricer)(nil).GasPrice), priority) } + +// MockGasTracker is a mock of GasTracker interface. +type MockGasTracker struct { + ctrl *gomock.Controller + recorder *MockGasTrackerMockRecorder +} + +// MockGasTrackerMockRecorder is the mock recorder for MockGasTracker. +type MockGasTrackerMockRecorder struct { + mock *MockGasTracker +} + +// NewMockGasTracker creates a new mock instance. +func NewMockGasTracker(ctrl *gomock.Controller) *MockGasTracker { + mock := &MockGasTracker{ctrl: ctrl} + mock.recorder = &MockGasTrackerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockGasTracker) EXPECT() *MockGasTrackerMockRecorder { + return m.recorder +} + +// TrackGasUsage mocks base method. +func (m *MockGasTracker) TrackGasUsage(domainID uint8, gasUsed uint64, gasPrice *big.Int) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "TrackGasUsage", domainID, gasUsed, gasPrice) +} + +// TrackGasUsage indicates an expected call of TrackGasUsage. +func (mr *MockGasTrackerMockRecorder) TrackGasUsage(domainID, gasUsed, gasPrice any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TrackGasUsage", reflect.TypeOf((*MockGasTracker)(nil).TrackGasUsage), domainID, gasUsed, gasPrice) +}