remnawave-api-go/api/oas_cfg_gen.go

// Code generated by ogen, DO NOT EDIT.

package api

import (
	"context"
	"net/http"

	ht "github.com/ogen-go/ogen/http"
	"github.com/ogen-go/ogen/ogenregex"
	"github.com/ogen-go/ogen/otelogen"
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/attribute"
	"go.opentelemetry.io/otel/metric"
	"go.opentelemetry.io/otel/trace"
)

var regexMap = map[string]ogenregex.Regexp{
	"^(?=.*?[A-Z])(?=.*?[a-z])(?=.*?[0-9]).{24,}$": ogenregex.MustCompile("^(?=.*?[A-Z])(?=.*?[a-z])(?=.*?[0-9]).{24,}$"),
	"^[!#$%&'*+\\-.0-9A-Z^_`a-z|~]+$":              ogenregex.MustCompile("^[!#$%&'*+\\-.0-9A-Z^_`a-z|~]+$"),
	"^[A-Z0-9_:]+$":                                ogenregex.MustCompile("^[A-Z0-9_:]+$"),
	"^[A-Z0-9_]+$":                                 ogenregex.MustCompile("^[A-Z0-9_]+$"),
	"^[A-Za-z0-9_\\s-]+$":                          ogenregex.MustCompile("^[A-Za-z0-9_\\s-]+$"),
	"^[a-zA-Z0-9_-]+$":                             ogenregex.MustCompile("^[a-zA-Z0-9_-]+$"),
}
var (
	// Allocate option closure once.
	clientSpanKind = trace.WithSpanKind(trace.SpanKindClient)
)

type (
	optionFunc[C any] func(*C)
	otelOptionFunc    func(*otelConfig)
)

type otelConfig struct {
	TracerProvider trace.TracerProvider
	Tracer         trace.Tracer
	MeterProvider  metric.MeterProvider
	Meter          metric.Meter
	Attributes     []attribute.KeyValue
}

func (cfg *otelConfig) initOTEL() {
	if cfg.TracerProvider == nil {
		cfg.TracerProvider = otel.GetTracerProvider()
	}
	if cfg.MeterProvider == nil {
		cfg.MeterProvider = otel.GetMeterProvider()
	}
	cfg.Tracer = cfg.TracerProvider.Tracer(otelogen.Name,
		trace.WithInstrumentationVersion(otelogen.SemVersion()),
	)
	cfg.Meter = cfg.MeterProvider.Meter(otelogen.Name,
		metric.WithInstrumentationVersion(otelogen.SemVersion()),
	)
}

type clientConfig struct {
	otelConfig
	// A list of callbacks for modifying requests which are generated before sending over
	// the network.
	RequestEditors []RequestEditor
	// A list of callbacks for modifying response.
	ResponseEditors []ResponseEditor
	Client          ht.Client
}

// ClientOption is client config option.
type ClientOption interface {
	applyClient(*clientConfig)
}

var _ ClientOption = (optionFunc[clientConfig])(nil)

func (o optionFunc[C]) applyClient(c *C) {
	o(c)
}

var _ ClientOption = (otelOptionFunc)(nil)

func (o otelOptionFunc) applyClient(c *clientConfig) {
	o(&c.otelConfig)
}

func newClientConfig(opts ...ClientOption) clientConfig {
	cfg := clientConfig{
		Client: http.DefaultClient,
	}
	for _, opt := range opts {
		opt.applyClient(&cfg)
	}
	cfg.initOTEL()
	return cfg
}

type baseClient struct {
	cfg      clientConfig
	requests metric.Int64Counter
	errors   metric.Int64Counter
	duration metric.Float64Histogram
}

func (cfg clientConfig) baseClient() (c baseClient, err error) {
	c = baseClient{cfg: cfg}
	if c.requests, err = otelogen.ClientRequestCountCounter(c.cfg.Meter); err != nil {
		return c, err
	}
	if c.errors, err = otelogen.ClientErrorsCountCounter(c.cfg.Meter); err != nil {
		return c, err
	}
	if c.duration, err = otelogen.ClientDurationHistogram(c.cfg.Meter); err != nil {
		return c, err
	}
	return c, nil
}

// Option is config option.
type Option interface {
	ClientOption
}

// WithTracerProvider specifies a tracer provider to use for creating a tracer.
//
// If none is specified, the global provider is used.
func WithTracerProvider(provider trace.TracerProvider) Option {
	return otelOptionFunc(func(cfg *otelConfig) {
		if provider != nil {
			cfg.TracerProvider = provider
		}
	})
}

// WithMeterProvider specifies a meter provider to use for creating a meter.
//
// If none is specified, the otel.GetMeterProvider() is used.
func WithMeterProvider(provider metric.MeterProvider) Option {
	return otelOptionFunc(func(cfg *otelConfig) {
		if provider != nil {
			cfg.MeterProvider = provider
		}
	})
}

// WithAttributes specifies default otel attributes.
func WithAttributes(attributes ...attribute.KeyValue) Option {
	return otelOptionFunc(func(cfg *otelConfig) {
		cfg.Attributes = attributes
	})
}

// WithClient specifies http client to use.
func WithClient(client ht.Client) ClientOption {
	return optionFunc[clientConfig](func(cfg *clientConfig) {
		if client != nil {
			cfg.Client = client
		}
	})
}

// RequestEditor is the function signature for the RequestEditor callback function
type RequestEditor func(ctx context.Context, req *http.Request) error

// ResponseEditor is the function signature for the ResponseEditor callback function
type ResponseEditor func(ctx context.Context, resp *http.Response) error

// WithRequestEditor allows setting up a callback function, which will be
// called right before sending the request. This can be used to mutate the request.
func WithRequestEditor(fn RequestEditor) ClientOption {
	return optionFunc[clientConfig](func(cfg *clientConfig) {
		cfg.RequestEditors = append(cfg.RequestEditors, fn)
	})
}

// WithResponseEditor allows setting up a callback function, which will be
// called right after receiving the response. This can be used to mutate the response.
func WithResponseEditor(fn ResponseEditor) ClientOption {
	return optionFunc[clientConfig](func(cfg *clientConfig) {
		cfg.ResponseEditors = append(cfg.ResponseEditors, fn)
	})
}