httpclient

type AuthBearerRoundTripper struct {
	Delegate     http.RoundTripper
	AuthProvider AuthProvider
	// contains filtered or unexported fields
}

type AuthBearerRoundTripperError struct {
	Inner error
}

type AuthBearerRoundTripperOpts struct {
	// TokenScope is an optional list of scopes to pass to AuthProvider.GetToken.
	// By default, no scopes are passed.
	TokenScope []string

	// MinInvalidationInterval determines the minimum time between cache invalidation attempts
	// for the same AuthProvider. This prevents excessive calls to token endpoints.
	// By default, DefaultAuthProviderMinInvalidationInterval const is used.
	MinInvalidationInterval time.Duration

	// ShouldRefreshTokenAndRetry is called after the first attempt and decides whether a token refresh attempt
	// should be performed and the request should be retried once more (cache invalidation + token refresh + single retry).
	// By default, it returns true only for HTTP 401 responses.
	// If you need to retry only for specific endpoints or HTTP methods, you can provide your own implementation
	// and use http.Response.Request field to make the decision.
	ShouldRefreshTokenAndRetry func(ctx context.Context, resp *http.Response) bool

	// LoggerProvider is a function that provides a context-specific logger.
	// One of the typical use cases is to use an auth client in the context of a request handler,
	// where the logger should produce logs with request-specific information (e.g., request ID).
	LoggerProvider func(ctx context.Context) log.FieldLogger
}

type AuthProvider interface {
	GetToken(ctx context.Context, scope ...string) (string, error)
}

type AuthProviderFunc func(ctx context.Context, scope ...string) (string, error)

type AuthProviderInvalidator interface {
	Invalidate()
}

type CheckRetryFunc func(ctx context.Context, resp *http.Response, roundTripErr error, doneRetryAttempts int) (bool, error)

type Config struct {
	// Retries is a configuration for HTTP client retries policy.
	Retries RetriesConfig `mapstructure:"retries" yaml:"retries" json:"retries"`

	// RateLimits is a configuration for HTTP client rate limits.
	RateLimits RateLimitsConfig `mapstructure:"rateLimits" yaml:"rateLimits" json:"rateLimits"`

	// Log is a configuration for HTTP client logs.
	Log LogConfig `mapstructure:"log" yaml:"log" json:"log"`

	// Metrics is a configuration for HTTP client metrics.
	Metrics MetricsConfig `mapstructure:"metrics" yaml:"metrics" json:"metrics"`

	// Timeout is the maximum time to wait for a request to be made.
	Timeout config.TimeDuration `mapstructure:"timeout" yaml:"timeout" json:"timeout"`
	// contains filtered or unexported fields
}

type ConfigOption func(*configOptions)

type ConstantBackoffConfig struct {
	// Interval is the interval for constant backoff.
	Interval config.TimeDuration `mapstructure:"interval" yaml:"interval" json:"interval"`
}

type ExponentialBackoffConfig struct {
	// InitialInterval is the initial interval for exponential backoff.
	InitialInterval config.TimeDuration `mapstructure:"initialInterval" yaml:"initialInterval" json:"initialInterval"`

	// Multiplier is the multiplier for exponential backoff.
	Multiplier float64 `mapstructure:"multiplier" yaml:"multiplier" json:"multiplier"`
}

type LogConfig struct {
	// Enabled is a flag that enables logging.
	Enabled bool `mapstructure:"enabled" yaml:"enabled" json:"enabled"`

	// SlowRequestThreshold is a threshold for slow requests.
	SlowRequestThreshold config.TimeDuration `mapstructure:"slowRequestThreshold" yaml:"slowRequestThreshold" json:"slowRequestThreshold"`

	// Mode of logging: [all, failed]. 'all' by default.
	Mode LoggingMode `mapstructure:"mode" yaml:"mode" json:"mode"`
}

type LoggingMode string

type LoggingRoundTripper struct {
	// Delegate is the next RoundTripper in the chain.
	Delegate http.RoundTripper

	// ClientType represents a type of client, it's a service component reference. e.g. 'auth-service'
	ClientType string

	// Mode of logging: [all, failed]. 'all' by default.
	Mode LoggingMode

	// SlowRequestThreshold is a threshold for slow requests.
	SlowRequestThreshold time.Duration

	// LoggerProvider is a function that provides a context-specific logger.
	// middleware.GetLoggerFromContext is used by default.
	LoggerProvider func(ctx context.Context) log.FieldLogger
}

type LoggingRoundTripperOpts struct {
	// ClientType represents a type of client, it's a service component reference. e.g. 'auth-service'
	ClientType string

	// Mode of logging: [all, failed]. 'all' by default.
	Mode LoggingMode

	// SlowRequestThreshold is a threshold for slow requests.
	SlowRequestThreshold time.Duration

	// LoggerProvider is a function that provides a context-specific logger.
	// middleware.GetLoggerFromContext is used by default.
	LoggerProvider func(ctx context.Context) log.FieldLogger
}

type MetricsCollector interface {
	// RequestDuration observes the duration of the request and the status code.
	RequestDuration(clientType, remoteAddress, summary, status, requestType string, duration float64)
}

type MetricsConfig struct {
	// Enabled is a flag that enables metrics.
	Enabled bool `mapstructure:"enabled" yaml:"enabled" json:"enabled"`
}

type MetricsRoundTripper struct {
	// Delegate is the next RoundTripper in the chain.
	Delegate http.RoundTripper

	// ClientType represents a type of client, it's a service component reference. e.g. 'auth-service'
	ClientType string

	// MetricsCollector is a metrics collector.
	MetricsCollector MetricsCollector

	// ClassifyRequest does request classification, producing non-parameterized summary for given request.
	ClassifyRequest func(r *http.Request, clientType string) string
}

type MetricsRoundTripperOpts struct {
	// ClientType represents a type of client, it's a service component reference. e.g. 'auth-service'
	ClientType string

	// ClassifyRequest does request classification, producing non-parameterized summary for given request.
	ClassifyRequest func(r *http.Request, clientType string) string
}

type Opts struct {
	// UserAgent is a user agent string.
	UserAgent string

	// AuthProvider provides auth information used for bearer authorization.
	AuthProvider AuthProvider

	// ClientType represents a type of client, it's a service component reference. e.g. 'auth-service'.
	ClientType string

	// Delegate is the next RoundTripper in the chain.
	Delegate http.RoundTripper

	// LoggerProvider is a function that provides a context-specific logger.
	LoggerProvider func(ctx context.Context) log.FieldLogger

	// RequestIDProvider is a function that provides a request ID.
	RequestIDProvider func(ctx context.Context) string

	// MetricsCollector is a metrics collector.
	MetricsCollector MetricsCollector

	// ClassifyRequest does request classification, producing non-parameterized summary in metrics round tripper.
	ClassifyRequest func(r *http.Request, clientType string) string
}

type PrometheusMetricsCollector struct {
	// Durations is a histogram of the http client requests durations.
	Durations *prometheus.HistogramVec
}

type RateLimitingRoundTripper struct {
	Delegate http.RoundTripper

	RateLimit   int
	Burst       int
	WaitTimeout time.Duration
	Adaptation  RateLimitingRoundTripperAdaptation
	// contains filtered or unexported fields
}

type RateLimitingRoundTripperAdaptation struct {
	ResponseHeaderName string
	SlackPercent       int
}

type RateLimitingRoundTripperOpts struct {
	Burst       int
	WaitTimeout time.Duration
	Adaptation  RateLimitingRoundTripperAdaptation
}

type RateLimitingWaitError struct {
	Inner error
}

type RateLimitsConfig struct {
	// Enabled is a flag that enables rate limiting.
	Enabled bool `mapstructure:"enabled" yaml:"enabled" json:"enabled"`

	// Limit is the maximum number of requests that can be made.
	Limit int `mapstructure:"limit" yaml:"limit" json:"limit"`

	// Burst allow temporary spikes in request rate.
	Burst int `mapstructure:"burst" yaml:"burst" json:"burst"`

	// WaitTimeout is the maximum time to wait for a request to be made.
	WaitTimeout config.TimeDuration `mapstructure:"waitTimeout" yaml:"waitTimeout" json:"waitTimeout"`
}

type RequestIDRoundTripper struct {
	// Delegate is the next RoundTripper in the chain.
	Delegate http.RoundTripper

	// Opts are the options for the request ID round tripper.
	Opts RequestIDRoundTripperOpts
}

type RequestIDRoundTripperOpts struct {
	// RequestIDProvider is a function that provides a request ID.
	// middleware.GetRequestIDFromContext is used by default.
	RequestIDProvider func(ctx context.Context) string
}

type RetriesConfig struct {
	// Enabled is a flag that enables retries.
	Enabled bool `mapstructure:"enabled" yaml:"enabled" json:"enabled"`

	// MaxAttempts is the maximum number of attempts to retry the request.
	MaxAttempts int `mapstructure:"maxAttempts" yaml:"maxAttempts" json:"maxAttempts"`

	// Policy of a retry: [exponential, constant].
	Policy RetryPolicy `mapstructure:"policy" yaml:"policy" json:"policy"`

	// ExponentialBackoff is the configuration for exponential backoff.
	ExponentialBackoff ExponentialBackoffConfig `mapstructure:"exponentialBackoff" yaml:"exponentialBackoff" json:"exponentialBackoff"`

	// ConstantBackoff is the configuration for constant backoff.
	ConstantBackoff ConstantBackoffConfig `mapstructure:"constantBackoff" yaml:"constantBackoff" json:"constantBackoff"`
}

type RetryPolicy string

type RetryableRoundTripper struct {
	// Delegate is an object that implements http.RoundTripper interface
	// and is used for sending HTTP requests under the hood.
	Delegate http.RoundTripper

	// Logger is used for logging.
	// Deprecated: use LoggerProvider instead.
	Logger log.FieldLogger

	// LoggerProvider is a function that provides a context-specific logger.
	// One of the typical use cases is to use a retryable client in the context of a request handler,
	// where the logger should produce logs with request-specific information (e.g., request ID).
	LoggerProvider func(ctx context.Context) log.FieldLogger

	// MaxRetryAttempts determines how many maximum retry attempts can be done.
	// The total number of sending HTTP request may be MaxRetryAttempts + 1 (the first request is not a retry attempt).
	// If its value is UnlimitedRetryAttempts, it's supposed that retry mechanism will be stopped by BackoffPolicy.
	// By default, DefaultMaxRetryAttempts const is used.
	MaxRetryAttempts int

	// CheckRetry is called right after RoundTrip() method and determines if the next retry attempt is needed.
	// By default, DefaultCheckRetry function is used.
	CheckRetry CheckRetryFunc

	// IgnoreRetryAfter determines if Retry-After HTTP header of the response is parsed and
	// used as a wait time before doing the next retry attempt.
	// If it's true or response doesn't contain Retry-After HTTP header, BackoffPolicy will be used for computing delay.
	IgnoreRetryAfter bool

	// BackoffPolicy is used for computing wait time before doing the next retry attempt
	// when the given response doesn't contain Retry-After HTTP header or IgnoreRetryAfter is true.
	// By default, DefaultBackoffPolicy is used.
	BackoffPolicy retry.Policy
}

type RetryableRoundTripperError struct {
	Inner error
}

type RetryableRoundTripperOpts struct {
	// Logger is used for logging.
	// Deprecated: use LoggerProvider instead.
	Logger log.FieldLogger

	// LoggerProvider is a function that provides a context-specific logger.
	// One of the typical use cases is to use a retryable client in the context of a request handler,
	// where the logger should produce logs with request-specific information (e.g., request ID).
	LoggerProvider func(ctx context.Context) log.FieldLogger

	// MaxRetryAttempts determines how many maximum retry attempts can be done.
	// The total number of sending HTTP request may be MaxRetryAttempts + 1 (the first request is not a retry attempt).
	// If its value is UnlimitedRetryAttempts, it's supposed that retry mechanism will be stopped by BackoffPolicy.
	// By default, DefaultMaxRetryAttempts const is used.
	MaxRetryAttempts int

	// CheckRetryFunc is called right after RoundTrip() method and determines if the next retry attempt is needed.
	// By default, DefaultCheckRetry function is used.
	CheckRetryFunc CheckRetryFunc

	// IgnoreRetryAfter determines if Retry-After HTTP header of the response is parsed and
	// used as a wait time before doing the next retry attempt.
	// If it's true or response doesn't contain Retry-After HTTP header, BackoffPolicy will be used for computing delay.
	IgnoreRetryAfter bool

	// BackoffPolicy is used for computing wait time before doing the next retry attempt
	// when the given response doesn't contain Retry-After HTTP header or IgnoreRetryAfter is true.
	// By default, DefaultBackoffPolicy is used.
	BackoffPolicy retry.Policy
}

type UserAgentRoundTripper struct {
	Delegate       http.RoundTripper
	UserAgent      string
	UpdateStrategy UserAgentUpdateStrategy
}

type UserAgentRoundTripperOpts struct {
	UpdateStrategy UserAgentUpdateStrategy
}

type UserAgentUpdateStrategy int