in aggregators/internal/telemetry/metrics.go [63:232]
func NewMetrics(provider pebbleProvider, opts ...Option) (*Metrics, error) {
var err error
var i Metrics
cfg := newConfig(opts...)
meter := cfg.Meter
// Aggregator metrics
i.EventsProcessed, err = meter.Float64Counter(
"events.processed.count",
metric.WithDescription("Number of processed APM Events. Dimensions are used to report the outcome"),
metric.WithUnit(countUnit),
)
if err != nil {
return nil, fmt.Errorf("failed to create metric for events processed: %w", err)
}
i.BytesProcessed, err = meter.Int64Counter(
"events.processed.bytes",
metric.WithDescription("Number of bytes processed by the aggregators"),
metric.WithUnit(bytesUnit),
)
if err != nil {
return nil, fmt.Errorf("failed to create metric for bytes processed: %w", err)
}
i.ProcessingLatency, err = meter.Float64Histogram(
"events.processed.latency",
metric.WithDescription("Records the processing delays, removes expected delays due to aggregation intervals"),
metric.WithUnit(durationUnit),
)
if err != nil {
return nil, fmt.Errorf("failed to create metric for processing delay: %w", err)
}
i.MinQueuedDelay, err = meter.Float64Histogram(
"events.processed.queued-latency",
metric.WithDescription("Records total duration for aggregating a batch w.r.t. its youngest member"),
metric.WithUnit(durationUnit),
)
if err != nil {
return nil, fmt.Errorf("failed to create metric for queued delay: %w", err)
}
i.MetricsOverflowed, err = meter.Int64Counter(
"metrics.overflowed.count",
metric.WithDescription(
"Estimated number of metric aggregation keys that resulted in an overflow, per interval and aggregation type",
),
metric.WithUnit(countUnit),
)
if err != nil {
return nil, fmt.Errorf("failed to create metric for metrics overflowed: %w", err)
}
// Pebble metrics
i.pebbleFlushes, err = meter.Int64ObservableCounter(
"pebble.flushes",
metric.WithDescription("Number of memtable flushes to disk"),
metric.WithUnit(countUnit),
)
if err != nil {
return nil, fmt.Errorf("failed to create metric for flushes: %w", err)
}
i.pebbleFlushedBytes, err = meter.Int64ObservableCounter(
"pebble.flushed-bytes",
metric.WithDescription("Bytes written during flush"),
metric.WithUnit(bytesUnit),
)
if err != nil {
return nil, fmt.Errorf("failed to create metric for flushed bytes: %w", err)
}
i.pebbleCompactions, err = meter.Int64ObservableCounter(
"pebble.compactions",
metric.WithDescription("Number of table compactions"),
metric.WithUnit(countUnit),
)
if err != nil {
return nil, fmt.Errorf("failed to create metric for compactions: %w", err)
}
i.pebbleIngestedBytes, err = meter.Int64ObservableCounter(
"pebble.ingested-bytes",
metric.WithDescription("Bytes ingested"),
metric.WithUnit(bytesUnit),
)
if err != nil {
return nil, fmt.Errorf("failed to create metric for ingested bytes: %w", err)
}
i.pebbleCompactedBytesRead, err = meter.Int64ObservableCounter(
"pebble.compacted-bytes-read",
metric.WithDescription("Bytes read during compaction"),
metric.WithUnit(bytesUnit),
)
if err != nil {
return nil, fmt.Errorf("failed to create metric for compacted bytes read: %w", err)
}
i.pebbleCompactedBytesWritten, err = meter.Int64ObservableCounter(
"pebble.compacted-bytes-written",
metric.WithDescription("Bytes written during compaction"),
metric.WithUnit(bytesUnit),
)
if err != nil {
return nil, fmt.Errorf("failed to create metric for compacted bytes written: %w", err)
}
i.pebbleMemtableTotalSize, err = meter.Int64ObservableGauge(
"pebble.memtable.total-size",
metric.WithDescription("Current size of memtable in bytes"),
metric.WithUnit(bytesUnit),
)
if err != nil {
return nil, fmt.Errorf("failed to create metric for memtable size: %w", err)
}
i.pebbleTotalDiskUsage, err = meter.Int64ObservableGauge(
"pebble.disk.usage",
metric.WithDescription("Total disk usage by pebble, including live and obsolete files"),
metric.WithUnit(bytesUnit),
)
if err != nil {
return nil, fmt.Errorf("failed to create metric for total disk usage: %w", err)
}
i.pebbleReadAmplification, err = meter.Int64ObservableGauge(
"pebble.read-amplification",
metric.WithDescription("Current read amplification for the db"),
metric.WithUnit(countUnit),
)
if err != nil {
return nil, fmt.Errorf("failed to create metric for read amplification: %w", err)
}
i.pebbleNumSSTables, err = meter.Int64ObservableGauge(
"pebble.num-sstables",
metric.WithDescription("Current number of storage engine SSTables"),
metric.WithUnit(countUnit),
)
if err != nil {
return nil, fmt.Errorf("failed to create metric for count of sstables: %w", err)
}
i.pebbleTableReadersMemEstimate, err = meter.Int64ObservableGauge(
"pebble.table-readers-mem-estimate",
metric.WithDescription("Memory used by index and filter blocks"),
metric.WithUnit(bytesUnit),
)
if err != nil {
return nil, fmt.Errorf("failed to create metric for table cache readers: %w", err)
}
i.pebblePendingCompaction, err = meter.Int64ObservableGauge(
"pebble.estimated-pending-compaction",
metric.WithDescription("Estimated pending compaction bytes"),
metric.WithUnit(bytesUnit),
)
if err != nil {
return nil, fmt.Errorf("failed to create metric for pending compaction: %w", err)
}
i.pebbleMarkedForCompactionFiles, err = meter.Int64ObservableGauge(
"pebble.marked-for-compaction-files",
metric.WithDescription("Count of SSTables marked for compaction"),
metric.WithUnit(countUnit),
)
if err != nil {
return nil, fmt.Errorf("failed to create metric for compaction marked files: %w", err)
}
i.pebbleKeysTombstones, err = meter.Int64ObservableGauge(
"pebble.keys.tombstone.count",
metric.WithDescription("Approximate count of delete keys across the storage engine"),
metric.WithUnit(countUnit),
)
if err != nil {
return nil, fmt.Errorf("failed to create metric for tombstones: %w", err)
}
if err := i.registerCallback(meter, provider); err != nil {
return nil, fmt.Errorf("failed to register callback: %w", err)
}
return &i, nil
}