connect

type CircuitSetting struct {
	// Timeout is how long to wait for command to complete, in milliseconds
	Timeout int `json:"timeout"`

	// MaxConcurrentRequests is how many commands of the same type can run at the same time
	MaxConcurrentRequests int `json:"max_concurrent_requests"`

	// RequestVolumeThreshold is the minimum number of requests needed before a circuit can be tripped due to health
	RequestVolumeThreshold int `json:"request_volume_threshold"`

	// SleepWindow is how long, in milliseconds, to wait after a circuit opens before testing for recovery
	SleepWindow int `json:"sleep_window"`

	// ErrorPercentThreshold causes circuits to open once the rolling measure of errors exceeds this percent of requests
	ErrorPercentThreshold int `json:"error_percent_threshold"`
}

type CockroachDBConnectionOptions struct {
	PingInterval     time.Duration
	RetryAttempts    int
	MaxIdleConns     int
	MaxOpenConns     int
	ConnMaxLifetime  time.Duration
	LogLevel         string
	UseOpenTelemetry bool
}

type ESErrorLogger struct{}

type ESInfoLogger struct{}

type ESTraceLogger struct{}

type ElasticsearchConnectionOptions struct {
	TLSHandshakeTimeout   time.Duration
	TLSInsecureSkipVerify bool
	MaxIdleConnections    int
	MaxConnsPerHost       int
	SetSniff              bool
	SetHealthcheck        bool
	UseOpenTelemetry      bool
}

type GRPCRateLimiter struct {
	Limit              int64
	Period             time.Duration
	ExcludedIPs        []string
	ExcludedUserAgents []string
}

type GRPCUnaryInterceptorOptions struct {
	// UseCircuitBreaker flag if the connection will implement a circuit breaker
	UseCircuitBreaker bool

	// RetryCount retry the operation if found error.
	// When set to <= 1, then it means no retry
	RetryCount int

	// RetryInterval next interval for retry.
	RetryInterval time.Duration

	// Timeout value, will return context deadline exceeded when the operation exceeds the duration
	Timeout time.Duration

	// UseOpenTelemetry flag if the connection will implement open telemetry
	UseOpenTelemetry bool

	// RateLimiter flag if the connection will implement rate limiter
	RateLimiter *GRPCRateLimiter

	RecoveryHandlerFunc RecoveryHandlerFunc
}

type GormCustomLogger struct {
	gormLogger.Config
}

type HTTPConnectionOptions struct {
	TLSHandshakeTimeout   time.Duration
	TLSInsecureSkipVerify bool
	Timeout               time.Duration
	UseOpenTelemetry      bool
	EnableKeepAlives      bool
}

type HealthCheckService struct{}

type Option func(t *Transport)

type RecoveryHandlerFunc func(ctx context.Context, p interface{}) (err error)

type RedisConnectionPoolOptions struct {
	// Dial timeout for establishing new connections.
	// Default is 5 seconds. Only for go-redis.
	DialTimeout time.Duration

	// Enables read-only commands on slave nodes.
	ReadOnly bool

	// Timeout for socket reads. If reached, commands will fail
	// with a timeout instead of blocking. Use value -1 for no timeout and 0 for default.
	// Default is 3 seconds. Only for go-redis.
	ReadTimeout time.Duration

	// Timeout for socket writes. If reached, commands will fail
	// with a timeout instead of blocking.
	// Default is ReadTimeout. Only for go-redis.
	WriteTimeout time.Duration

	// Number of idle connections in the pool.
	IdleCount int

	// Maximum number of connections allocated by the pool at a given time.
	// When zero, there is no limit on the number of connections in the pool.
	PoolSize int

	// Close connections after remaining idle for this duration. If the value
	// is zero, then idle connections are not closed. Applications should set
	// the timeout to a value less than the server's timeout.
	IdleTimeout time.Duration

	// Close connections older than this duration. If the value is zero, then
	// the pool does not close connections based on age.
	MaxConnLifetime time.Duration
}

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