commoncfg

type Application struct {
	Name             string            `yaml:"name" json:"name"`
	Environment      string            `yaml:"environment" json:"environment"`
	Labels           map[string]string `yaml:"labels" json:"labels"`
	BuildInfo        BuildInfo
	RuntimeBuildInfo *debug.BuildInfo
}

type Audit struct {
	Endpoint string `yaml:"endpoint" json:"endpoint"`

	HTTPClient HTTPClient `yaml:"httpClient" json:"httpClient"`

	// Optional set of additional properties to be added to OTLP log object. Must be added as a literal string to maintain casing.
	AdditionalProperties string `yaml:"additionalProperties" json:"additionalProperties"`
}

type BaseConfig struct {
	Application  Application  `yaml:"application" json:"application"`
	FeatureGates FeatureGates `yaml:"featureGates" json:"featureGates"`
	Status       Status       `yaml:"status" json:"status"`
	Logger       Logger       `yaml:"logger" json:"logger"`
	Telemetry    Telemetry    `yaml:"telemetry" json:"telemetry"`
	Audit        Audit        `yaml:"audit" json:"audit"`
}

type BasicAuth struct {
	Username SourceRef `yaml:"username" json:"username"`
	Password SourceRef `yaml:"password" json:"password"`
}

type BuildInfo struct {
	Component `mapstructure:",squash" yaml:",inline"`

	Components []Component `json:"components,omitempty"`
}

type Component struct {
	Branch    string `json:"branch,omitempty"`
	Org       string `json:"org,omitempty"`
	Product   string `json:"product,omitempty"`
	Repo      string `json:"repo,omitempty"`
	SHA       string `json:"sha,omitempty"`
	Version   string `json:"version,omitempty"`
	BuildTime string `json:"buildTime,omitempty"`
}

type CredentialFile struct {
	Path     string     `yaml:"path" json:"path"`
	Format   FileFormat `yaml:"format" json:"format"`
	JSONPath string     `yaml:"jsonPath" json:"jsonPath"`
}

type FeatureGates map[string]bool

type FileFormat string

type Flags struct {
	// Reflection is a protocol that gRPC servers can use to declare the protobuf-defined APIs.
	// Reflection is used by debugging tools like grpcurl or grpcui.
	// See https://grpc.io/docs/guides/reflection/.
	Reflection bool `yaml:"reflection" json:"reflection"`
	Health     bool `yaml:"health" json:"health"`
}

type GRPCClient struct {
	Enabled    bool                 `yaml:"enabled" json:"enabled"`
	Address    string               `yaml:"address" json:"address"`
	Attributes GRPCClientAttributes `yaml:"attributes" json:"attributes"`
	Pool       GRPCPool             `yaml:"pool" json:"pool"`
	SecretRef  *SecretRef           `yaml:"secretRef" json:"secretRef"`
}

type GRPCClientAttributes struct {
	//  GRPC KeepaliveTime option
	KeepaliveTime time.Duration `yaml:"keepaliveTime" json:"keepaliveTime" default:"80s"`
	//  GRPC KeepaliveTimeout option
	KeepaliveTimeout time.Duration `yaml:"keepaliveTimeout" json:"keepaliveTimeout" default:"40s"`
}

type GRPCPool struct {
	InitialCapacity int           `yaml:"initialCapacity" json:"initialCapacity" default:"1"`
	MaxCapacity     int           `yaml:"maxCapacity" json:"maxCapacity" default:"1"`
	IdleTimeout     time.Duration `yaml:"idleTimeout" json:"idleTimeout" default:"5s"`
	MaxLifeDuration time.Duration `yaml:"maxLifeDuration" json:"maxLifeDuration" default:"60s"`
}

type GRPCServer struct {
	Enabled bool   `yaml:"enabled" json:"enabled"`
	Address string `yaml:"address" json:"address" default:":9092"`
	Flags   Flags  `yaml:"flags" json:"flags"`
	// MaxSendMsgSize returns a ServerOption to set the max message size in bytes the server can send.
	// If this is not set, gRPC uses the default `2147483647`.
	MaxSendMsgSize int `yaml:"maxSendMsgSize" json:"maxSendMsgSize" default:"2147483647"`
	// MaxRecvMsgSize returns a ServerOption to set the max message size in bytes the server can receive.
	// If this is not set, gRPC uses the default 4MB.
	MaxRecvMsgSize int `yaml:"maxRecvMsgSize" json:"maxRecvMsgSize" default:"125829120"`
	// MinTime is the minimum amount of time a client should wait before sending
	// a keepalive ping.
	EfPolMinTime time.Duration `yaml:"efPolMinTime" json:"efPolMinTime" default:"180s"` // The current default value is 5 minutes.
	// If true, server allows keepalive pings even when there are no active
	// streams(RPCs). If false, and client sends ping when there are no active
	// streams, server will send GOAWAY and close the connection.
	EfPolPermitWithoutStream bool                 `yaml:"efPolPermitWithoutStream" json:"efPolPermitWithoutStream"` // false by default.
	Attributes               GRPCServerAttributes `yaml:"attributes" json:"attributes"`
}

type GRPCServerAttributes struct {
	// MaxConnectionIdle is a duration for the amount of time after which an
	// idle connection would be closed by sending a GoAway. Idleness duration is
	// defined since the most recent time the number of outstanding RPCs became
	// zero or the connection establishment.
	MaxConnectionIdle time.Duration `yaml:"maxConnectionIdle" json:"maxConnectionIdle" default:"1800s"` // The current default value is infinity.
	// MaxConnectionAge is a duration for the maximum amount of time a
	// connection may exist before it will be closed by sending a GoAway. A
	// random jitter of +/-10% will be added to MaxConnectionAge to spread out
	// connection storms.
	MaxConnectionAge time.Duration `yaml:"maxConnectionAge" json:"maxConnectionAge" default:"1800s"` // The current default value is infinity.
	// MaxConnectionAgeGrace is an additive period after MaxConnectionAge after
	// which the connection will be forcibly closed.
	MaxConnectionAgeGrace time.Duration `yaml:"maxConnectionAgeGrace" json:"maxConnectionAgeGrace" default:"300s"` // The current default value is infinity.
	// After a duration of this time if the server doesn't see any activity it
	// pings the client to see if the transport is still alive.
	// If set below 1s, a minimum value of 1s will be used instead.
	Time time.Duration `yaml:"time" json:"time" default:"120m"` // The current default value is 2 hours.
	// After having pinged for keepalive check, the server waits for a duration
	// of Timeout and if no activity is seen even after that the connection is
	// closed.
	Timeout time.Duration `yaml:"timeout" json:"timeout" default:"20s"` // The current default value is 20 seconds.
}

type HTTPClient struct {
	Timeout time.Duration `yaml:"timeout" json:"timeout" default:"10s"`

	//Deprecated [to be replaced by using MTLS]
	RootCAs *SourceRef `yaml:"rootCAs" json:"rootCAs"`
	//Deprecated [to be replaced by using MTLS]
	InsecureSkipVerify bool `yaml:"insecureSkipVerify" json:"insecureSkipVerify"`
	//Deprecated [to be replaced by using MTLS]
	MinVersion uint16 `yaml:"minVersion" json:"minVersion"`
	//Deprecated [to be replaced by using MTLS]
	Cert *SourceRef `yaml:"cert" json:"cert"`
	//Deprecated [to be replaced by using MTLS]
	CertKey *SourceRef `yaml:"certKey" json:"certKey"`

	APIToken            *SourceRef               `yaml:"apiToken" json:"apiToken"`
	BasicAuth           *BasicAuth               `yaml:"basicAuth" json:"basicAuth"`
	OAuth2Auth          *OAuth2                  `yaml:"oauth2Auth" json:"oauth2Auth"`
	MTLS                *MTLS                    `yaml:"mtls" json:"mtls"`
	TransportAttributes *HTTPTransportAttributes `yaml:"transportAttributes" json:"transportAttributes"`
}

type HTTPTransportAttributes struct {
	// TLSHandshakeTimeout specifies the maximum amount of time to
	// wait for a TLS handshake. Zero means no timeout.
	TLSHandshakeTimeout time.Duration `yaml:"tlsHandshakeTimeout" json:"tlsHandshakeTimeout" default:"0s"`

	// DisableKeepAlives, if true, disables HTTP keep-alives and
	// will only use the connection to the server for a single
	// HTTP request.
	//
	// This is unrelated to the similarly named TCP keep-alives.
	DisableKeepAlives bool `yaml:"disableKeepAlives" json:"disableKeepAlives"`

	// DisableCompression, if true, prevents the Transport from
	// requesting compression with an "Accept-Encoding: gzip"
	// request header when the Request contains no existing
	// Accept-Encoding value. If the Transport requests gzip on
	// its own and gets a gzipped response, it's transparently
	// decoded in the Response.Body. However, if the user
	// explicitly requested gzip it is not automatically
	// uncompressed.
	DisableCompression bool `yaml:"disableCompression" json:"disableCompression"`

	// MaxIdleConns controls the maximum number of idle (keep-alive)
	// connections across all hosts. Zero means no limit.
	MaxIdleConns int `yaml:"maxIdleConns" json:"maxIdleConns" default:"0"`

	// MaxIdleConnsPerHost, if non-zero, controls the maximum idle
	// (keep-alive) connections to keep per-host. If zero,
	// DefaultMaxIdleConnsPerHost is used.
	MaxIdleConnsPerHost int `yaml:"maxIdleConnsPerHost" json:"maxIdleConnsPerHost" default:"0"`

	// MaxConnsPerHost optionally limits the total number of
	// connections per host, including connections in the dialing,
	// active, and idle states. On limit violation, dials will block.
	//
	// Zero means no limit.
	MaxConnsPerHost int `yaml:"maxConnsPerHost" json:"maxConnsPerHost" default:"0"`

	// IdleConnTimeout is the maximum amount of time an idle
	// (keep-alive) connection will remain idle before closing
	// itself.
	// Zero means no limit.
	IdleConnTimeout time.Duration `yaml:"idleConnTimeout" json:"idleConnTimeout" default:"0s"`

	// ResponseHeaderTimeout, if non-zero, specifies the amount of
	// time to wait for a server's response headers after fully
	// writing the request (including its body, if any). This
	// time does not include the time to read the response body.
	ResponseHeaderTimeout time.Duration `yaml:"responseHeaderTimeout" json:"responseHeaderTimeout" default:"0s"`

	// ExpectContinueTimeout, if non-zero, specifies the amount of
	// time to wait for a server's first response headers after fully
	// writing the request headers if the request has an
	// "Expect: 100-continue" header. Zero means no timeout and
	// causes the body to be sent immediately, without
	// waiting for the server to approve.
	// This time does not include the time to send the request header.
	ExpectContinueTimeout time.Duration `yaml:"expectContinueTimeout" json:"expectContinueTimeout" default:"0s"`
}

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

type Log struct {
	Enabled   bool      `yaml:"enabled" json:"enabled"`
	Protocol  Protocol  `yaml:"protocol" json:"protocol"`
	Host      SourceRef `yaml:"host" json:"host"`
	URL       string    `yaml:"url" json:"url"`
	SecretRef SecretRef `yaml:"secretRef" json:"secretRef"`
}

type Logger struct {
	Source    bool            `yaml:"source" json:"source"`
	Format    LoggerFormat    `yaml:"format" json:"format" default:"json"`
	Level     string          `yaml:"level" json:"level" default:"info"`
	Formatter LoggerFormatter `yaml:"formatter" json:"formatter"`
}

type LoggerFields struct {
	Time    string              `yaml:"time" json:"time" default:"time"`
	Error   string              `yaml:"error" json:"error" default:"error"`
	Level   string              `yaml:"level" json:"level" default:"info"`
	Message string              `yaml:"message" json:"message" default:"msg"`
	OTel    LoggerOTel          `yaml:"otel" json:"otel"`
	Masking LoggerFieldsMasking `yaml:"masking" json:"masking"`
}

type LoggerFieldsMasking struct {
	PII   []string          `yaml:"pii" json:"pii"`
	Other map[string]string `yaml:"other" json:"other"`
}

type LoggerFormat string

type LoggerFormatter struct {
	Time   LoggerTime   `yaml:"time" json:"time"`
	Fields LoggerFields `yaml:"fields" json:"fields"`
}

type LoggerOTel struct {
	TraceID string `yaml:"traceId" json:"traceId" default:"traceId"`
	SpanID  string `yaml:"spanId" json:"spanId" default:"spanId"`
}

type LoggerTime struct {
	Type      LoggerTimeType `yaml:"type" json:"type" default:"unix"`
	Pattern   string         `yaml:"pattern" json:"pattern" default:"Mon Jan 02 15:04:05 -0700 2006"`
	Precision string         `yaml:"precision" json:"precision" default:"1us"`
}

type LoggerTimeType string

type MTLS struct {
	Cert    SourceRef `yaml:"cert" json:"cert"`
	CertKey SourceRef `yaml:"certKey" json:"certKey"`

	ServerCA *SourceRef  `yaml:"serverCa" json:"serverCa"`
	RootCAs  []SourceRef `yaml:"rootCAs,omitempty" json:"rootCAs,omitempty"`

	Attributes *TLSAttributes `yaml:"attributes" json:"attributes"`
}

type Metric struct {
	Enabled    bool       `yaml:"enabled" json:"enabled"`
	Protocol   Protocol   `yaml:"protocol" json:"protocol"`
	Host       SourceRef  `yaml:"host" json:"host"`
	URL        string     `yaml:"url" json:"url"`
	SecretRef  SecretRef  `yaml:"secretRef" json:"secretRef"`
	Prometheus Prometheus `yaml:"prometheus" json:"prometheus"`
}

type OAuth2 struct {
	URL         *SourceRef        `yaml:"url" json:"url"`
	Credentials OAuth2Credentials `yaml:"credentials" json:"credentials"`
	MTLS        *MTLS             `yaml:"mtls" json:"mtls"`
}

type OAuth2ClientAuthMethod string

type OAuth2Credentials struct {
	ClientID SourceRef `yaml:"clientID" json:"clientID"`

	AuthMethod OAuth2ClientAuthMethod `yaml:"authMethod" json:"authMethod" default:"post"`

	// Option A: client_secret authentication
	ClientSecret *SourceRef `yaml:"clientSecret,omitempty" json:"clientSecret,omitempty"`

	// Option B: private_key_jwt authentication (RFC 7523)
	ClientAssertionType *SourceRef `yaml:"clientAssertionType,omitempty" json:"clientAssertionType,omitempty"`
	ClientAssertion     *SourceRef `yaml:"clientAssertion,omitempty" json:"clientAssertion,omitempty"`
}

type Option func(*Loader)

type Prometheus struct {
	Enabled bool `yaml:"enabled" json:"enabled"`
}

type Protocol string

type SecretRef struct {
	Type     SecretType `yaml:"type" json:"type"`
	MTLS     MTLS       `yaml:"mtls" json:"mtls"`
	APIToken SourceRef  `yaml:"apiToken" json:"apiToken"`
	OAuth2   OAuth2     `yaml:"oauth2" json:"oauth2"`
	Basic    BasicAuth  `yaml:"basic" json:"basic"`
}

type SecretType string

type SourceRef struct {
	Source SourceValueType `yaml:"source" json:"source" default:"embedded"`
	Env    string          `yaml:"env" json:"env"`
	File   CredentialFile  `yaml:"file" json:"file"`
	Value  string          `yaml:"value" json:"value"`
}

type SourceValueType string

type Status struct {
	Enabled bool `yaml:"enabled" json:"enabled"`
	// Status.Address is the address to listen on for status reporting
	Address string `yaml:"address" json:"address" default:":8888"`
	// Timeout defines a timeout duration for all checks
	Timeout time.Duration `yaml:"timeout" json:"timeout" default:"10s"`
	// Status.Profiling enables profiling on the status server
	Profiling bool `yaml:"profiling" json:"profiling"`
}

type TLSAttributes struct {
	// InsecureSkipVerify controls whether a client verifies the server's
	// certificate chain and host name. If InsecureSkipVerify is true, crypto/tls
	// accepts any certificate presented by the server and any host name in that
	// certificate. In this mode, TLS is susceptible to machine-in-the-middle
	// attacks unless custom verification is used. This should be used only for
	// testing or in combination with VerifyConnection or VerifyPeerCertificate.
	InsecureSkipVerify bool `yaml:"insecureSkipVerify" json:"insecureSkipVerify"`
	// ServerName is used to verify the hostname on the returned
	// certificates unless InsecureSkipVerify is given. It is also included
	// in the client's handshake to support virtual hosting unless it is
	// an IP address.
	ServerName string `yaml:"serverName" json:"serverName"`

	// SessionTicketsDisabled may be set to true to disable session ticket and
	// PSK (resumption) support. Note that on clients, session ticket support is
	// also disabled if ClientSessionCache is nil.
	SessionTicketsDisabled bool `yaml:"sessionTicketsDisabled" json:"sessionTicketsDisabled"`

	// DynamicRecordSizingDisabled disables adaptive sizing of TLS records.
	// When true, the largest possible TLS record size is always used. When
	// false, the size of TLS records may be adjusted in an attempt to
	// improve latency.
	DynamicRecordSizingDisabled bool `yaml:"dynamicRecordSizingDisabled" json:"dynamicRecordSizingDisabled"`
}

type Telemetry struct {
	DynatraceOneAgent bool   `yaml:"dynatraceOneAgent" json:"dynatraceOneAgent"`
	Traces            Trace  `yaml:"traces" json:"traces"`
	Metrics           Metric `yaml:"metrics" json:"metrics"`
	Logs              Log    `yaml:"logs" json:"logs"`
}

type Trace struct {
	Enabled   bool      `yaml:"enabled" json:"enabled"`
	Protocol  Protocol  `yaml:"protocol" json:"protocol"`
	Host      SourceRef `yaml:"host" json:"host"`
	URL       string    `yaml:"url" json:"url"`
	SecretRef SecretRef `yaml:"secretRef" json:"secretRef"`
}