synth

type AttributeGenerator interface {
	Generate(rng *rand.Rand) any
}

type AttributeValueConfig struct {
	Value        any                 `yaml:"value,omitempty"`
	Values       map[any]int         `yaml:"values,omitempty"`
	Sequence     string              `yaml:"sequence,omitempty"`
	Probability  *float64            `yaml:"probability,omitempty"`
	Range        []int64             `yaml:"range,omitempty"`
	Distribution *DistributionConfig `yaml:"distribution,omitempty"`
}

type BackpressureConfig struct {
	LatencyThreshold   string  `yaml:"latency_threshold"`
	DurationMultiplier float64 `yaml:"duration_multiplier,omitempty"`
	ErrorRateAdd       string  `yaml:"error_rate_add,omitempty"`
}

type BoolValue struct {
	Probability float64
}

type BurstyPattern struct {
	BaseRate        float64
	BurstMultiplier float64
	BurstInterval   time.Duration
	BurstDuration   time.Duration
}

type Call struct {
	Operation    *Operation
	Probability  float64
	Condition    string
	Count        int
	Timeout      time.Duration
	Retries      int
	RetryBackoff time.Duration
}

type CallConfig struct {
	Target       string  `yaml:"target"`
	Probability  float64 `yaml:"probability,omitempty"`
	Condition    string  `yaml:"condition,omitempty"`
	Count        int     `yaml:"count,omitempty"`
	Timeout      string  `yaml:"timeout,omitempty"`
	Retries      int     `yaml:"retries,omitempty"`
	RetryBackoff string  `yaml:"retry_backoff,omitempty"`
}

type CheckOptions struct {
	MaxDepth         int
	MaxFanOut        int
	MaxSpans         int
	MaxSpansPerTrace int
	Samples          int
	Seed             uint64
}

type CheckResult struct {
	Name         string
	Pass         bool
	Limit        int
	Actual       int
	Sampled      *int
	SamplesRun   int
	Path         []string
	Ref          string
	Distribution *DistributionSummary
}

type CircuitBreakerConfig struct {
	FailureThreshold int    `yaml:"failure_threshold"`
	Window           string `yaml:"window"`
	Cooldown         string `yaml:"cooldown"`
}

type CircuitState int

type Config struct {
	Version   int              `yaml:"version"`
	Services  []ServiceConfig  `yaml:"-"`
	Traffic   TrafficConfig    `yaml:"traffic"`
	Scenarios []ScenarioConfig `yaml:"scenarios,omitempty"`
}

type Distribution struct {
	Mean   time.Duration
	StdDev time.Duration
}

type DistributionConfig struct {
	Mean   float64 `yaml:"mean"`
	StdDev float64 `yaml:"stddev"`
}

type DistributionSummary struct {
	P50 int
	P95 int
	P99 int
	Max int
}

type DiurnalPattern struct {
	BaseRate         float64
	PeakMultiplier   float64
	TroughMultiplier float64
	Period           time.Duration
}

type DomainResolver func(domain string) map[string]AttributeGenerator

type Engine struct {
	Topology         *Topology
	Traffic          TrafficPattern
	Scenarios        []Scenario
	Tracers          TracerSource
	Rng              *rand.Rand
	Duration         time.Duration
	Observers        []SpanObserver
	MaxSpansPerTrace int
	State            *SimulationState
	LabelScenarios   bool
	TimeOffset       time.Duration
}

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

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

type NormalValue struct {
	Mean   float64
	StdDev float64
}

type Operation struct {
	Service        *Service
	Name           string
	Ref            string
	Duration       Distribution
	ErrorRate      float64
	Calls          []Call
	CallStyle      string
	Attributes     map[string]AttributeGenerator
	QueueDepth     int
	Backpressure   *ResolvedBackpressure
	CircuitBreaker *ResolvedCircuitBreaker
}

type OperationConfig struct {
	Name           string
	Domain         string
	Duration       string
	ErrorRate      string
	Calls          []CallConfig
	CallStyle      string
	Attributes     map[string]AttributeValueConfig
	QueueDepth     int
	Backpressure   *BackpressureConfig
	CircuitBreaker *CircuitBreakerConfig
}

type OperationState struct {
	ActiveRequests int
	MaxQueueDepth  int

	BackpressureThreshold time.Duration
	DurationMultiplier    float64
	ErrorRateAdd          float64
	RecentLatency         time.Duration
	BackpressureActive    bool

	FailureWindow    []failureRecord
	Circuit          CircuitState
	OpenedAt         time.Duration
	Cooldown         time.Duration
	FailureThreshold int
	WindowDuration   time.Duration
}

type Override struct {
	Duration     Distribution
	ErrorRate    float64
	HasErrorRate bool
	Attributes   map[string]AttributeGenerator
	AddCalls     []Call
	RemoveCalls  map[string]bool
}

type OverrideConfig struct {
	Duration    string                          `yaml:"duration,omitempty"`
	ErrorRate   string                          `yaml:"error_rate,omitempty"`
	Attributes  map[string]AttributeValueConfig `yaml:"attributes,omitempty"`
	AddCalls    []CallConfig                    `yaml:"add_calls,omitempty"`
	RemoveCalls []RemoveCallConfig              `yaml:"remove_calls,omitempty"`
}

type RangeValue struct {
	Min int64
	Max int64
}

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

type RemoveCallConfig struct {
	Target string `yaml:"target"`
}

type ResolvedBackpressure struct {
	LatencyThreshold   time.Duration
	DurationMultiplier float64
	ErrorRateAdd       float64
}

type ResolvedCircuitBreaker struct {
	FailureThreshold int
	Window           time.Duration
	Cooldown         time.Duration
}

type SampleDistribution struct {
	Depths  []int
	Spans   []int
	FanOuts []int
}

type SampleResults struct {
	MaxDepth     int
	MaxSpans     int
	MaxFanOut    int
	TracesRun    int
	Distribution SampleDistribution
}

type Scenario struct {
	Name      string
	Start     time.Duration
	End       time.Duration
	Priority  int
	Overrides map[string]Override
	Traffic   TrafficPattern
}

type ScenarioConfig struct {
	Name     string                    `yaml:"name"`
	At       string                    `yaml:"at"`
	Duration string                    `yaml:"duration"`
	Priority int                       `yaml:"priority,omitempty"`
	Override map[string]OverrideConfig `yaml:"override,omitempty"`
	Traffic  *TrafficConfig            `yaml:"traffic,omitempty"`
}

type SegmentConfig struct {
	Until string `yaml:"until"`
	Rate  string `yaml:"rate"`
}

type SequenceValue struct {
	Pattern string
	// contains filtered or unexported fields
}

type Service struct {
	Name       string
	Operations map[string]*Operation
	Attributes map[string]string
}

type ServiceConfig struct {
	Name       string
	Attributes map[string]string
	Operations []OperationConfig
}

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

type SpanInfo struct {
	Service   string
	Operation string
	Timestamp time.Time
	Duration  time.Duration
	IsError   bool
	Kind      trace.SpanKind
	Attrs     []attribute.KeyValue
	Scenarios []string
}

type SpanObserver interface {
	Observe(info SpanInfo)
}

type StaticValue struct {
	Value any
}

type Stats struct {
	Traces              int64   `json:"traces"`
	Spans               int64   `json:"spans"`
	Errors              int64   `json:"errors"`
	FailedTraces        int64   `json:"failed_traces"`
	Timeouts            int64   `json:"timeouts"`
	Retries             int64   `json:"retries"`
	SpansBounded        int64   `json:"spans_bounded"`
	QueueRejections     int64   `json:"queue_rejections"`
	CircuitBreakerTrips int64   `json:"circuit_breaker_trips"`
	ElapsedMs           int64   `json:"elapsed_ms"`
	TracesPerSec        float64 `json:"traces_per_second"`
	SpansPerSec         float64 `json:"spans_per_second"`
	ErrorRate           float64 `json:"error_rate"`
	TraceErrorRate      float64 `json:"trace_error_rate"`
}

type Topology struct {
	Services map[string]*Service
	Roots    []*Operation
}

type TracerSource func(serviceName string) trace.Tracer

type TrafficConfig struct {
	Rate             string          `yaml:"rate"`
	Pattern          string          `yaml:"pattern,omitempty"`
	BurstMultiplier  float64         `yaml:"burst_multiplier,omitempty"`
	BurstInterval    string          `yaml:"burst_interval,omitempty"`
	BurstDuration    string          `yaml:"burst_duration,omitempty"`
	PeakMultiplier   float64         `yaml:"peak_multiplier,omitempty"`
	TroughMultiplier float64         `yaml:"trough_multiplier,omitempty"`
	Period           string          `yaml:"period,omitempty"`
	Segments         []SegmentConfig `yaml:"segments,omitempty"`
	Overlay          *TrafficConfig  `yaml:"overlay,omitempty"`
}

type TrafficPattern interface {
	Rate(elapsed time.Duration) float64 // traces per second
}

type UniformPattern struct {
	BaseRate float64
}

type WeightedChoice struct {
	Choices      []any
	CumulWeights []int
	TotalWeight  int
}