testbed

type BaseOTLPDataReceiver struct {
	DataReceiverBase
	// contains filtered or unexported fields
}

type ChildProcessOption func(*childProcessCollector)

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

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

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

type DataProvider interface {
	// SetLoadGeneratorCounters supplies pointers to LoadGenerator counters.
	// The data provider implementation should increment these as it generates data.
	SetLoadGeneratorCounters(dataItemsGenerated *atomic.Uint64)
	// GenerateTraces returns an internal Traces instance with an OTLP ResourceSpans slice populated with test data.
	GenerateTraces() (ptrace.Traces, bool)
	// GenerateMetrics returns an internal MetricData instance with an OTLP ResourceMetrics slice of test data.
	GenerateMetrics() (pmetric.Metrics, bool)
	// GenerateLogs returns the internal plog.Logs format
	GenerateLogs() (plog.Logs, bool)
}

type DataReceiver interface {
	Start(tc consumer.Traces, mc consumer.Metrics, lc consumer.Logs) error
	Stop() error

	// GenConfigYAMLStr generates a config string to place in exporter part of collector config
	// so that it can send data to this receiver.
	GenConfigYAMLStr() string

	// ProtocolName returns exporterType name to use in collector config pipeline.
	ProtocolName() string
}

type DataReceiverBase struct {
	// Port on which to listen.
	Port int
}

type DataSender interface {
	// Start sender and connect to the configured endpoint. Must be called before
	// sending data.
	Start() error

	// Flush sends any accumulated data.
	Flush()

	// GetEndpoint returns the address to which this sender will send data.
	GetEndpoint() net.Addr

	// GenConfigYAMLStr generates a config string to place in receiver part of collector config
	// so that it can receive data from this sender.
	GenConfigYAMLStr() string

	// ProtocolName returns exporter name to use in collector config pipeline.
	ProtocolName() string
}

type DataSenderBase struct {
	Port int
	Host string
}

type FileDataProvider struct {
	ItemsPerBatch int
	// contains filtered or unexported fields
}

type LoadGenerator interface {
	Start(options LoadOptions)
	Stop()
	IsReady() bool
	DataItemsSent() uint64
	IncDataItemsSent()
	PermanentErrors() uint64
	GetStats() string
}

type LoadOptions struct {
	// DataItemsPerSecond specifies how many spans, metric data points, or log
	// records to generate each second.
	DataItemsPerSecond int

	// ItemsPerBatch specifies how many spans, metric data points, or log
	// records per batch to generate. Should be greater than zero. The number
	// of batches generated per second will be DataItemsPerSecond/ItemsPerBatch.
	ItemsPerBatch int

	// Attributes to add to each generated data item. Can be empty.
	Attributes map[string]string

	// Parallel specifies how many goroutines to send from.
	Parallel int
}

type LogDataSender interface {
	DataSender
	consumer.Logs
}

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

type LogPresentValidator struct {
	LogBody string
	Present bool
}

type MetricDataSender interface {
	DataSender
	consumer.Metrics
}

type MockBackend struct {
	ReceivedTraces  []ptrace.Traces
	ReceivedMetrics []pmetric.Metrics
	ReceivedLogs    []plog.Logs

	DroppedTraces  []ptrace.Traces
	DroppedMetrics []pmetric.Metrics
	DroppedLogs    []plog.Logs

	LogsToRetry []plog.Logs
	// contains filtered or unexported fields
}

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

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

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

type OtelcolRunner interface {
	// PrepareConfig stores the provided YAML-based otelcol configuration file in the format needed by the otelcol
	// instance(s) this runner manages. If successful, it returns the cleanup config function to be executed after
	// the test is executed.
	PrepareConfig(configStr string) (configCleanup func(), err error)
	// Start starts the otelcol instance(s) if not already running which is the subject of the test to be run.
	// It returns the host:port of the data receiver to post test data to.
	Start(args StartParams) error
	// Stop stops the otelcol instance(s) which are the subject of the test just run if applicable. Returns whether
	// the instance was actually stopped or not.
	Stop() (stopped bool, err error)
	// WatchResourceConsumption toggles on the monitoring of resource consumpution by the otelcol instance under test.
	WatchResourceConsumption() error
	// GetProcessMon returns the Process being used to monitor resource consumption.
	GetProcessMon() *process.Process
	// GetTotalConsumption returns the data collected by the process monitor.
	GetTotalConsumption() *ResourceConsumption
	// GetResourceConsumption returns the data collected by the process monitor as a display string.
	GetResourceConsumption() string
}

type PerfTestValidator struct{}

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

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

type ProviderSender struct {
	Provider DataProvider
	Sender   DataSender
	// contains filtered or unexported fields
}

type ResourceConsumption struct {
	CPUPercentAvg float64
	CPUPercentMax float64
	RAMMiBAvg     uint32
	RAMMiBMax     uint32
}

type ResourceSpec struct {
	// Percentage of one core the process is expected to consume at most.
	// Test is aborted and failed if consumption during
	// ResourceCheckPeriod exceeds this number. If 0 the CPU
	// consumption is not monitored and does not affect the test result.
	ExpectedMaxCPU uint32

	// Maximum RAM in MiB the process is expected to consume.
	// Test is aborted and failed if consumption exceeds this number.
	// If 0 memory consumption is not monitored and does not affect
	// the test result.
	ExpectedMaxRAM uint32

	// Period during which CPU and RAM of the process are measured.
	// Bigger numbers will result in more averaging of short spikes.
	ResourceCheckPeriod time.Duration

	// The number of consecutive violations necessary to trigger a failure.
	// This is useful for tests which can tolerate transitory violations.
	MaxConsecutiveFailures uint32
}

type StartParams struct {
	Name        string
	LogFilePath string
	CmdArgs     []string
	// contains filtered or unexported fields
}

type TestCase struct {
	LoadGenerator LoadGenerator
	MockBackend   *MockBackend

	// Duration is the requested duration of the tests. Configured via TESTBED_DURATION
	// env variable and defaults to 15 seconds if env variable is unspecified.
	Duration time.Duration
	// contains filtered or unexported fields
}

type TestCaseOption func(t *TestCase)

type TestCaseValidator interface {
	// Validate executes validation routines and test assertions.
	Validate(tc *TestCase)
	// RecordResults updates the TestResultsSummary for the test suite with results of a single test.
	RecordResults(tc *TestCase)
}

type TestResultsSummary interface {
	// Init creates and open the file and write headers.
	Init(resultsDir string)
	// Add results for one test.
	Add(testName string, result any)
	// Save the total results and close the file.
	Save()
}

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

type TraceDataSender interface {
	DataSender
	consumer.Traces
}