reporter

type Config struct {
	// CollAgentAddr defines the destination of the backend connection
	CollAgentAddr string

	// MaxRPCMsgSize defines the maximum size of a gRPC message.
	MaxRPCMsgSize int

	// ExecMetadataMaxQueue defines the maximum size for the queue which holds
	// data of type collectionagent.ExecutableMetadata.
	ExecMetadataMaxQueue uint32
	// CountsForTracesMaxQueue defines the maximum size for the queue which holds
	// data of type libpf.TraceAndCounts.
	CountsForTracesMaxQueue uint32
	// MetricsMaxQueue defines the maximum size for the queue which holds
	// data of type collectionagent.Metric.
	MetricsMaxQueue uint32
	// FramesForTracesMaxQueue defines the maximum size for the queue which holds
	// data of type libpf.Trace.
	FramesForTracesMaxQueue uint32
	// FrameMetadataMaxQueue defines the maximum size for the queue which holds
	// data of type collectionagent.FrameMetadata.
	FrameMetadataMaxQueue uint32
	// HostMetadataMaxQueue defines the maximum size for the queue which holds
	// data of type collectionagent.HostMetadata.
	HostMetadataMaxQueue uint32
	// FallbackSymbolsMaxQueue defines the maximum size for the queue which holds
	// data of type collectionagent.FallbackSymbol.
	FallbackSymbolsMaxQueue uint32
	// Disable secure communication with Collection Agent
	DisableTLS bool
	// Number of connection attempts to the collector after which we give up retrying
	MaxGRPCRetries uint32

	Times Times
}

type GRPCReporter struct {
	// contains filtered or unexported fields
}

type HostMetadata struct {
	Metadata  map[string]string
	Timestamp uint64
}

type HostMetadataReporter interface {
	// ReportHostMetadata enqueues host metadata for sending (to the collection agent).
	ReportHostMetadata(metadataMap map[string]string)

	// ReportHostMetadataBlocking sends host metadata to the collection agent.
	ReportHostMetadataBlocking(ctx context.Context, metadataMap map[string]string,
		maxRetries int, waitRetry time.Duration) error
}

type Metrics struct {
	CountsForTracesOverwriteCount uint32
	ExeMetadataOverwriteCount     uint32
	FrameMetadataOverwriteCount   uint32
	FramesForTracesOverwriteCount uint32
	HostMetadataOverwriteCount    uint32
	MetricsOverwriteCount         uint32
	FallbackSymbolsOverwriteCount uint32
	RPCBytesOutCount              int64
	RPCBytesInCount               int64
	WireBytesOutCount             int64
	WireBytesInCount              int64
}

type MetricsReporter interface {
	// ReportMetrics accepts an id with a corresponding value and caches this
	// information before a periodic reporting to the backend.
	ReportMetrics(timestamp uint32, ids []uint32, values []int64)
}

type OTLPReporter struct {
	// contains filtered or unexported fields
}

type Reporter interface {
	TraceReporter
	SymbolReporter
	HostMetadataReporter
	MetricsReporter

	// Stop triggers a graceful shutdown of the reporter.
	Stop()
	// GetMetrics returns the reporter internal metrics.
	GetMetrics() Metrics
}

type SymbolReporter interface {
	// ReportFallbackSymbol enqueues a fallback symbol for reporting, for a given frame.
	ReportFallbackSymbol(frameID libpf.FrameID, symbol string)

	// ExecutableMetadata accepts a fileID with the corresponding filename
	// and caches this information before a periodic reporting to the backend.
	ExecutableMetadata(ctx context.Context, fileID libpf.FileID, fileName, buildID string)

	// FrameMetadata accepts metadata associated with a frame and caches this information before
	// a periodic reporting to the backend.
	FrameMetadata(fileID libpf.FileID, addressOrLine libpf.AddressOrLineno,
		lineNumber libpf.SourceLineno, functionOffset uint32, functionName, filePath string)
}

type Times interface {
	ReportInterval() time.Duration
	ReportMetricsInterval() time.Duration
	GRPCConnectionTimeout() time.Duration
	GRPCOperationTimeout() time.Duration
	GRPCStartupBackoffTime() time.Duration
	GRPCAuthErrorDelay() time.Duration
}

type TraceReporter interface {
	// ReportFramesForTrace accepts a trace with the corresponding frames
	// and caches this information before a periodic reporting to the backend.
	ReportFramesForTrace(trace *libpf.Trace)

	// ReportCountForTrace accepts a hash of a trace with a corresponding count and
	// caches this information before a periodic reporting to the backend.
	ReportCountForTrace(traceHash libpf.TraceHash, timestamp libpf.UnixTime32,
		count uint16, comm, podName, containerName string)
}