client

type Cachable interface {
	CacheKey() string
	CacheKeyAt(index int) string
	BatchSize() int
	FlagCacheHit(index int)
	CacheHit(index int) bool
}

type CacheScope int

type Config struct {
	Hosts []*Host
	Model string

	CacheSizeMb int

	// CacheScope limits which caches are available to this client.
	CacheScope *CacheScope

	Datastore *config.Remote

	// MaxRetry defines the maximum number of HTTP requests that should be sent
	// during a shared/client.(*Service).Run()
	MaxRetry int

	Debug              bool
	DictHashValidation bool

	// LatencyBreaker fields are passed through to circut.LatencyBreaker
	// at Service init time. When both LatencyBreakerLatestThreshold and
	// LatencyBreakerRollingThreshold are zero, the LatencyBreaker is not
	// constructed and the host's IsUp() reflects only the connection
	// breaker -- backward-compatible default.
	//
	// LatestThreshold is the per-attempt latency above which a single
	// observation is enough to trip into the shedding state. The caller
	// is expected to size this near (or just below) its own request
	// timeout so the breaker fires before requests would have failed.
	LatencyBreakerLatestThreshold time.Duration

	// RollingThreshold is the rolling-average latency above which the
	// breaker trips. Detects sustained slow-creep that no single
	// observation crosses LatestThreshold for.
	LatencyBreakerRollingThreshold time.Duration

	// RollingWindow is the duration over which the rolling average is
	// computed. Default 1s if zero.
	LatencyBreakerRollingWindow time.Duration

	// KConsecutive is the number of consecutive observations satisfying
	// (latest < LatestThreshold AND rolling < RollingThreshold) needed
	// to transition from ON back to OFF. Higher = more conservative
	// recovery, prevents flap on outliers. Default 3 if zero.
	LatencyBreakerKConsecutive int

	// PassThroughFraction is the probability that a request is allowed
	// through while the breaker is ON, to drive recovery sensing.
	// Default 0.01 (1%). Set higher for low-QPS models that need more
	// observations to recover, or 0 to fully shed without recovery.
	LatencyBreakerPassThroughFraction float64
}

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

type Host struct {

	// used as both a check to see if a host is down
	// and to pause requests to prevent downstream overload
	RequestTimeout time.Duration

	*circut.Breaker

	// LatencyBreaker is an optional latency-driven shed mechanism that
	// runs in parallel to the connection-failure-based Breaker. When
	// configured (non-nil), getHost() requires both Breaker.IsUp() and
	// LatencyBreaker.IsUp() to return true before letting a request
	// through. nil = disabled (acts as permanently up).
	LatencyBreaker *circut.LatencyBreaker
	// contains filtered or unexported fields
}

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

type Messages interface {
	Borrow() *Message
}

type Option interface {
	// Apply applies settings
	Apply(c *Service)
}

type Releaser interface {
	Release()
}

type Response struct {
	Status      string        `json:"status"`
	Error       string        `json:"error,omitempty"`
	ServiceTime time.Duration `json:"serviceTime"`
	DictHash    int           `json:"dictHash"`
	Data        interface{}   `json:"data"`
}

type Service struct {
	Config

	// Lock for dictionary.
	sync.RWMutex

	ErrorHistory tracker.Tracker
	// contains filtered or unexported fields
}