receive

type Appendable interface {
	Appender(ctx context.Context) (storage.Appender, error)
}

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

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

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

type CapNProtoWriterOptions struct {
	TooFarInFutureTimeWindow int64 // Unit: nanoseconds
}

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

type DefaultLimitsConfig struct {
	// RequestLimits holds the difficult per-request limits.
	RequestLimits requestLimitsConfig `yaml:"request"`
	// HeadSeriesLimit specifies the maximum number of head series allowed for any tenant.
	HeadSeriesLimit uint64 `yaml:"head_series_limit"`
}

type Endpoint struct {
	Address          string `json:"address"`
	CapNProtoAddress string `json:"capnproto_address"`
	AZ               string `json:"az"`
}

type GlobalLimitsConfig struct {
	// MaxConcurrency represents the maximum concurrency during write operations.
	MaxConcurrency int64 `yaml:"max_concurrency"`
	// MetaMonitoring options specify the query, url and client for Query API address used in head series limiting.
	MetaMonitoringURL        string                         `yaml:"meta_monitoring_url"`
	MetaMonitoringHTTPClient *clientconfig.HTTPClientConfig `yaml:"meta_monitoring_http_client"`
	MetaMonitoringLimitQuery string                         `yaml:"meta_monitoring_limit_query"`
	// contains filtered or unexported fields
}

type Handler struct {
	Limiter *Limiter
	// contains filtered or unexported fields
}

type Hashring interface {
	// GetN returns the nth node that should handle the given tenant and time series.
	GetN(tenant string, timeSeries *prompb.TimeSeries, n uint64) (Endpoint, error)
	// Nodes returns a sorted slice of nodes that are in this hashring. Addresses could be duplicated
	// if, for example, the same address is used for multiple tenants in the multi-hashring.
	Nodes() []Endpoint

	Close()
}

type HashringAlgorithm string

type HashringConfig struct {
	Hashring          string            `json:"hashring,omitempty"`
	Tenants           []string          `json:"tenants,omitempty"`
	TenantMatcherType tenantMatcher     `json:"tenant_matcher_type,omitempty"`
	Endpoints         []Endpoint        `json:"endpoints"`
	Algorithm         HashringAlgorithm `json:"algorithm,omitempty"`
	ExternalLabels    labels.Labels     `json:"external_labels,omitempty"`
	// If non-zero then enable shuffle sharding.
	ShuffleShardingConfig ShuffleShardingConfig `json:"shuffle_sharding_config,omitempty"`
}

type Limiter struct {
	sync.RWMutex
	// contains filtered or unexported fields
}

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

type MultiTSDBOption func(mt *MultiTSDB)

type Options struct {
	Writer                  *Writer
	ListenAddress           string
	Registry                *prometheus.Registry
	TenantHeader            string
	TenantField             string
	DefaultTenantID         string
	ReplicaHeader           string
	Endpoint                string
	ReplicationFactor       uint64
	SplitTenantLabelName    string
	ReceiverMode            ReceiverMode
	Tracer                  opentracing.Tracer
	TLSConfig               *tls.Config
	DialOpts                []grpc.DialOption
	ForwardTimeout          time.Duration
	MaxBackoff              time.Duration
	MaxArtificialDelay      time.Duration
	RelabelConfigs          []*relabel.Config
	TSDBStats               TSDBStats
	Limiter                 *Limiter
	AsyncForwardWorkerCount uint
	ReplicationProtocol     ReplicationProtocol
	OtlpEnableTargetInfo    bool
	OtlpResourceAttributes  []string
}

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

type ReceiveAppender struct {
	storage.Appender
	// contains filtered or unexported fields
}

type ReceiverMode string

type ReplicationProtocol string

type RootLimitsConfig struct {
	// WriteLimits hold the limits for writing data.
	WriteLimits WriteLimitsConfig `yaml:"write"`
}

type ShuffleShardingConfig struct {
	ShardSize int `json:"shard_size"`
	CacheSize int `json:"cache_size"`
	// ZoneAwarenessDisabled disables zone awareness. We still try to spread the load
	// across the available zones, but we don't try to balance the shards across zones.
	ZoneAwarenessDisabled bool                            `json:"zone_awareness_disabled"`
	Overrides             []ShuffleShardingOverrideConfig `json:"overrides,omitempty"`
}

type ShuffleShardingOverrideConfig struct {
	ShardSize         int           `json:"shard_size"`
	Tenants           []string      `json:"tenants,omitempty"`
	TenantMatcherType tenantMatcher `json:"tenant_matcher_type,omitempty"`
}

type SingleNodeHashring string

type TSDBStats interface {
	// TenantStats returns TSDB head stats for the given tenants.
	// If no tenantIDs are provided, stats for all tenants are returned.
	TenantStats(limit int, statsByLabelName string, tenantIDs ...string) []api.TenantStats
}

type TenantStorage interface {
	TenantAppendable(string) (Appendable, error)
}

type TenantsWriteLimitsConfig map[string]*WriteLimitConfig

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

type WriteLimitConfig struct {
	// RequestLimits holds the difficult per-request limits.
	RequestLimits *requestLimitsConfig `yaml:"request"`
	// HeadSeriesLimit specifies the maximum number of head series allowed for a tenant.
	HeadSeriesLimit *uint64 `yaml:"head_series_limit"`
}

type WriteLimitsConfig struct {
	// GlobalLimits are limits that are shared across all tenants.
	GlobalLimits GlobalLimitsConfig `yaml:"global"`
	// DefaultLimits are the default limits for tenants without specified limits.
	DefaultLimits DefaultLimitsConfig `yaml:"default"`
	// TenantsLimits are the limits per tenant.
	TenantsLimits TenantsWriteLimitsConfig `yaml:"tenants"`
}

type WriteableStoreAsyncClient interface {
	storepb.WriteableStoreClient
	RemoteWriteAsync(context.Context, *storepb.WriteRequest, endpointReplica, []int, chan writeResponse, func(error))
	// TryRemoteWriteAsync submits the request without blocking. Returns false if the peer's
	// worker pool is at capacity; the caller should fall back to RemoteWriteAsync.
	TryRemoteWriteAsync(context.Context, *storepb.WriteRequest, endpointReplica, []int, chan writeResponse, func(error)) bool
}

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

type WriterOptions struct {
	Intern                   bool
	TooFarInFutureTimeWindow int64 // Unit: nanoseconds
}