v1

package
v0.0.0-...-ff19955 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 2, 2025 License: AGPL-3.0 Imports: 8 Imported by: 0

Documentation

Overview

Package v1 contains API Schema definitions for the loki v1 API group +kubebuilder:object:generate=true +groupName=loki.grafana.com

Index

Constants

View Source 
const (
	// StorageSchemaEffectiveDateFormat is the datetime string need to format the time.
	StorageSchemaEffectiveDateFormat = "2006-01-02"
	// StorageSchemaUpdateBuffer is the amount of time used as a buffer to prevent
	// storage schemas from being added too close to midnight in UTC.
	StorageSchemaUpdateBuffer = time.Hour * 2
)
View Source 
const (
	// The AnnotationDisableTenantValidation annotation can contain a boolean value that, if true, disables the tenant-ID validation.
	AnnotationDisableTenantValidation = "loki.grafana.com/disable-tenant-validation"

	// The AnnotationAvailabilityZone annotation contains the availability zone used in the Loki configuration of that pod.
	// It is automatically added to managed Pods by the operator, if needed.
	AnnotationAvailabilityZone = "loki.grafana.com/availability-zone"

	// The AnnotationAvailabilityZoneLabels annotation contains a list of node-labels that are used to construct the availability zone
	// of the annotated Pod. It is used by the zone-awareness controller and automatically added to managed Pods by the operator,
	// if needed.
	AnnotationAvailabilityZoneLabels string = "loki.grafana.com/availability-zone-labels"

	// LabelZoneAwarePod is a pod-label that is added to Pods that should be reconciled by the zone-awareness controller.
	// It is automatically added to managed Pods by the operator, if needed.
	LabelZoneAwarePod string = "loki.grafana.com/zone-aware"
)

Variables

View Source 
var (
	// GroupVersion is group version used to register these objects
	GroupVersion = schema.GroupVersion{Group: "loki.grafana.com", Version: "v1"}

	// SchemeBuilder is used to add go types to the GroupVersionKind scheme
	SchemeBuilder = &scheme.Builder{GroupVersion: GroupVersion}

	// AddToScheme adds the types in this group-version to the given scheme.
	AddToScheme = SchemeBuilder.AddToScheme
)
View Source 
var (
	// ErrGroupNamesNotUnique is the error type when loki groups have not unique names.
	ErrGroupNamesNotUnique = errors.New("Group names are not unique")
	// ErrInvalidRecordMetricName when any loki recording rule has a invalid PromQL metric name.
	ErrInvalidRecordMetricName = errors.New("Failed to parse record metric name")
	// ErrParseAlertForPeriod when any loki alerting rule for period is not a valid PromQL duration.
	ErrParseAlertForPeriod = errors.New("Failed to parse alert firing period")
	// ErrParseEvaluationInterval when any loki group evaluation internal is not a valid PromQL duration.
	ErrParseEvaluationInterval = errors.New("Failed to parse evaluation")
	// ErrParseLogQLExpression when any loki rule expression is not a valid LogQL expression.
	ErrParseLogQLExpression = errors.New("Failed to parse LogQL expression")
	// ErrParseLogQLNotSample when the Loki rule expression does not evaluate to a sample expression.
	ErrParseLogQLNotSample = errors.New("LogQL expression is not a sample query")
	// ErrParseLogQLSelector when the Loki rule expression does not have a valid selector.
	ErrParseLogQLSelector = errors.New("Failed to get selector from LogQL expression")
	// ErrEffectiveDatesNotUnique when effective dates are not unique.
	ErrEffectiveDatesNotUnique = errors.New("Effective dates are not unique")
	// ErrParseEffectiveDates when effective dates cannot be parsed.
	ErrParseEffectiveDates = errors.New("Failed to parse effective date")
	// ErrMissingValidStartDate when a schema list is created without a valid effective date
	ErrMissingValidStartDate = errors.New("Schema does not contain a valid starting effective date")
	// ErrSchemaRetroactivelyAdded when a schema has been retroactively added
	ErrSchemaRetroactivelyAdded = errors.New("Cannot retroactively add schema")
	// ErrSchemaRetroactivelyRemoved when a schema or schemas has been retroactively removed
	ErrSchemaRetroactivelyRemoved = errors.New("Cannot retroactively remove schema(s)")
	// ErrSchemaRetroactivelyChanged when a schema has been retroactively changed
	ErrSchemaRetroactivelyChanged = errors.New("Cannot retroactively change schema")
	// ErrHeaderAuthCredentialsConflict when both Credentials and CredentialsFile are used in a header authentication client.
	ErrHeaderAuthCredentialsConflict = errors.New("credentials and credentialsFile cannot be used at the same time")
	// ErrReplicationZonesNodes when there is an error retrieving nodes with replication zones labels.
	ErrReplicationZonesNodes = errors.New("Failed to retrieve nodes for zone replication")
	// ErrReplicationFactorToZonesRatio when the replication factor defined is greater than the number of available zones.
	ErrReplicationFactorToZonesRatio = errors.New("replication factor is greater than the number of available zones")
	// ErrReplicationSpecConflict when both the ReplicationSpec and depricated ReplicationFactor are used.
	ErrReplicationSpecConflict = errors.New("replicationSpec and replicationFactor (deprecated) cannot be used at the same time")
	// ErrIPv6InstanceAddrTypeNotAllowed when the default InstanceAddrType is used with enableIPv6.
	ErrIPv6InstanceAddrTypeNotAllowed = errors.New(`instanceAddrType "default" cannot be used with enableIPv6 at the same time`)

	// ErrOTLPGlobalNoStreamLabel when the global OTLP configuration does not define at least one stream label.
	ErrOTLPGlobalNoStreamLabel = errors.New("global OTLP configuration needs to define at least one stream label")
	// ErrOTLPTenantMissing when a tenant is missing from the OTLP configuration although it has been defined in the tenancy.
	ErrOTLPTenantMissing = errors.New("if no global OTLP configuration is present which defines at least one stream label, every tenant must have an OTLP configuration")
	// ErrOTLPTenantNoStreamLabel when a tenant is defined but has no stream labels and there also no global stream labels.
	ErrOTLPTenantNoStreamLabel = errors.New("if no global OTLP configuration is present which defines at least one stream label, every tenant must define at least one stream label")

	// ErrRuleMustMatchNamespace indicates that an expression used in an alerting or recording rule is missing
	// matchers for a namespace.
	ErrRuleMustMatchNamespace = errors.New("rule needs to have a matcher for the namespace")
	// ErrSeverityLabelMissing indicates that an alerting rule is missing the severity label
	ErrSeverityLabelMissing = errors.New("rule requires label: severity")
	// ErrSeverityLabelInvalid indicates that an alerting rule has an invalid value for the summary label
	ErrSeverityLabelInvalid = errors.New("rule severity label value invalid, allowed values: critical, warning, info")
	// ErrSummaryAnnotationMissing indicates that an alerting rule is missing the summary annotation
	ErrSummaryAnnotationMissing = errors.New("rule requires annotation: summary")
	// ErrDescriptionAnnotationMissing indicates that an alerting rule is missing the description annotation
	ErrDescriptionAnnotationMissing = errors.New("rule requires annotation: description")
)

Functions

This section is empty.

Types

type AlertManagerClientBasicAuth 

type AlertManagerClientBasicAuth struct {
	// The subject's username for the basic authentication configuration.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Username"
	Username *string `json:"username,omitempty"`

	// The subject's password for the basic authentication configuration.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Password"
	Password *string `json:"password,omitempty"`
}

AlertManagerClientBasicAuth defines the basic authentication configuration for reaching alertmanager endpoints.

func (*AlertManagerClientBasicAuth) DeepCopy 

func (in *AlertManagerClientBasicAuth) DeepCopy() *AlertManagerClientBasicAuth

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AlertManagerClientBasicAuth.

func (*AlertManagerClientBasicAuth) DeepCopyInto 

func (in *AlertManagerClientBasicAuth) DeepCopyInto(out *AlertManagerClientBasicAuth)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type AlertManagerClientConfig 

type AlertManagerClientConfig struct {
	// TLS configuration for reaching the alertmanager endpoints.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:advanced",displayName="TLS"
	TLS *AlertManagerClientTLSConfig `json:"tls,omitempty"`

	// Header authentication configuration for reaching the alertmanager endpoints.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:advanced",displayName="Header Authentication"
	HeaderAuth *AlertManagerClientHeaderAuth `json:"headerAuth,omitempty"`

	// Basic authentication configuration for reaching the alertmanager endpoints.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:advanced",displayName="Basic Authentication"
	BasicAuth *AlertManagerClientBasicAuth `json:"basicAuth,omitempty"`
}

AlertManagerClientConfig defines the client configuration for reaching alertmanager endpoints.

func (*AlertManagerClientConfig) DeepCopy 

func (in *AlertManagerClientConfig) DeepCopy() *AlertManagerClientConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AlertManagerClientConfig.

func (*AlertManagerClientConfig) DeepCopyInto 

func (in *AlertManagerClientConfig) DeepCopyInto(out *AlertManagerClientConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type AlertManagerClientHeaderAuth 

type AlertManagerClientHeaderAuth struct {
	// The authentication type for the header authentication configuration.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Type"
	Type *string `json:"type,omitempty"`

	// The credentials for the header authentication configuration.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Credentials"
	Credentials *string `json:"credentials,omitempty"`

	// The credentials file for the Header authentication configuration. It is mutually exclusive with `credentials`.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Credentials File"
	CredentialsFile *string `json:"credentialsFile,omitempty"`
}

AlertManagerClientHeaderAuth defines the header configuration reaching alertmanager endpoints.

func (*AlertManagerClientHeaderAuth) DeepCopy 

func (in *AlertManagerClientHeaderAuth) DeepCopy() *AlertManagerClientHeaderAuth

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AlertManagerClientHeaderAuth.

func (*AlertManagerClientHeaderAuth) DeepCopyInto 

func (in *AlertManagerClientHeaderAuth) DeepCopyInto(out *AlertManagerClientHeaderAuth)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type AlertManagerClientTLSConfig 

type AlertManagerClientTLSConfig struct {
	// The CA certificate file path for the TLS configuration.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="CA Path"
	CAPath *string `json:"caPath,omitempty"`

	// The server name to validate in the alertmanager server certificates.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Server Name"
	ServerName *string `json:"serverName,omitempty"`

	// The client-side certificate file path for the TLS configuration.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Cert Path"
	CertPath *string `json:"certPath,omitempty"`

	// The client-side key file path for the TLS configuration.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Key Path"
	KeyPath *string `json:"keyPath,omitempty"`

	// Skip validating server certificate.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Skip validating server certificate"
	InsecureSkipVerify *bool `json:"insecureSkipVerify,omitempty"`
}

AlertManagerClientTLSConfig defines the TLS configuration for reaching alertmanager endpoints.

func (*AlertManagerClientTLSConfig) DeepCopy 

func (in *AlertManagerClientTLSConfig) DeepCopy() *AlertManagerClientTLSConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AlertManagerClientTLSConfig.

func (*AlertManagerClientTLSConfig) DeepCopyInto 

func (in *AlertManagerClientTLSConfig) DeepCopyInto(out *AlertManagerClientTLSConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type AlertManagerDiscoverySpec 

type AlertManagerDiscoverySpec struct {
	// Use DNS SRV records to discover Alertmanager hosts.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Enable SRV"
	EnableSRV bool `json:"enableSRV"`

	// How long to wait between refreshing DNS resolutions of Alertmanager hosts.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +kubebuilder:default:="1m"
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Refresh Interval"
	RefreshInterval PrometheusDuration `json:"refreshInterval,omitempty"`
}

AlertManagerDiscoverySpec defines the configuration to use DNS resolution for AlertManager hosts.

func (*AlertManagerDiscoverySpec) DeepCopy 

func (in *AlertManagerDiscoverySpec) DeepCopy() *AlertManagerDiscoverySpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AlertManagerDiscoverySpec.

func (*AlertManagerDiscoverySpec) DeepCopyInto 

func (in *AlertManagerDiscoverySpec) DeepCopyInto(out *AlertManagerDiscoverySpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type AlertManagerNotificationQueueSpec 

type AlertManagerNotificationQueueSpec struct {
	// Capacity of the queue for notifications to be sent to the Alertmanager.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +kubebuilder:default:=10000
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:number",displayName="Notification Queue Capacity"
	Capacity int32 `json:"capacity,omitempty"`

	// HTTP timeout duration when sending notifications to the Alertmanager.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +kubebuilder:default:="10s"
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Timeout"
	Timeout PrometheusDuration `json:"timeout,omitempty"`

	// Max time to tolerate outage for restoring "for" state of alert.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +kubebuilder:default:="1h"
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Outage Tolerance"
	ForOutageTolerance PrometheusDuration `json:"forOutageTolerance,omitempty"`

	// Minimum duration between alert and restored "for" state. This is maintained
	// only for alerts with configured "for" time greater than the grace period.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +kubebuilder:default:="10m"
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Firing Grace Period"
	ForGracePeriod PrometheusDuration `json:"forGracePeriod,omitempty"`

	// Minimum amount of time to wait before resending an alert to Alertmanager.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +kubebuilder:default:="1m"
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Resend Delay"
	ResendDelay PrometheusDuration `json:"resendDelay,omitempty"`
}

AlertManagerNotificationQueueSpec defines the configuration for AlertManager notification settings.

func (*AlertManagerNotificationQueueSpec) DeepCopy 

func (in *AlertManagerNotificationQueueSpec) DeepCopy() *AlertManagerNotificationQueueSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AlertManagerNotificationQueueSpec.

func (*AlertManagerNotificationQueueSpec) DeepCopyInto 

func (in *AlertManagerNotificationQueueSpec) DeepCopyInto(out *AlertManagerNotificationQueueSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type AlertManagerSpec 

type AlertManagerSpec struct {
	// URL for alerts return path.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Alert External URL"
	ExternalURL string `json:"externalUrl,omitempty"`

	// Additional labels to add to all alerts.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Extra Alert Labels"
	ExternalLabels map[string]string `json:"externalLabels,omitempty"`

	// If enabled, then requests to Alertmanager use the v2 API.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:booleanSwitch",displayName="Enable AlertManager V2 API"
	EnableV2 bool `json:"enableV2"`

	// List of AlertManager URLs to send notifications to. Each Alertmanager URL is treated as
	// a separate group in the configuration. Multiple Alertmanagers in HA per group can be
	// supported by using DNS resolution (See EnableDNSDiscovery).
	//
	// +required
	// +kubebuilder:validation:Required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="AlertManager Endpoints"
	Endpoints []string `json:"endpoints"`

	// Defines the configuration for DNS-based discovery of AlertManager hosts.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:advanced",displayName="DNS Discovery"
	DiscoverySpec *AlertManagerDiscoverySpec `json:"discovery,omitempty"`

	// Defines the configuration for the notification queue to AlertManager hosts.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:advanced",displayName="Notification Queue"
	NotificationQueueSpec *AlertManagerNotificationQueueSpec `json:"notificationQueue,omitempty"`

	// List of alert relabel configurations.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Alert Relabel Configuration"
	RelabelConfigs []RelabelConfig `json:"relabelConfigs,omitempty"`

	// Client configuration for reaching the alertmanager endpoint.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="TLS Config"
	Client *AlertManagerClientConfig `json:"client,omitempty"`
}

AlertManagerSpec defines the configuration for ruler's alertmanager connectivity.

func (*AlertManagerSpec) DeepCopy 

func (in *AlertManagerSpec) DeepCopy() *AlertManagerSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AlertManagerSpec.

func (*AlertManagerSpec) DeepCopyInto 

func (in *AlertManagerSpec) DeepCopyInto(out *AlertManagerSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type AlertingRule 

type AlertingRule struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   AlertingRuleSpec   `json:"spec,omitempty"`
	Status AlertingRuleStatus `json:"status,omitempty"`
}

AlertingRule is the Schema for the alertingrules API

+operator-sdk:csv:customresourcedefinitions:displayName="AlertingRule",resources={{LokiStack,v1}}

func (*AlertingRule) DeepCopy 

func (in *AlertingRule) DeepCopy() *AlertingRule

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AlertingRule.

func (*AlertingRule) DeepCopyInto 

func (in *AlertingRule) DeepCopyInto(out *AlertingRule)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*AlertingRule) DeepCopyObject 

func (in *AlertingRule) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*AlertingRule) Hub 

func (*AlertingRule) Hub()

Hub declares the v1.AlertingRule as the hub CRD version.

type AlertingRuleGroup 

type AlertingRuleGroup struct {
	// Name of the alerting rule group. Must be unique within all alerting rules.
	//
	// +required
	// +kubebuilder:validation:Required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Name"
	Name string `json:"name"`

	// Interval defines the time interval between evaluation of the given
	// alerting rule.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +kubebuilder:default:="1m"
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Evaluation Interval"
	Interval PrometheusDuration `json:"interval"`

	// Limit defines the number of alerts an alerting rule can produce. 0 is no limit.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:number",displayName="Limit of firing alerts"
	Limit int32 `json:"limit,omitempty"`

	// Rules defines a list of alerting rules
	//
	// +required
	// +kubebuilder:validation:Required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Rules"
	Rules []*AlertingRuleGroupSpec `json:"rules"`
}

AlertingRuleGroup defines a group of Loki alerting rules.

func (*AlertingRuleGroup) DeepCopy 

func (in *AlertingRuleGroup) DeepCopy() *AlertingRuleGroup

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AlertingRuleGroup.

func (*AlertingRuleGroup) DeepCopyInto 

func (in *AlertingRuleGroup) DeepCopyInto(out *AlertingRuleGroup)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type AlertingRuleGroupSpec 

type AlertingRuleGroupSpec struct {
	// The name of the alert. Must be a valid label value.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Name"
	Alert string `json:"alert,omitempty"`

	// The LogQL expression to evaluate. Every evaluation cycle this is
	// evaluated at the current time, and all resultant time series become
	// pending/firing alerts.
	//
	// +required
	// +kubebuilder:validation:Required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="LogQL Expression"
	Expr string `json:"expr"`

	// Alerts are considered firing once they have been returned for this long.
	// Alerts which have not yet fired for long enough are considered pending.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Firing Threshold"
	For PrometheusDuration `json:"for,omitempty"`

	// Annotations to add to each alert.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Annotations"
	Annotations map[string]string `json:"annotations,omitempty"`

	// Labels to add to each alert.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Labels"
	Labels map[string]string `json:"labels,omitempty"`
}

AlertingRuleGroupSpec defines the spec for a Loki alerting rule.

func (*AlertingRuleGroupSpec) DeepCopy 

func (in *AlertingRuleGroupSpec) DeepCopy() *AlertingRuleGroupSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AlertingRuleGroupSpec.

func (*AlertingRuleGroupSpec) DeepCopyInto 

func (in *AlertingRuleGroupSpec) DeepCopyInto(out *AlertingRuleGroupSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type AlertingRuleList 

type AlertingRuleList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []AlertingRule `json:"items"`
}

AlertingRuleList contains a list of AlertingRule

func (*AlertingRuleList) DeepCopy 

func (in *AlertingRuleList) DeepCopy() *AlertingRuleList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AlertingRuleList.

func (*AlertingRuleList) DeepCopyInto 

func (in *AlertingRuleList) DeepCopyInto(out *AlertingRuleList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*AlertingRuleList) DeepCopyObject 

func (in *AlertingRuleList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type AlertingRuleSpec 

type AlertingRuleSpec struct {
	// TenantID of tenant where the alerting rules are evaluated in.
	//
	// +required
	// +kubebuilder:validation:Required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Tenant ID"
	TenantID string `json:"tenantID"`

	// List of groups for alerting rules.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Groups"
	Groups []*AlertingRuleGroup `json:"groups"`
}

AlertingRuleSpec defines the desired state of AlertingRule

func (*AlertingRuleSpec) DeepCopy 

func (in *AlertingRuleSpec) DeepCopy() *AlertingRuleSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AlertingRuleSpec.

func (*AlertingRuleSpec) DeepCopyInto 

func (in *AlertingRuleSpec) DeepCopyInto(out *AlertingRuleSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type AlertingRuleStatus 

type AlertingRuleStatus struct {
	// Conditions of the AlertingRule generation health.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=status,xDescriptors="urn:alm:descriptor:io.kubernetes.conditions"
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

AlertingRuleStatus defines the observed state of AlertingRule

func (*AlertingRuleStatus) DeepCopy 

func (in *AlertingRuleStatus) DeepCopy() *AlertingRuleStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AlertingRuleStatus.

func (*AlertingRuleStatus) DeepCopyInto 

func (in *AlertingRuleStatus) DeepCopyInto(out *AlertingRuleStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type AuthenticationSpec 

type AuthenticationSpec struct {
	// TenantName defines the name of the tenant.
	//
	// +required
	// +kubebuilder:validation:Required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Tenant Name"
	TenantName string `json:"tenantName"`
	// TenantID defines the id of the tenant.
	//
	// +required
	// +kubebuilder:validation:Required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Tenant ID"
	TenantID string `json:"tenantId"`
	// OIDC defines the spec for the OIDC tenant's authentication.
	//
	// +optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="OIDC Configuration"
	OIDC *OIDCSpec `json:"oidc,omitempty"`

	// TLSConfig defines the spec for the mTLS tenant's authentication.
	//
	// +optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="mTLS Configuration"
	MTLS *MTLSSpec `json:"mTLS,omitempty"`
}

AuthenticationSpec defines the oidc configuration per tenant for lokiStack Gateway component.

func (*AuthenticationSpec) DeepCopy 

func (in *AuthenticationSpec) DeepCopy() *AuthenticationSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AuthenticationSpec.

func (*AuthenticationSpec) DeepCopyInto 

func (in *AuthenticationSpec) DeepCopyInto(out *AuthenticationSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type AuthorizationSpec 

type AuthorizationSpec struct {
	// OPA defines the spec for the third-party endpoint for tenant's authorization.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="OPA Configuration"
	OPA *OPASpec `json:"opa"`
	// Roles defines a set of permissions to interact with a tenant.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Static Roles"
	Roles []RoleSpec `json:"roles"`
	// RoleBindings defines configuration to bind a set of roles to a set of subjects.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Static Role Bindings"
	RoleBindings []RoleBindingsSpec `json:"roleBindings"`
}

AuthorizationSpec defines the opa, role bindings and roles configuration per tenant for lokiStack Gateway component.

func (*AuthorizationSpec) DeepCopy 

func (in *AuthorizationSpec) DeepCopy() *AuthorizationSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new AuthorizationSpec.

func (*AuthorizationSpec) DeepCopyInto 

func (in *AuthorizationSpec) DeepCopyInto(out *AuthorizationSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type BlockedQuerySpec 

type BlockedQuerySpec struct {
	// Hash is a 32-bit FNV-1 hash of the query string.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:number",displayName="Query Hash"
	Hash int32 `json:"hash,omitempty"`
	// Pattern defines the pattern matching the queries to be blocked.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Query Pattern"
	Pattern string `json:"pattern,omitempty"`
	// Regex defines if the pattern is a regular expression. If false the pattern will be used only for exact matches.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:booleanSwitch",displayName="Regex"
	Regex bool `json:"regex,omitempty"`
	// Types defines the list of query types that should be considered for blocking.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Query Types"
	Types BlockedQueryTypes `json:"types,omitempty"`
}

BlockedQuerySpec defines the rule spec for queries to be blocked.

+kubebuilder:validation:MinProperties:=1

func (*BlockedQuerySpec) DeepCopy 

func (in *BlockedQuerySpec) DeepCopy() *BlockedQuerySpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new BlockedQuerySpec.

func (*BlockedQuerySpec) DeepCopyInto 

func (in *BlockedQuerySpec) DeepCopyInto(out *BlockedQuerySpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type BlockedQueryType 

type BlockedQueryType string

BlockedQueryType defines which type of query a blocked query should apply to.

+kubebuilder:validation:Enum=filter;limited;metric 

const (
	// BlockedQueryFilter is used, when the blocked query should apply to queries using a log filter.
	BlockedQueryFilter BlockedQueryType = "filter"
	// BlockedQueryLimited is used, when the blocked query should apply to queries without a filter or a metric aggregation.
	BlockedQueryLimited BlockedQueryType = "limited"
	// BlockedQueryMetric is used, when the blocked query should apply to queries with an aggregation.
	BlockedQueryMetric BlockedQueryType = "metric"
)

type BlockedQueryTypes 

type BlockedQueryTypes []BlockedQueryType

BlockedQueryTypes defines a slice of BlockedQueryType values to be used for a blocked query.

func (BlockedQueryTypes) DeepCopy 

func (in BlockedQueryTypes) DeepCopy() BlockedQueryTypes

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new BlockedQueryTypes.

func (BlockedQueryTypes) DeepCopyInto 

func (in BlockedQueryTypes) DeepCopyInto(out *BlockedQueryTypes)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (BlockedQueryTypes) String 

func (t BlockedQueryTypes) String() string

type CASpec 

type CASpec struct {
	// Key is the data key of a ConfigMap containing a CA certificate.
	// It needs to be in the same namespace as the LokiStack custom resource.
	// If empty, it defaults to "service-ca.crt".
	//
	// +optional
	// +kubebuilder:validation:optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="CA ConfigMap Key"
	CAKey string `json:"caKey,omitempty"`
	// CA is the name of a ConfigMap containing a CA certificate.
	// It needs to be in the same namespace as the LokiStack custom resource.
	//
	// +required
	// +kubebuilder:validation:required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:io.kubernetes:ConfigMap",displayName="CA ConfigMap Name"
	CA string `json:"caName"`
}

func (*CASpec) DeepCopy 

func (in *CASpec) DeepCopy() *CASpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new CASpec.

func (*CASpec) DeepCopyInto 

func (in *CASpec) DeepCopyInto(out *CASpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ClusterProxy 

type ClusterProxy struct {
	// HTTPProxy configures the HTTP_PROXY/http_proxy env variable.
	//
	// +optional
	// +kubebuilder:validation:optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="HTTPProxy"
	HTTPProxy string `json:"httpProxy,omitempty"`
	// HTTPSProxy configures the HTTPS_PROXY/https_proxy env variable.
	//
	// +optional
	// +kubebuilder:validation:optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="HTTPSProxy"
	HTTPSProxy string `json:"httpsProxy,omitempty"`
	// NoProxy configures the NO_PROXY/no_proxy env variable.
	//
	// +optional
	// +kubebuilder:validation:optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="NoProxy"
	NoProxy string `json:"noProxy,omitempty"`
}

ClusterProxy is the Proxy configuration when the cluster is behind a Proxy.

func (*ClusterProxy) DeepCopy 

func (in *ClusterProxy) DeepCopy() *ClusterProxy

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ClusterProxy.

func (*ClusterProxy) DeepCopyInto 

func (in *ClusterProxy) DeepCopyInto(out *ClusterProxy)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type CredentialMode 

type CredentialMode string

CredentialMode represents the type of authentication used for accessing the object storage.

+kubebuilder:validation:Enum=static;token;token-cco 

const (
	// CredentialModeStatic represents the usage of static, long-lived credentials stored in a Secret.
	// This is the default authentication mode and available for all supported object storage types.
	CredentialModeStatic CredentialMode = "static"
	// CredentialModeToken represents the usage of short-lived tokens retrieved from a credential source.
	// In this mode the static configuration does not contain credentials needed for the object storage.
	// Instead, they are generated during runtime using a service, which allows for shorter-lived credentials and
	// much more granular control. This authentication mode is not supported for all object storage types.
	CredentialModeToken CredentialMode = "token"
	// CredentialModeTokenCCO represents the usage of short-lived tokens retrieved from a credential source.
	// This mode is similar to CredentialModeToken, but instead of having a user-configured credential source,
	// it is configured by the environment and the operator relies on the Cloud Credential Operator to provide
	// a secret. This mode is only supported for certain object storage types in certain runtime environments.
	CredentialModeTokenCCO CredentialMode = "token-cco"
)

type HashRingSpec 

type HashRingSpec struct {
	// Type of hash ring implementation that should be used
	//
	// +required
	// +kubebuilder:validation:Required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors={"urn:alm:descriptor:com.tectonic.ui:select:memberlist"},displayName="Type"
	// +kubebuilder:default:=memberlist
	Type HashRingType `json:"type"`

	// MemberList configuration spec
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Memberlist Config"
	MemberList *MemberListSpec `json:"memberlist,omitempty"`
}

HashRingSpec defines the hash ring configuration

func (*HashRingSpec) DeepCopy 

func (in *HashRingSpec) DeepCopy() *HashRingSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new HashRingSpec.

func (*HashRingSpec) DeepCopyInto 

func (in *HashRingSpec) DeepCopyInto(out *HashRingSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type HashRingType 

type HashRingType string

HashRingType defines the type of hash ring which can be used with the Loki cluster.

+kubebuilder:validation:Enum=memberlist 

const (
	// HashRingMemberList when using memberlist for the distributed hash ring.
	HashRingMemberList HashRingType = "memberlist"
)

type IngestionLimitSpec 

type IngestionLimitSpec struct {
	// IngestionRate defines the sample size per second. Units MB.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:number",displayName="Ingestion Rate (in MB)"
	IngestionRate int32 `json:"ingestionRate,omitempty"`

	// IngestionBurstSize defines the local rate-limited sample size per
	// distributor replica. It should be set to the set at least to the
	// maximum logs size expected in a single push request.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:number",displayName="Ingestion Burst Size (in MB)"
	IngestionBurstSize int32 `json:"ingestionBurstSize,omitempty"`

	// MaxLabelNameLength defines the maximum number of characters allowed
	// for label keys in log streams.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:number",displayName="Max Label Name Length"
	MaxLabelNameLength int32 `json:"maxLabelNameLength,omitempty"`

	// MaxLabelValueLength defines the maximum number of characters allowed
	// for label values in log streams.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:number",displayName="Max Label Value Length"
	MaxLabelValueLength int32 `json:"maxLabelValueLength,omitempty"`

	// MaxLabelNamesPerSeries defines the maximum number of label names per series
	// in each log stream.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:number",displayName="Max Labels Names per Series"
	MaxLabelNamesPerSeries int32 `json:"maxLabelNamesPerSeries,omitempty"`

	// MaxGlobalStreamsPerTenant defines the maximum number of active streams
	// per tenant, across the cluster.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:number",displayName="Max Global Streams per  Tenant"
	MaxGlobalStreamsPerTenant int32 `json:"maxGlobalStreamsPerTenant,omitempty"`

	// MaxLineSize defines the maximum line size on ingestion path. Units in Bytes.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:number",displayName="Max Line Size"
	MaxLineSize int32 `json:"maxLineSize,omitempty"`

	// PerStreamDesiredRate defines the desired ingestion rate per second that LokiStack should
	// target applying automatic stream sharding. Units MB.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:number",displayName="Per Stream Desired Rate (in MB)"
	PerStreamDesiredRate int32 `json:"perStreamDesiredRate,omitempty"`

	// PerStreamRateLimit defines the maximum byte rate per second per stream. Units MB.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:number",displayName="Maximum byte rate per second per stream (in MB)"
	PerStreamRateLimit int32 `json:"perStreamRateLimit,omitempty"`

	// PerStreamRateLimitBurst defines the maximum burst bytes per stream. Units MB.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:number",displayName="Maximum burst bytes per stream (in MB)"
	PerStreamRateLimitBurst int32 `json:"perStreamRateLimitBurst,omitempty"`
}

IngestionLimitSpec defines the limits applied at the ingestion path.

func (*IngestionLimitSpec) DeepCopy 

func (in *IngestionLimitSpec) DeepCopy() *IngestionLimitSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new IngestionLimitSpec.

func (*IngestionLimitSpec) DeepCopyInto 

func (in *IngestionLimitSpec) DeepCopyInto(out *IngestionLimitSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type InstanceAddrType 

type InstanceAddrType string

InstanceAddrType defines the type of pod network to use for advertising IPs to the ring.

+kubebuilder:validation:Enum=default;podIP 

const (
	// InstanceAddrDefault when using the first from any private network interfaces (RFC 1918 and RFC 6598).
	InstanceAddrDefault InstanceAddrType = "default"
	// InstanceAddrPodIP when using the public pod IP from the cluster's pod network.
	InstanceAddrPodIP InstanceAddrType = "podIP"
)

type LimitsSpec 

type LimitsSpec struct {
	// Global defines the limits applied globally across the cluster.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Global Limits"
	Global *LimitsTemplateSpec `json:"global,omitempty"`

	// Tenants defines the limits applied per tenant.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Limits per Tenant"
	Tenants map[string]PerTenantLimitsTemplateSpec `json:"tenants,omitempty"`
}

LimitsSpec defines the spec for limits applied at ingestion or query path across the cluster or per tenant.

func (*LimitsSpec) DeepCopy 

func (in *LimitsSpec) DeepCopy() *LimitsSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LimitsSpec.

func (*LimitsSpec) DeepCopyInto 

func (in *LimitsSpec) DeepCopyInto(out *LimitsSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type LimitsTemplateSpec 

type LimitsTemplateSpec struct {
	// IngestionLimits defines the limits applied on ingested log streams.
	//
	// +optional
	// +kubebuilder:validation:Optional
	IngestionLimits *IngestionLimitSpec `json:"ingestion,omitempty"`

	// QueryLimits defines the limit applied on querying log streams.
	//
	// +optional
	// +kubebuilder:validation:Optional
	QueryLimits *QueryLimitSpec `json:"queries,omitempty"`

	// OTLP to configure which resource, scope and log attributes are stored as stream labels or structured metadata.
	//
	// Tenancy modes can provide a default OTLP configuration, when no custom OTLP configuration is set or even
	// enforce the use of some required attributes.
	//
	// +optional
	// +kubebuilder:validation:Optional
	OTLP *OTLPSpec `json:"otlp,omitempty"`

	// Retention defines how long logs are kept in storage.
	//
	// +optional
	// +kubebuilder:validation:Optional
	Retention *RetentionLimitSpec `json:"retention,omitempty"`
}

LimitsTemplateSpec defines the limits applied at ingestion or query path.

func (*LimitsTemplateSpec) DeepCopy 

func (in *LimitsTemplateSpec) DeepCopy() *LimitsTemplateSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LimitsTemplateSpec.

func (*LimitsTemplateSpec) DeepCopyInto 

func (in *LimitsTemplateSpec) DeepCopyInto(out *LimitsTemplateSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type LokiComponentSpec 

type LokiComponentSpec struct {
	// Replicas defines the number of replica pods of the component.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:hidden"
	Replicas int32 `json:"replicas,omitempty"`

	// NodeSelector defines the labels required by a node to schedule
	// the component onto it.
	//
	// +optional
	// +kubebuilder:validation:Optional
	NodeSelector map[string]string `json:"nodeSelector,omitempty"`

	// Tolerations defines the tolerations required by a node to schedule
	// the component onto it.
	//
	// +optional
	// +kubebuilder:validation:Optional
	Tolerations []corev1.Toleration `json:"tolerations,omitempty"`

	// PodAntiAffinity defines the pod anti affinity scheduling rules to schedule pods
	// of a component.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:podAntiAffinity",displayName="PodAntiAffinity"
	PodAntiAffinity *corev1.PodAntiAffinity `json:"podAntiAffinity,omitempty"`
}

LokiComponentSpec defines the requirements to configure scheduling of each loki component individually.

func (*LokiComponentSpec) DeepCopy 

func (in *LokiComponentSpec) DeepCopy() *LokiComponentSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LokiComponentSpec.

func (*LokiComponentSpec) DeepCopyInto 

func (in *LokiComponentSpec) DeepCopyInto(out *LokiComponentSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type LokiStack 

type LokiStack struct {
	// LokiStack CR spec field.
	Spec LokiStackSpec `json:"spec,omitempty"`
	// LokiStack CR spec Status.
	Status            LokiStackStatus `json:"status,omitempty"`
	metav1.ObjectMeta `json:"metadata,omitempty"`
	metav1.TypeMeta   `json:",inline"`
}

LokiStack is the Schema for the lokistacks API

+operator-sdk:csv:customresourcedefinitions:displayName="LokiStack",resources={{Deployment,v1},{StatefulSet,v1},{ConfigMap,v1},{Ingress,v1},{Service,v1},{ServiceAccount,v1},{PersistentVolumeClaims,v1},{Route,v1},{ServiceMonitor,v1}}

func (*LokiStack) DeepCopy 

func (in *LokiStack) DeepCopy() *LokiStack

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LokiStack.

func (*LokiStack) DeepCopyInto 

func (in *LokiStack) DeepCopyInto(out *LokiStack)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*LokiStack) DeepCopyObject 

func (in *LokiStack) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*LokiStack) Hub 

func (*LokiStack) Hub()

Hub declares the v1.LokiStack as the hub CRD version.

type LokiStackComponentStatus 

type LokiStackComponentStatus struct {
	// Compactor is a map to the pod status of the compactor pod.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=status,xDescriptors="urn:alm:descriptor:com.tectonic.ui:podStatuses",displayName="Compactor",order=5
	Compactor PodStatusMap `json:"compactor,omitempty"`

	// Distributor is a map to the per pod status of the distributor deployment
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=status,xDescriptors="urn:alm:descriptor:com.tectonic.ui:podStatuses",displayName="Distributor",order=1
	Distributor PodStatusMap `json:"distributor,omitempty"`

	// IndexGateway is a map to the per pod status of the index gateway statefulset
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=status,xDescriptors="urn:alm:descriptor:com.tectonic.ui:podStatuses",displayName="IndexGateway",order=6
	IndexGateway PodStatusMap `json:"indexGateway,omitempty"`

	// Ingester is a map to the per pod status of the ingester statefulset
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=status,xDescriptors="urn:alm:descriptor:com.tectonic.ui:podStatuses",displayName="Ingester",order=2
	Ingester PodStatusMap `json:"ingester,omitempty"`

	// Querier is a map to the per pod status of the querier deployment
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=status,xDescriptors="urn:alm:descriptor:com.tectonic.ui:podStatuses",displayName="Querier",order=3
	Querier PodStatusMap `json:"querier,omitempty"`

	// QueryFrontend is a map to the per pod status of the query frontend deployment
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=status,xDescriptors="urn:alm:descriptor:com.tectonic.ui:podStatuses",displayName="Query Frontend",order=4
	QueryFrontend PodStatusMap `json:"queryFrontend,omitempty"`

	// Gateway is a map to the per pod status of the lokistack gateway deployment.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=status,xDescriptors="urn:alm:descriptor:com.tectonic.ui:podStatuses",displayName="Gateway",order=5
	Gateway PodStatusMap `json:"gateway,omitempty"`

	// Ruler is a map to the per pod status of the lokistack ruler statefulset.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=status,xDescriptors="urn:alm:descriptor:com.tectonic.ui:podStatuses",displayName="Ruler",order=6
	Ruler PodStatusMap `json:"ruler,omitempty"`
}

LokiStackComponentStatus defines the map of per pod status per LokiStack component. Each component is represented by a separate map of v1.Phase to a list of pods.

func (*LokiStackComponentStatus) DeepCopy 

func (in *LokiStackComponentStatus) DeepCopy() *LokiStackComponentStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LokiStackComponentStatus.

func (*LokiStackComponentStatus) DeepCopyInto 

func (in *LokiStackComponentStatus) DeepCopyInto(out *LokiStackComponentStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type LokiStackConditionReason 

type LokiStackConditionReason string

LokiStackConditionReason defines the type for valid reasons of a Loki deployment conditions. 

const (
	// ReasonFailedComponents when all/some LokiStack components fail to roll out.
	ReasonFailedComponents LokiStackConditionReason = "FailedComponents"
	// ReasonPendingComponents when all/some LokiStack components pending dependencies
	ReasonPendingComponents LokiStackConditionReason = "PendingComponents"
	// ReasonReadyComponents when all LokiStack components are ready to serve traffic.
	ReasonReadyComponents LokiStackConditionReason = "ReadyComponents"
	// ReasonMissingObjectStorageSecret when the required secret to store logs to object
	// storage is missing.
	ReasonMissingObjectStorageSecret LokiStackConditionReason = "MissingObjectStorageSecret"
	// ReasonInvalidObjectStorageSecret when the format of the secret is invalid.
	ReasonInvalidObjectStorageSecret LokiStackConditionReason = "InvalidObjectStorageSecret"
	// ReasonMissingTokenCCOAuthSecret when the secret generated by CCO for token authentication is missing.
	// This is usually a transient error because the secret is not immediately available after creating the
	// CredentialsRequest, but it can persist if the CCO or its configuration are incorrect.
	ReasonMissingTokenCCOAuthSecret LokiStackConditionReason = "MissingTokenCCOAuthenticationSecret"
	// ReasonInvalidObjectStorageSchema when the spec contains an invalid schema(s).
	ReasonInvalidObjectStorageSchema LokiStackConditionReason = "InvalidObjectStorageSchema"
	// ReasonMissingObjectStorageCAConfigMap when the required configmap to verify object storage
	// certificates is missing.
	ReasonMissingObjectStorageCAConfigMap LokiStackConditionReason = "MissingObjectStorageCAConfigMap"
	// ReasonInvalidObjectStorageCAConfigMap when the format of the CA configmap is invalid.
	ReasonInvalidObjectStorageCAConfigMap LokiStackConditionReason = "InvalidObjectStorageCAConfigMap"
	// ReasonMissingRulerSecret when the required secret to authorization remote write connections
	// for the ruler is missing.
	ReasonMissingRulerSecret LokiStackConditionReason = "MissingRulerSecret"
	// ReasonInvalidRulerSecret when the format of the ruler remote write authorization secret is invalid.
	ReasonInvalidRulerSecret LokiStackConditionReason = "InvalidRulerSecret"
	// ReasonInvalidReplicationConfiguration when the configurated replication factor is not valid
	// with the select cluster size.
	ReasonInvalidReplicationConfiguration LokiStackConditionReason = "InvalidReplicationConfiguration"
	// ReasonMissingGatewayTenantSecret when the required tenant secret
	// for authentication is missing.
	ReasonMissingGatewayTenantSecret LokiStackConditionReason = "MissingGatewayTenantSecret"
	// ReasonMissingGatewayTenantConfigMap when the required tenant configmap
	// for authentication is missing.
	ReasonMissingGatewayTenantConfigMap LokiStackConditionReason = "MissingGatewayTenantConfigMap"
	// ReasonInvalidGatewayTenantSecret when the format of the secret is invalid.
	ReasonInvalidGatewayTenantSecret LokiStackConditionReason = "InvalidGatewayTenantSecret"
	// ReasonInvalidGatewayTenantConfigMap when the format of the configmap is invalid.
	ReasonInvalidGatewayTenantConfigMap LokiStackConditionReason = "InvalidGatewayTenantConfigMap"
	// ReasonMissingGatewayAuthenticationConfig when the config for when a tenant is missing authentication config
	ReasonMissingGatewayAuthenticationConfig LokiStackConditionReason = "MissingGatewayTenantAuthenticationConfig"
	// ReasonInvalidTenantsConfiguration when the tenant configuration provided is invalid.
	ReasonInvalidTenantsConfiguration LokiStackConditionReason = "InvalidTenantsConfiguration"
	// ReasonMissingGatewayOpenShiftBaseDomain when the reconciler cannot lookup the OpenShift DNS base domain.
	ReasonMissingGatewayOpenShiftBaseDomain LokiStackConditionReason = "MissingGatewayOpenShiftBaseDomain"
	// ReasonFailedCertificateRotation when the reconciler cannot rotate any of the required TLS certificates.
	ReasonFailedCertificateRotation LokiStackConditionReason = "FailedCertificateRotation"
	// ReasonQueryTimeoutInvalid when the QueryTimeout can not be parsed.
	ReasonQueryTimeoutInvalid LokiStackConditionReason = "ReasonQueryTimeoutInvalid"
	// ReasonZoneAwareNodesMissing when the cluster does not contain any nodes with the labels needed for zone-awareness.
	ReasonZoneAwareNodesMissing LokiStackConditionReason = "ReasonZoneAwareNodesMissing"
	// ReasonZoneAwareEmptyLabel when the node-label used for zone-awareness has an empty value.
	ReasonZoneAwareEmptyLabel LokiStackConditionReason = "ReasonZoneAwareEmptyLabel"
	// ReasonStorageNeedsSchemaUpdate when the object storage schema version is older than V13
	ReasonStorageNeedsSchemaUpdate LokiStackConditionReason = "StorageNeedsSchemaUpdate"
)

type LokiStackConditionType 

type LokiStackConditionType string

LokiStackConditionType deifnes the type of condition types of a Loki deployment. 

const (
	// ConditionReady defines the condition that all components in the Loki deployment are ready.
	ConditionReady LokiStackConditionType = "Ready"

	// ConditionPending defines the condition that some or all components are in pending state.
	ConditionPending LokiStackConditionType = "Pending"

	// ConditionFailed defines the condition that components in the Loki deployment failed to roll out.
	ConditionFailed LokiStackConditionType = "Failed"

	// ConditionDegraded defines the condition that some or all components in the Loki deployment
	// are degraded or the cluster cannot connect to object storage.
	ConditionDegraded LokiStackConditionType = "Degraded"

	// ConditionWarning is used for configurations that are not recommended, but don't currently cause
	// issues. There can be multiple warning conditions active at a time.
	ConditionWarning LokiStackConditionType = "Warning"
)

type LokiStackList 

type LokiStackList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []LokiStack `json:"items"`
}

LokiStackList contains a list of LokiStack

func (*LokiStackList) DeepCopy 

func (in *LokiStackList) DeepCopy() *LokiStackList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LokiStackList.

func (*LokiStackList) DeepCopyInto 

func (in *LokiStackList) DeepCopyInto(out *LokiStackList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*LokiStackList) DeepCopyObject 

func (in *LokiStackList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type LokiStackSizeType 

type LokiStackSizeType string

LokiStackSizeType declares the type for loki cluster scale outs.

+kubebuilder:validation:Enum="1x.demo";"1x.pico";"1x.extra-small";"1x.small";"1x.medium" 

const (
	// SizeOneXDemo defines the size of a single Loki deployment
	// with tiny resource requirements and without HA support.
	// This size is intended to run in single-node clusters on laptops,
	// it is only useful for very light testing, demonstrations, or prototypes.
	// There are no ingestion/query performance guarantees.
	// DO NOT USE THIS IN PRODUCTION!
	SizeOneXDemo LokiStackSizeType = "1x.demo"

	// SizeOneXPico defines the size of a single Loki deployment
	// with extra small resources/limits requirements and HA support for all
	// Loki components. This size is dedicated for setup **without** the
	// requirement for single replication factor and auto-compaction.
	//
	// FIXME: Add clear description of ingestion/query performance expectations.
	SizeOneXPico LokiStackSizeType = "1x.pico"

	// SizeOneXExtraSmall defines the size of a single Loki deployment
	// with extra small resources/limits requirements and HA support for all
	// Loki components. This size is dedicated for setup **without** the
	// requirement for single replication factor and auto-compaction.
	//
	// FIXME: Add clear description of ingestion/query performance expectations.
	SizeOneXExtraSmall LokiStackSizeType = "1x.extra-small"

	// SizeOneXSmall defines the size of a single Loki deployment
	// with small resources/limits requirements and HA support for all
	// Loki components. This size is dedicated for setup **without** the
	// requirement for single replication factor and auto-compaction.
	//
	// FIXME: Add clear description of ingestion/query performance expectations.
	SizeOneXSmall LokiStackSizeType = "1x.small"

	// SizeOneXMedium defines the size of a single Loki deployment
	// with small resources/limits requirements and HA support for all
	// Loki components. This size is dedicated for setup **with** the
	// requirement for single replication factor and auto-compaction.
	//
	// FIXME: Add clear description of ingestion/query performance expectations.
	SizeOneXMedium LokiStackSizeType = "1x.medium"
)

type LokiStackSpec 

type LokiStackSpec struct {
	// ManagementState defines if the CR should be managed by the operator or not.
	// Default is managed.
	//
	// +optional
	// +kubebuilder:validation:optional
	// +kubebuilder:default:=Managed
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors={"urn:alm:descriptor:com.tectonic.ui:select:Managed","urn:alm:descriptor:com.tectonic.ui:select:Unmanaged"},displayName="Management State"
	ManagementState ManagementStateType `json:"managementState,omitempty"`

	// Size defines one of the support Loki deployment scale out sizes.
	//
	// +required
	// +kubebuilder:validation:Required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors={"urn:alm:descriptor:com.tectonic.ui:select:1x.pico","urn:alm:descriptor:com.tectonic.ui:select:1x.extra-small","urn:alm:descriptor:com.tectonic.ui:select:1x.small","urn:alm:descriptor:com.tectonic.ui:select:1x.medium"},displayName="LokiStack Size"
	Size LokiStackSizeType `json:"size"`

	// HashRing defines the spec for the distributed hash ring configuration.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:advanced",displayName="Hash Ring"
	HashRing *HashRingSpec `json:"hashRing,omitempty"`

	// Storage defines the spec for the object storage endpoint to store logs.
	//
	// +required
	// +kubebuilder:validation:Required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Object Storage"
	Storage ObjectStorageSpec `json:"storage"`

	// Storage class name defines the storage class for ingester/querier PVCs.
	//
	// +required
	// +kubebuilder:validation:Required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:io.kubernetes:StorageClass",displayName="Storage Class Name"
	StorageClassName string `json:"storageClassName"`

	// Proxy defines the spec for the object proxy to configure cluster proxy information.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Cluster Proxy"
	Proxy *ClusterProxy `json:"proxy,omitempty"`

	// Deprecated: Please use replication.factor instead. This field will be removed in future versions of this CRD.
	// ReplicationFactor defines the policy for log stream replication.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +kubebuilder:validation:Minimum:=1
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:number",displayName="Replication Factor"
	ReplicationFactor int32 `json:"replicationFactor,omitempty"`

	// Replication defines the configuration for Loki data replication.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Replication Spec"
	Replication *ReplicationSpec `json:"replication,omitempty"`

	// Rules defines the spec for the ruler component.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:advanced",displayName="Rules"
	Rules *RulesSpec `json:"rules,omitempty"`

	// Limits defines the limits to be applied to log stream processing.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:advanced",displayName="Rate Limiting"
	Limits *LimitsSpec `json:"limits,omitempty"`

	// Template defines the resource/limits/tolerations/nodeselectors per component.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:advanced",displayName="Node Placement"
	Template *LokiTemplateSpec `json:"template,omitempty"`

	// Tenants defines the per-tenant authentication and authorization spec for the lokistack-gateway component.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Tenants Configuration"
	Tenants *TenantsSpec `json:"tenants,omitempty"`
}

LokiStackSpec defines the desired state of LokiStack

func (*LokiStackSpec) DeepCopy 

func (in *LokiStackSpec) DeepCopy() *LokiStackSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LokiStackSpec.

func (*LokiStackSpec) DeepCopyInto 

func (in *LokiStackSpec) DeepCopyInto(out *LokiStackSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type LokiStackStatus 

type LokiStackStatus struct {
	// Components provides summary of all Loki pod status grouped
	// per component.
	//
	// +optional
	// +kubebuilder:validation:Optional
	Components LokiStackComponentStatus `json:"components,omitempty"`

	// Storage provides summary of all changes that have occurred
	// to the storage configuration.
	//
	// +optional
	// +kubebuilder:validation:Optional
	Storage LokiStackStorageStatus `json:"storage,omitempty"`

	// Conditions of the Loki deployment health.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=status,xDescriptors="urn:alm:descriptor:io.kubernetes.conditions"
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

LokiStackStatus defines the observed state of LokiStack

func (*LokiStackStatus) DeepCopy 

func (in *LokiStackStatus) DeepCopy() *LokiStackStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LokiStackStatus.

func (*LokiStackStatus) DeepCopyInto 

func (in *LokiStackStatus) DeepCopyInto(out *LokiStackStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type LokiStackStorageStatus 

type LokiStackStorageStatus struct {
	// Schemas is a list of schemas which have been applied
	// to the LokiStack.
	//
	// +optional
	// +kubebuilder:validation:Optional
	Schemas []ObjectStorageSchema `json:"schemas,omitempty"`

	// CredentialMode contains the authentication mode used for accessing the object storage.
	//
	// +optional
	// +kubebuilder:validation:Optional
	CredentialMode CredentialMode `json:"credentialMode,omitempty"`
}

LokiStackStorageStatus defines the observed state of the Loki storage configuration.

func (*LokiStackStorageStatus) DeepCopy 

func (in *LokiStackStorageStatus) DeepCopy() *LokiStackStorageStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LokiStackStorageStatus.

func (*LokiStackStorageStatus) DeepCopyInto 

func (in *LokiStackStorageStatus) DeepCopyInto(out *LokiStackStorageStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type LokiTemplateSpec 

type LokiTemplateSpec struct {
	// Compactor defines the compaction component spec.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Compactor pods"
	Compactor *LokiComponentSpec `json:"compactor,omitempty"`

	// Distributor defines the distributor component spec.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Distributor pods"
	Distributor *LokiComponentSpec `json:"distributor,omitempty"`

	// Ingester defines the ingester component spec.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Ingester pods"
	Ingester *LokiComponentSpec `json:"ingester,omitempty"`

	// Querier defines the querier component spec.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Querier pods"
	Querier *LokiComponentSpec `json:"querier,omitempty"`

	// QueryFrontend defines the query frontend component spec.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Query Frontend pods"
	QueryFrontend *LokiComponentSpec `json:"queryFrontend,omitempty"`

	// Gateway defines the lokistack gateway component spec.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Gateway pods"
	Gateway *LokiComponentSpec `json:"gateway,omitempty"`

	// IndexGateway defines the index gateway component spec.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Index Gateway pods"
	IndexGateway *LokiComponentSpec `json:"indexGateway,omitempty"`

	// Ruler defines the ruler component spec.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Ruler pods"
	Ruler *LokiComponentSpec `json:"ruler,omitempty"`
}

LokiTemplateSpec defines the template of all requirements to configure scheduling of all Loki components to be deployed.

func (*LokiTemplateSpec) DeepCopy 

func (in *LokiTemplateSpec) DeepCopy() *LokiTemplateSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new LokiTemplateSpec.

func (*LokiTemplateSpec) DeepCopyInto 

func (in *LokiTemplateSpec) DeepCopyInto(out *LokiTemplateSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type MTLSSpec 

type MTLSSpec struct {
	// CA defines the spec for the custom CA for tenant's authentication.
	//
	// +required
	// +kubebuilder:validation:Required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="CA ConfigMap"
	CA *CASpec `json:"ca"`
}

MTLSSpec specifies mTLS configuration parameters.

func (*MTLSSpec) DeepCopy 

func (in *MTLSSpec) DeepCopy() *MTLSSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MTLSSpec.

func (*MTLSSpec) DeepCopyInto 

func (in *MTLSSpec) DeepCopyInto(out *MTLSSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ManagementStateType 

type ManagementStateType string

ManagementStateType defines the type for CR management states.

+kubebuilder:validation:Enum=Managed;Unmanaged 

const (
	// ManagementStateManaged when the LokiStack custom resource should be
	// reconciled by the operator.
	ManagementStateManaged ManagementStateType = "Managed"

	// ManagementStateUnmanaged when the LokiStack custom resource should not be
	// reconciled by the operator.
	ManagementStateUnmanaged ManagementStateType = "Unmanaged"
)

type MemberListSpec 

type MemberListSpec struct {
	// InstanceAddrType defines the type of address to use to advertise to the ring.
	// Defaults to the first address from any private network interfaces of the current pod.
	// Alternatively the public pod IP can be used in case private networks (RFC 1918 and RFC 6598)
	// are not available.
	//
	// +optional
	// +kubebuilder:validation:optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors={"urn:alm:descriptor:com.tectonic.ui:select:default","urn:alm:descriptor:com.tectonic.ui:select:podIP"},displayName="Instance Address"
	InstanceAddrType InstanceAddrType `json:"instanceAddrType,omitempty"`

	// EnableIPv6 enables IPv6 support for the memberlist based hash ring.
	//
	// Currently this also forces the instanceAddrType to podIP to avoid local address lookup
	// for the memberlist.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:booleanSwitch",displayName="Enable IPv6"
	EnableIPv6 bool `json:"enableIPv6,omitempty"`
}

MemberListSpec defines the configuration for the memberlist based hash ring.

func (*MemberListSpec) DeepCopy 

func (in *MemberListSpec) DeepCopy() *MemberListSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new MemberListSpec.

func (*MemberListSpec) DeepCopyInto 

func (in *MemberListSpec) DeepCopyInto(out *MemberListSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ModeType 

type ModeType string

ModeType is the authentication/authorization mode in which LokiStack Gateway will be configured.

+kubebuilder:validation:Enum=static;dynamic;openshift-logging;openshift-network 

const (
	// Static mode asserts the Authorization Spec's Roles and RoleBindings
	// using an in-process OpenPolicyAgent Rego authorizer.
	Static ModeType = "static"
	// Dynamic mode delegates the authorization to a third-party OPA-compatible endpoint.
	Dynamic ModeType = "dynamic"
	// OpenshiftLogging mode provides fully automatic OpenShift in-cluster authentication and authorization support for application, infrastructure and audit logs.
	OpenshiftLogging ModeType = "openshift-logging"
	// OpenshiftNetwork mode provides fully automatic OpenShift in-cluster authentication and authorization support for network logs only.
	OpenshiftNetwork ModeType = "openshift-network"
)

type OIDCSpec 

type OIDCSpec struct {
	// Secret defines the spec for the clientID and clientSecret for tenant's authentication.
	//
	// +required
	// +kubebuilder:validation:Required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Tenant Secret"
	Secret *TenantSecretSpec `json:"secret"`
	// IssuerCA defines the spec for the issuer CA for tenant's authentication.
	//
	// +optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="IssuerCA ConfigMap"
	IssuerCA *CASpec `json:"issuerCA"`
	// IssuerURL defines the URL for issuer.
	//
	// +required
	// +kubebuilder:validation:Required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Issuer URL"
	IssuerURL string `json:"issuerURL"`
	// RedirectURL defines the URL for redirect.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Redirect URL"
	RedirectURL string `json:"redirectURL,omitempty"`
	// Group claim field from ID Token
	//
	// +optional
	// +kubebuilder:validation:Optional
	GroupClaim string `json:"groupClaim,omitempty"`
	// User claim field from ID Token
	//
	// +optional
	// +kubebuilder:validation:Optional
	UsernameClaim string `json:"usernameClaim,omitempty"`
}

OIDCSpec defines the oidc configuration spec for lokiStack Gateway component.

func (*OIDCSpec) DeepCopy 

func (in *OIDCSpec) DeepCopy() *OIDCSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OIDCSpec.

func (*OIDCSpec) DeepCopyInto 

func (in *OIDCSpec) DeepCopyInto(out *OIDCSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type OPASpec 

type OPASpec struct {
	// URL defines the third-party endpoint for authorization.
	//
	// +required
	// +kubebuilder:validation:Required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="OpenPolicyAgent URL"
	URL string `json:"url"`
}

OPASpec defines the opa configuration spec for lokiStack Gateway component.

func (*OPASpec) DeepCopy 

func (in *OPASpec) DeepCopy() *OPASpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OPASpec.

func (*OPASpec) DeepCopyInto 

func (in *OPASpec) DeepCopyInto(out *OPASpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type OTLPAttributeReference 

type OTLPAttributeReference struct {
	// Name contains either a verbatim name of an attribute or a regular expression matching many attributes.
	//
	// +required
	// +kubebuilder:validation:Required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Name"
	Name string `json:"name"`

	// If Regex is true, then Name is treated as a regular expression instead of as a verbatim attribute name.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Treat name as regular expression"
	Regex bool `json:"regex,omitempty"`
}

func (*OTLPAttributeReference) DeepCopy 

func (in *OTLPAttributeReference) DeepCopy() *OTLPAttributeReference

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OTLPAttributeReference.

func (*OTLPAttributeReference) DeepCopyInto 

func (in *OTLPAttributeReference) DeepCopyInto(out *OTLPAttributeReference)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type OTLPMetadataSpec 

type OTLPMetadataSpec struct {
	// ResourceAttributes lists the names of resource attributes that should be included in structured metadata.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Resource Attributes"
	ResourceAttributes []OTLPAttributeReference `json:"resourceAttributes,omitempty"`

	// ScopeAttributes lists the names of scope attributes that should be included in structured metadata.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Scope Attributes"
	ScopeAttributes []OTLPAttributeReference `json:"scopeAttributes,omitempty"`

	// LogAttributes lists the names of log attributes that should be included in structured metadata.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Log Attributes"
	LogAttributes []OTLPAttributeReference `json:"logAttributes,omitempty"`
}

func (*OTLPMetadataSpec) DeepCopy 

func (in *OTLPMetadataSpec) DeepCopy() *OTLPMetadataSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OTLPMetadataSpec.

func (*OTLPMetadataSpec) DeepCopyInto 

func (in *OTLPMetadataSpec) DeepCopyInto(out *OTLPMetadataSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type OTLPSpec 

type OTLPSpec struct {
	// StreamLabels configures which resource attributes are converted to Loki stream labels.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Stream Labels"
	StreamLabels *OTLPStreamLabelSpec `json:"streamLabels,omitempty"`

	// StructuredMetadata configures which attributes are saved in structured metadata.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Structured Metadata"
	StructuredMetadata *OTLPMetadataSpec `json:"structuredMetadata,omitempty"`
}

OTLPSpec defines which resource, scope and log attributes should be used as stream labels or stored as structured metadata.

func (*OTLPSpec) DeepCopy 

func (in *OTLPSpec) DeepCopy() *OTLPSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OTLPSpec.

func (*OTLPSpec) DeepCopyInto 

func (in *OTLPSpec) DeepCopyInto(out *OTLPSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type OTLPStreamLabelSpec 

type OTLPStreamLabelSpec struct {
	// ResourceAttributes lists the names of the resource attributes that should be converted into Loki stream labels.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Resource Attributes"
	ResourceAttributes []OTLPAttributeReference `json:"resourceAttributes,omitempty"`
}

func (*OTLPStreamLabelSpec) DeepCopy 

func (in *OTLPStreamLabelSpec) DeepCopy() *OTLPStreamLabelSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OTLPStreamLabelSpec.

func (*OTLPStreamLabelSpec) DeepCopyInto 

func (in *OTLPStreamLabelSpec) DeepCopyInto(out *OTLPStreamLabelSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ObjectStorageSchema 

type ObjectStorageSchema struct {
	// Version for writing and reading logs.
	//
	// +required
	// +kubebuilder:validation:Required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors={"urn:alm:descriptor:com.tectonic.ui:select:v11","urn:alm:descriptor:com.tectonic.ui:select:v12","urn:alm:descriptor:com.tectonic.ui:select:v13"},displayName="Version"
	Version ObjectStorageSchemaVersion `json:"version"`

	// EffectiveDate contains a date in YYYY-MM-DD format which is interpreted in the UTC time zone.
	//
	// The configuration always needs at least one schema that is currently valid. This means that when creating a new
	// LokiStack it is recommended to add a schema with the latest available version and an effective date of "yesterday".
	// New schema versions added to the configuration always needs to be placed "in the future", so that Loki can start
	// using it once the day rolls over.
	//
	// +required
	// +kubebuilder:validation:Required
	EffectiveDate StorageSchemaEffectiveDate `json:"effectiveDate"`
}

ObjectStorageSchema defines a schema version and the date when it will become effective.

func (*ObjectStorageSchema) DeepCopy 

func (in *ObjectStorageSchema) DeepCopy() *ObjectStorageSchema

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ObjectStorageSchema.

func (*ObjectStorageSchema) DeepCopyInto 

func (in *ObjectStorageSchema) DeepCopyInto(out *ObjectStorageSchema)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ObjectStorageSchemaVersion 

type ObjectStorageSchemaVersion string

ObjectStorageSchemaVersion defines the storage schema version which will be used with the Loki cluster.

+kubebuilder:validation:Enum=v11;v12;v13 

const (
	// ObjectStorageSchemaV11 when using v11 for the storage schema
	ObjectStorageSchemaV11 ObjectStorageSchemaVersion = "v11"

	// ObjectStorageSchemaV12 when using v12 for the storage schema
	ObjectStorageSchemaV12 ObjectStorageSchemaVersion = "v12"

	// ObjectStorageSchemaV13 when using v13 for the storage schema
	ObjectStorageSchemaV13 ObjectStorageSchemaVersion = "v13"
)

type ObjectStorageSecretSpec 

type ObjectStorageSecretSpec struct {
	// Type of object storage that should be used
	//
	// +required
	// +kubebuilder:validation:Required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors={"urn:alm:descriptor:com.tectonic.ui:select:azure","urn:alm:descriptor:com.tectonic.ui:select:gcs","urn:alm:descriptor:com.tectonic.ui:select:s3","urn:alm:descriptor:com.tectonic.ui:select:swift","urn:alm:descriptor:com.tectonic.ui:select:alibabacloud"},displayName="Object Storage Secret Type"
	Type ObjectStorageSecretType `json:"type"`

	// Name of a secret in the namespace configured for object storage secrets.
	//
	// +required
	// +kubebuilder:validation:Required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:io.kubernetes:Secret",displayName="Object Storage Secret Name"
	Name string `json:"name"`

	// CredentialMode can be used to set the desired credential mode for authenticating with the object storage.
	// If this is not set, then the operator tries to infer the credential mode from the provided secret and its
	// own configuration.
	//
	// +optional
	// +kubebuilder:validation:Optional
	CredentialMode CredentialMode `json:"credentialMode,omitempty"`
}

ObjectStorageSecretSpec is a secret reference containing name only, no namespace.

func (*ObjectStorageSecretSpec) DeepCopy 

func (in *ObjectStorageSecretSpec) DeepCopy() *ObjectStorageSecretSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ObjectStorageSecretSpec.

func (*ObjectStorageSecretSpec) DeepCopyInto 

func (in *ObjectStorageSecretSpec) DeepCopyInto(out *ObjectStorageSecretSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ObjectStorageSecretType 

type ObjectStorageSecretType string

ObjectStorageSecretType defines the type of storage which can be used with the Loki cluster.

+kubebuilder:validation:Enum=azure;gcs;s3;swift;alibabacloud; 

const (
	// ObjectStorageSecretAzure when using Azure for Loki storage
	ObjectStorageSecretAzure ObjectStorageSecretType = "azure"

	// ObjectStorageSecretGCS when using GCS for Loki storage
	ObjectStorageSecretGCS ObjectStorageSecretType = "gcs"

	// ObjectStorageSecretS3 when using S3 for Loki storage
	ObjectStorageSecretS3 ObjectStorageSecretType = "s3"

	// ObjectStorageSecretSwift when using Swift for Loki storage
	ObjectStorageSecretSwift ObjectStorageSecretType = "swift"

	// ObjectStorageSecretAlibabaCloud when using AlibabaCloud OSS for Loki storage
	ObjectStorageSecretAlibabaCloud ObjectStorageSecretType = "alibabacloud"
)

type ObjectStorageSpec 

type ObjectStorageSpec struct {
	// Schemas for reading and writing logs.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +kubebuilder:validation:MinItems:=1
	// +kubebuilder:default:={{version:v11,effectiveDate:"2020-10-11"}}
	Schemas []ObjectStorageSchema `json:"schemas"`

	// Secret for object storage authentication.
	// Name of a secret in the same namespace as the LokiStack custom resource.
	//
	// +required
	// +kubebuilder:validation:Required
	Secret ObjectStorageSecretSpec `json:"secret"`

	// TLS configuration for reaching the object storage endpoint.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="TLS Config"
	TLS *ObjectStorageTLSSpec `json:"tls,omitempty"`
}

ObjectStorageSpec defines the requirements to access the object storage bucket to persist logs by the ingester component.

func (*ObjectStorageSpec) DeepCopy 

func (in *ObjectStorageSpec) DeepCopy() *ObjectStorageSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ObjectStorageSpec.

func (*ObjectStorageSpec) DeepCopyInto 

func (in *ObjectStorageSpec) DeepCopyInto(out *ObjectStorageSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ObjectStorageTLSSpec 

type ObjectStorageTLSSpec struct {
	CASpec `json:",inline"`
}

ObjectStorageTLSSpec is the TLS configuration for reaching the object storage endpoint.

func (*ObjectStorageTLSSpec) DeepCopy 

func (in *ObjectStorageTLSSpec) DeepCopy() *ObjectStorageTLSSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ObjectStorageTLSSpec.

func (*ObjectStorageTLSSpec) DeepCopyInto 

func (in *ObjectStorageTLSSpec) DeepCopyInto(out *ObjectStorageTLSSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type OpenshiftOTLPConfig 

type OpenshiftOTLPConfig struct {
	// DisableRecommendedAttributes can be used to reduce the number of attributes used for stream labels and structured
	// metadata.
	//
	// Enabling this setting removes the "recommended attributes" from the generated Loki configuration. This will cause
	// meta information to not be available as stream labels or structured metadata, potentially making queries more
	// expensive and less performant.
	//
	// Note that there is a set of "required attributes", needed for OpenShift Logging to work properly. Those will be
	// added to the configuration, even if this field is set to true.
	//
	// This option is supposed to be combined with a custom label configuration customizing the labels for the specific
	// usecase.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Disable recommended OTLP attributes"
	DisableRecommendedAttributes bool `json:"disableRecommendedAttributes,omitempty"`
}

OpenshiftOTLPConfig defines configuration specific to users using OTLP together with an OpenShift tenancy mode.

func (*OpenshiftOTLPConfig) DeepCopy 

func (in *OpenshiftOTLPConfig) DeepCopy() *OpenshiftOTLPConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OpenshiftOTLPConfig.

func (*OpenshiftOTLPConfig) DeepCopyInto 

func (in *OpenshiftOTLPConfig) DeepCopyInto(out *OpenshiftOTLPConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type OpenshiftTenantSpec 

type OpenshiftTenantSpec struct {
	// AdminGroups defines a list of groups, whose members are considered to have admin-privileges by the Loki Operator.
	// Setting this to an empty array disables admin groups.
	//
	// By default the following groups are considered admin-groups:
	//  - system:cluster-admins
	//  - cluster-admin
	//  - dedicated-admin
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Admin Groups"
	AdminGroups []string `json:"adminGroups"`

	// OTLP contains settings for ingesting data using OTLP in the OpenShift tenancy mode.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="OpenTelemetry Protocol"
	OTLP *OpenshiftOTLPConfig `json:"otlp,omitempty"`
}

OpenshiftTenantSpec defines the configuration specific to Openshift modes.

func (*OpenshiftTenantSpec) DeepCopy 

func (in *OpenshiftTenantSpec) DeepCopy() *OpenshiftTenantSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new OpenshiftTenantSpec.

func (*OpenshiftTenantSpec) DeepCopyInto 

func (in *OpenshiftTenantSpec) DeepCopyInto(out *OpenshiftTenantSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type PerTenantLimitsTemplateSpec 

type PerTenantLimitsTemplateSpec struct {
	// IngestionLimits defines the limits applied on ingested log streams.
	//
	// +optional
	// +kubebuilder:validation:Optional
	IngestionLimits *IngestionLimitSpec `json:"ingestion,omitempty"`

	// QueryLimits defines the limit applied on querying log streams.
	//
	// +optional
	// +kubebuilder:validation:Optional
	QueryLimits *PerTenantQueryLimitSpec `json:"queries,omitempty"`

	// OTLP to configure which resource, scope and log attributes are stored as stream labels or structured metadata.
	//
	// Tenancy modes can provide a default OTLP configuration, when no custom OTLP configuration is set or even
	// enforce the use of some required attributes.
	//
	// The per-tenant configuration for OTLP attributes will be merged with the global configuration.
	//
	// +optional
	// +kubebuilder:validation:Optional
	OTLP *OTLPSpec `json:"otlp,omitempty"`

	// Retention defines how long logs are kept in storage.
	//
	// +optional
	// +kubebuilder:validation:Optional
	Retention *RetentionLimitSpec `json:"retention,omitempty"`
}

PerTenantLimitsTemplateSpec defines the limits applied at ingestion or query path.

func (*PerTenantLimitsTemplateSpec) DeepCopy 

func (in *PerTenantLimitsTemplateSpec) DeepCopy() *PerTenantLimitsTemplateSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PerTenantLimitsTemplateSpec.

func (*PerTenantLimitsTemplateSpec) DeepCopyInto 

func (in *PerTenantLimitsTemplateSpec) DeepCopyInto(out *PerTenantLimitsTemplateSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type PerTenantQueryLimitSpec 

type PerTenantQueryLimitSpec struct {
	QueryLimitSpec `json:",omitempty"`

	// Blocked defines the list of rules to block matching queries.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Blocked"
	Blocked []BlockedQuerySpec `json:"blocked,omitempty"`
}

PerTenantQueryLimitSpec defines the limits applied to per tenant query path.

func (*PerTenantQueryLimitSpec) DeepCopy 

func (in *PerTenantQueryLimitSpec) DeepCopy() *PerTenantQueryLimitSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PerTenantQueryLimitSpec.

func (*PerTenantQueryLimitSpec) DeepCopyInto 

func (in *PerTenantQueryLimitSpec) DeepCopyInto(out *PerTenantQueryLimitSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type PermissionType 

type PermissionType string

PermissionType is a LokiStack Gateway RBAC permission.

+kubebuilder:validation:Enum=read;write 

const (
	// Write gives access to write data to a tenant.
	Write PermissionType = "write"
	// Read gives access to read data from a tenant.
	Read PermissionType = "read"
)

type PodStatus 

type PodStatus string

PodStatus is a short description of the status a Pod can be in. 

const (
	// PodPending means the pod has been accepted by the system, but one or more of the containers
	// has not been started. This includes time before being bound to a node, as well as time spent
	// pulling images onto the host.
	PodPending PodStatus = "Pending"
	// PodRunning means the pod has been bound to a node and all of the containers have been started.
	// At least one container is still running or is in the process of being restarted.
	PodRunning PodStatus = "Running"
	// PodReady means the pod has been started and the readiness probe reports a successful status.
	PodReady PodStatus = "Ready"
	// PodFailed means that all containers in the pod have terminated, and at least one container has
	// terminated in a failure (exited with a non-zero exit code or was stopped by the system).
	PodFailed PodStatus = "Failed"
	// PodStatusUnknown is used when none of the other statuses apply or the information is not ready yet.
	PodStatusUnknown PodStatus = "Unknown"
)

type PodStatusMap 

type PodStatusMap map[PodStatus][]string

PodStatusMap defines the type for mapping pod status to pod name.

func (PodStatusMap) DeepCopy 

func (in PodStatusMap) DeepCopy() PodStatusMap

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new PodStatusMap.

func (PodStatusMap) DeepCopyInto 

func (in PodStatusMap) DeepCopyInto(out *PodStatusMap)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type PrometheusDuration 

type PrometheusDuration string

PrometheusDuration defines the type for Prometheus durations.

+kubebuilder:validation:Pattern:="((([0-9]+)y)?(([0-9]+)w)?(([0-9]+)d)?(([0-9]+)h)?(([0-9]+)m)?(([0-9]+)s)?(([0-9]+)ms)?|0)"

type QueryLimitSpec 

type QueryLimitSpec struct {
	// MaxEntriesLimitsPerQuery defines the maximum number of log entries
	// that will be returned for a query.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:number",displayName="Max Entries Limit per Query"
	MaxEntriesLimitPerQuery int32 `json:"maxEntriesLimitPerQuery,omitempty"`

	// MaxChunksPerQuery defines the maximum number of chunks
	// that can be fetched by a single query.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:number",displayName="Max Chunk per Query"
	MaxChunksPerQuery int32 `json:"maxChunksPerQuery,omitempty"`

	// MaxQuerySeries defines the maximum of unique series
	// that is returned by a metric query.
	//
	// + optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:number",displayName="Max Query Series"
	MaxQuerySeries int32 `json:"maxQuerySeries,omitempty"`

	// Timeout when querying ingesters or storage during the execution of a query request.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +kubebuilder:default:="3m"
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Query Timeout"
	QueryTimeout string `json:"queryTimeout,omitempty"`

	// CardinalityLimit defines the cardinality limit for index queries.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:number",displayName="Cardinality Limit"
	CardinalityLimit int32 `json:"cardinalityLimit,omitempty"`

	// MaxVolumeSeries defines the maximum number of aggregated series in a log-volume response
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:number",displayName="Max Volume Series"
	MaxVolumeSeries int32 `json:"maxVolumeSeries,omitempty"`
}

QueryLimitSpec defines the limits applies at the query path.

func (*QueryLimitSpec) DeepCopy 

func (in *QueryLimitSpec) DeepCopy() *QueryLimitSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new QueryLimitSpec.

func (*QueryLimitSpec) DeepCopyInto 

func (in *QueryLimitSpec) DeepCopyInto(out *QueryLimitSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type RecordingRule 

type RecordingRule struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   RecordingRuleSpec   `json:"spec,omitempty"`
	Status RecordingRuleStatus `json:"status,omitempty"`
}

RecordingRule is the Schema for the recordingrules API

+operator-sdk:csv:customresourcedefinitions:displayName="RecordingRule",resources={{LokiStack,v1}}

func (*RecordingRule) DeepCopy 

func (in *RecordingRule) DeepCopy() *RecordingRule

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RecordingRule.

func (*RecordingRule) DeepCopyInto 

func (in *RecordingRule) DeepCopyInto(out *RecordingRule)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*RecordingRule) DeepCopyObject 

func (in *RecordingRule) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*RecordingRule) Hub 

func (*RecordingRule) Hub()

Hub declares the v1.RecordingRule as the hub CRD version.

type RecordingRuleGroup 

type RecordingRuleGroup struct {
	// Name of the recording rule group. Must be unique within all recording rules.
	//
	// +required
	// +kubebuilder:validation:Required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Name"
	Name string `json:"name"`

	// Interval defines the time interval between evaluation of the given
	// recoding rule.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +kubebuilder:default:="1m"
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Evaluation Interval"
	Interval PrometheusDuration `json:"interval"`

	// Limit defines the number of series a recording rule can produce. 0 is no limit.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:number",displayName="Limit of produced series"
	Limit int32 `json:"limit,omitempty"`

	// Rules defines a list of recording rules
	//
	// +required
	// +kubebuilder:validation:Required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Rules"
	Rules []*RecordingRuleGroupSpec `json:"rules"`
}

RecordingRuleGroup defines a group of Loki recording rules.

func (*RecordingRuleGroup) DeepCopy 

func (in *RecordingRuleGroup) DeepCopy() *RecordingRuleGroup

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RecordingRuleGroup.

func (*RecordingRuleGroup) DeepCopyInto 

func (in *RecordingRuleGroup) DeepCopyInto(out *RecordingRuleGroup)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type RecordingRuleGroupSpec 

type RecordingRuleGroupSpec struct {
	// The name of the time series to output to. Must be a valid metric name.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Metric Name"
	Record string `json:"record,omitempty"`

	// The LogQL expression to evaluate. Every evaluation cycle this is
	// evaluated at the current time, and all resultant time series become
	// pending/firing alerts.
	//
	// +required
	// +kubebuilder:validation:Required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="LogQL Expression"
	Expr string `json:"expr"`

	// Labels to add to each recording rule.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Labels"
	Labels map[string]string `json:"labels,omitempty"`
}

RecordingRuleGroupSpec defines the spec for a Loki recording rule.

func (*RecordingRuleGroupSpec) DeepCopy 

func (in *RecordingRuleGroupSpec) DeepCopy() *RecordingRuleGroupSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RecordingRuleGroupSpec.

func (*RecordingRuleGroupSpec) DeepCopyInto 

func (in *RecordingRuleGroupSpec) DeepCopyInto(out *RecordingRuleGroupSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type RecordingRuleList 

type RecordingRuleList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []RecordingRule `json:"items"`
}

RecordingRuleList contains a list of RecordingRule

func (*RecordingRuleList) DeepCopy 

func (in *RecordingRuleList) DeepCopy() *RecordingRuleList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RecordingRuleList.

func (*RecordingRuleList) DeepCopyInto 

func (in *RecordingRuleList) DeepCopyInto(out *RecordingRuleList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*RecordingRuleList) DeepCopyObject 

func (in *RecordingRuleList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type RecordingRuleSpec 

type RecordingRuleSpec struct {
	// TenantID of tenant where the recording rules are evaluated in.
	//
	// +required
	// +kubebuilder:validation:Required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Tenant ID"
	TenantID string `json:"tenantID"`

	// List of groups for recording rules.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Groups"
	Groups []*RecordingRuleGroup `json:"groups"`
}

RecordingRuleSpec defines the desired state of RecordingRule

func (*RecordingRuleSpec) DeepCopy 

func (in *RecordingRuleSpec) DeepCopy() *RecordingRuleSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RecordingRuleSpec.

func (*RecordingRuleSpec) DeepCopyInto 

func (in *RecordingRuleSpec) DeepCopyInto(out *RecordingRuleSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type RecordingRuleStatus 

type RecordingRuleStatus struct {
	// Conditions of the RecordingRule generation health.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=status,xDescriptors="urn:alm:descriptor:io.kubernetes.conditions"
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

RecordingRuleStatus defines the observed state of RecordingRule

func (*RecordingRuleStatus) DeepCopy 

func (in *RecordingRuleStatus) DeepCopy() *RecordingRuleStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RecordingRuleStatus.

func (*RecordingRuleStatus) DeepCopyInto 

func (in *RecordingRuleStatus) DeepCopyInto(out *RecordingRuleStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type RelabelActionType 

type RelabelActionType string

RelabelActionType defines the enumeration type for RelabelConfig actions.

+kubebuilder:validation:Enum=drop;hashmod;keep;labeldrop;labelkeep;labelmap;replace

type RelabelConfig 

type RelabelConfig struct {
	// The source labels select values from existing labels. Their content is concatenated
	// using the configured separator and matched against the configured regular expression
	// for the replace, keep, and drop actions.
	//
	// +required
	// +kubebuilder:validation:Required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Source Labels"
	SourceLabels []string `json:"sourceLabels"`

	// Separator placed between concatenated source label values. default is ';'.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +kubebuilder:default:=";"
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Separator"
	Separator string `json:"separator,omitempty"`

	// Label to which the resulting value is written in a replace action.
	// It is mandatory for replace actions. Regex capture groups are available.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Target Label"
	TargetLabel string `json:"targetLabel,omitempty"`

	// Regular expression against which the extracted value is matched. Default is '(.*)'
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +kubebuilder:default:="(.*)"
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Regex"
	Regex string `json:"regex,omitempty"`

	// Modulus to take of the hash of the source label values.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Modulus"
	Modulus uint64 `json:"modulus,omitempty"`

	// Replacement value against which a regex replace is performed if the
	// regular expression matches. Regex capture groups are available. Default is '$1'
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +kubebuilder:default:="$1"
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Replacement"
	Replacement string `json:"replacement,omitempty"`

	// Action to perform based on regex matching. Default is 'replace'
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +kubebuilder:default:="replace"
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Action"
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors={"urn:alm:descriptor:com.tectonic.ui:select:drop","urn:alm:descriptor:com.tectonic.ui:select:hashmod","urn:alm:descriptor:com.tectonic.ui:select:keep","urn:alm:descriptor:com.tectonic.ui:select:labeldrop","urn:alm:descriptor:com.tectonic.ui:select:labelkeep","urn:alm:descriptor:com.tectonic.ui:select:labelmap","urn:alm:descriptor:com.tectonic.ui:select:replace"},displayName="Action"
	Action RelabelActionType `json:"action,omitempty"`
}

RelabelConfig allows dynamic rewriting of the label set, being applied to samples before ingestion. It defines `<metric_relabel_configs>` and `<alert_relabel_configs>` sections of Prometheus configuration. More info: https://prometheus.io/docs/prometheus/latest/configuration/configuration/#metric_relabel_configs

func (*RelabelConfig) DeepCopy 

func (in *RelabelConfig) DeepCopy() *RelabelConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RelabelConfig.

func (*RelabelConfig) DeepCopyInto 

func (in *RelabelConfig) DeepCopyInto(out *RelabelConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type RemoteWriteAuthType 

type RemoteWriteAuthType string

RemoteWriteAuthType defines the type of authorization to use to access the remote write endpoint.

+kubebuilder:validation:Enum=basic;header 

const (
	// BasicAuthorization defines the remote write client to use HTTP basic authorization.
	BasicAuthorization RemoteWriteAuthType = "basic"
	// BearerAuthorization defines the remote write client to use HTTP bearer authorization.
	BearerAuthorization RemoteWriteAuthType = "bearer"
)

type RemoteWriteClientQueueSpec 

type RemoteWriteClientQueueSpec struct {
	// Number of samples to buffer per shard before we block reading of more
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +kubebuilder:default:=2500
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:number",displayName="Queue Capacity"
	Capacity int32 `json:"capacity,omitempty"`

	// Maximum number of shards, i.e. amount of concurrency.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +kubebuilder:default:=200
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:number",displayName="Maximum Shards"
	MaxShards int32 `json:"maxShards,omitempty"`

	// Minimum number of shards, i.e. amount of concurrency.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +kubebuilder:default:=200
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:number",displayName="Minimum Shards"
	MinShards int32 `json:"minShards,omitempty"`

	// Maximum number of samples per send.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +kubebuilder:default:=500
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:number",displayName="Maximum Shards per Send"
	MaxSamplesPerSend int32 `json:"maxSamplesPerSend,omitempty"`

	// Maximum time a sample will wait in buffer.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +kubebuilder:default:="5s"
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Batch Send Deadline"
	BatchSendDeadline PrometheusDuration `json:"batchSendDeadline,omitempty"`

	// Initial retry delay. Gets doubled for every retry.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +kubebuilder:default:="30ms"
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Min BackOff Period"
	MinBackOffPeriod PrometheusDuration `json:"minBackOffPeriod,omitempty"`

	// Maximum retry delay.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +kubebuilder:default:="100ms"
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Max BackOff Period"
	MaxBackOffPeriod PrometheusDuration `json:"maxBackOffPeriod,omitempty"`
}

RemoteWriteClientQueueSpec defines the configuration of the remote write client queue.

func (*RemoteWriteClientQueueSpec) DeepCopy 

func (in *RemoteWriteClientQueueSpec) DeepCopy() *RemoteWriteClientQueueSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RemoteWriteClientQueueSpec.

func (*RemoteWriteClientQueueSpec) DeepCopyInto 

func (in *RemoteWriteClientQueueSpec) DeepCopyInto(out *RemoteWriteClientQueueSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type RemoteWriteClientSpec 

type RemoteWriteClientSpec struct {
	// Name of the remote write config, which if specified must be unique among remote write configs.
	//
	// +required
	// +kubebuilder:validation:Required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Name"
	Name string `json:"name"`

	// The URL of the endpoint to send samples to.
	//
	// +required
	// +kubebuilder:validation:Required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Endpoint"
	URL string `json:"url"`

	// Timeout for requests to the remote write endpoint.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +kubebuilder:default:="30s"
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Remote Write Timeout"
	Timeout PrometheusDuration `json:"timeout,omitempty"`

	// Type of authorzation to use to access the remote write endpoint
	//
	// +required
	// +kubebuilder:validation:Required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors={"urn:alm:descriptor:com.tectonic.ui:select:basic","urn:alm:descriptor:com.tectonic.ui:select:header"},displayName="Authorization Type"
	AuthorizationType RemoteWriteAuthType `json:"authorization"`

	// Name of a secret in the namespace configured for authorization secrets.
	//
	// +required
	// +kubebuilder:validation:Required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:io.kubernetes:Secret",displayName="Authorization Secret Name"
	AuthorizationSecretName string `json:"authorizationSecretName"`

	// Additional HTTP headers to be sent along with each remote write request.
	//
	// +optional
	// +kubebuilder:validation:Optional
	AdditionalHeaders map[string]string `json:"additionalHeaders,omitempty"`

	// List of remote write relabel configurations.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Metric Relabel Configuration"
	RelabelConfigs []RelabelConfig `json:"relabelConfigs,omitempty"`

	// Optional proxy URL.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="HTTP Proxy URL"
	ProxyURL string `json:"proxyUrl,omitempty"`

	// Configure whether HTTP requests follow HTTP 3xx redirects.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +kubebuilder:default:=true
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:booleanSwitch",displayName="Follow HTTP Redirects"
	FollowRedirects bool `json:"followRedirects"`
}

RemoteWriteClientSpec defines the configuration of the remote write client.

func (*RemoteWriteClientSpec) DeepCopy 

func (in *RemoteWriteClientSpec) DeepCopy() *RemoteWriteClientSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RemoteWriteClientSpec.

func (*RemoteWriteClientSpec) DeepCopyInto 

func (in *RemoteWriteClientSpec) DeepCopyInto(out *RemoteWriteClientSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type RemoteWriteSpec 

type RemoteWriteSpec struct {
	// Enable remote-write functionality.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:booleanSwitch",displayName="Enabled"
	Enabled bool `json:"enabled,omitempty"`

	// Minimum period to wait between refreshing remote-write reconfigurations.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +kubebuilder:default:="10s"
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Min Refresh Period"
	RefreshPeriod PrometheusDuration `json:"refreshPeriod,omitempty"`

	// Defines the configuration for remote write client.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:advanced",displayName="Client"
	ClientSpec *RemoteWriteClientSpec `json:"client,omitempty"`

	// Defines the configuration for remote write client queue.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:advanced",displayName="Client Queue"
	QueueSpec *RemoteWriteClientQueueSpec `json:"queue,omitempty"`
}

RemoteWriteSpec defines the configuration for ruler's remote_write connectivity.

func (*RemoteWriteSpec) DeepCopy 

func (in *RemoteWriteSpec) DeepCopy() *RemoteWriteSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RemoteWriteSpec.

func (*RemoteWriteSpec) DeepCopyInto 

func (in *RemoteWriteSpec) DeepCopyInto(out *RemoteWriteSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ReplicationSpec 

type ReplicationSpec struct {
	// Factor defines the policy for log stream replication.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +kubebuilder:validation:Minimum:=1
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:number",displayName="Replication Factor"
	Factor int32 `json:"factor,omitempty"`

	// Zones defines an array of ZoneSpec that the scheduler will try to satisfy.
	// IMPORTANT: Make sure that the replication factor defined is less than or equal to the number of available zones.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Zones Spec"
	Zones []ZoneSpec `json:"zones,omitempty"`
}

func (*ReplicationSpec) DeepCopy 

func (in *ReplicationSpec) DeepCopy() *ReplicationSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ReplicationSpec.

func (*ReplicationSpec) DeepCopyInto 

func (in *ReplicationSpec) DeepCopyInto(out *ReplicationSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type RetentionLimitSpec 

type RetentionLimitSpec struct {
	// Days contains the number of days logs are kept.
	//
	// +required
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:Minimum:=1
	Days uint `json:"days"`

	// Stream defines the log stream.
	//
	// +optional
	// +kubebuilder:validation:Optional
	Streams []*RetentionStreamSpec `json:"streams,omitempty"`
}

RetentionLimitSpec controls how long logs will be kept in storage.

func (*RetentionLimitSpec) DeepCopy 

func (in *RetentionLimitSpec) DeepCopy() *RetentionLimitSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RetentionLimitSpec.

func (*RetentionLimitSpec) DeepCopyInto 

func (in *RetentionLimitSpec) DeepCopyInto(out *RetentionLimitSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type RetentionStreamSpec 

type RetentionStreamSpec struct {
	// Days contains the number of days logs are kept.
	//
	// +required
	// +kubebuilder:validation:Required
	// +kubebuilder:validation:Minimum:=1
	Days uint `json:"days"`

	// Priority defines the priority of this selector compared to other retention rules.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +kubebuilder:default:=1
	Priority uint32 `json:"priority,omitempty"`

	// Selector contains the LogQL query used to define the log stream.
	//
	// +required
	// +kubebuilder:validation:Required
	Selector string `json:"selector"`
}

RetentionStreamSpec defines a log stream with separate retention time.

func (*RetentionStreamSpec) DeepCopy 

func (in *RetentionStreamSpec) DeepCopy() *RetentionStreamSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RetentionStreamSpec.

func (*RetentionStreamSpec) DeepCopyInto 

func (in *RetentionStreamSpec) DeepCopyInto(out *RetentionStreamSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type RoleBindingsSpec 

type RoleBindingsSpec struct {
	Name     string    `json:"name"`
	Subjects []Subject `json:"subjects"`
	Roles    []string  `json:"roles"`
}

RoleBindingsSpec binds a set of roles to a set of subjects.

func (*RoleBindingsSpec) DeepCopy 

func (in *RoleBindingsSpec) DeepCopy() *RoleBindingsSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RoleBindingsSpec.

func (*RoleBindingsSpec) DeepCopyInto 

func (in *RoleBindingsSpec) DeepCopyInto(out *RoleBindingsSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type RoleSpec 

type RoleSpec struct {
	Name        string           `json:"name"`
	Resources   []string         `json:"resources"`
	Tenants     []string         `json:"tenants"`
	Permissions []PermissionType `json:"permissions"`
}

RoleSpec describes a set of permissions to interact with a tenant.

func (*RoleSpec) DeepCopy 

func (in *RoleSpec) DeepCopy() *RoleSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RoleSpec.

func (*RoleSpec) DeepCopyInto 

func (in *RoleSpec) DeepCopyInto(out *RoleSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type RulerConfig 

type RulerConfig struct {
	metav1.TypeMeta   `json:",inline"`
	metav1.ObjectMeta `json:"metadata,omitempty"`

	Spec   RulerConfigSpec   `json:"spec,omitempty"`
	Status RulerConfigStatus `json:"status,omitempty"`
}

RulerConfig is the Schema for the rulerconfigs API

+operator-sdk:csv:customresourcedefinitions:displayName="RulerConfig",resources={{LokiStack,v1}}

func (*RulerConfig) DeepCopy 

func (in *RulerConfig) DeepCopy() *RulerConfig

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RulerConfig.

func (*RulerConfig) DeepCopyInto 

func (in *RulerConfig) DeepCopyInto(out *RulerConfig)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*RulerConfig) DeepCopyObject 

func (in *RulerConfig) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

func (*RulerConfig) Hub 

func (*RulerConfig) Hub()

Hub declares the v1.RulerConfig as the hub CRD version.

type RulerConfigList 

type RulerConfigList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []RulerConfig `json:"items"`
}

RulerConfigList contains a list of RuleConfig

func (*RulerConfigList) DeepCopy 

func (in *RulerConfigList) DeepCopy() *RulerConfigList

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RulerConfigList.

func (*RulerConfigList) DeepCopyInto 

func (in *RulerConfigList) DeepCopyInto(out *RulerConfigList)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*RulerConfigList) DeepCopyObject 

func (in *RulerConfigList) DeepCopyObject() runtime.Object

DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object.

type RulerConfigSpec 

type RulerConfigSpec struct {
	// Interval on how frequently to evaluate rules.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +kubebuilder:default:="1m"
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Evaluation Interval"
	EvalutionInterval PrometheusDuration `json:"evaluationInterval,omitempty"`

	// Interval on how frequently to poll for new rule definitions.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +kubebuilder:default:="1m"
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Poll Interval"
	PollInterval PrometheusDuration `json:"pollInterval,omitempty"`

	// Defines alert manager configuration to notify on firing alerts.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:advanced",displayName="Alert Manager Configuration"
	AlertManagerSpec *AlertManagerSpec `json:"alertmanager,omitempty"`

	// Defines a remote write endpoint to write recording rule metrics.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:advanced",displayName="Remote Write Configuration"
	RemoteWriteSpec *RemoteWriteSpec `json:"remoteWrite,omitempty"`

	// Overrides defines the config overrides to be applied per-tenant.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:advanced",displayName="Rate Limiting"
	Overrides map[string]RulerOverrides `json:"overrides,omitempty"`
}

RulerConfigSpec defines the desired state of Ruler

func (*RulerConfigSpec) DeepCopy 

func (in *RulerConfigSpec) DeepCopy() *RulerConfigSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RulerConfigSpec.

func (*RulerConfigSpec) DeepCopyInto 

func (in *RulerConfigSpec) DeepCopyInto(out *RulerConfigSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type RulerConfigStatus 

type RulerConfigStatus struct {
	// Conditions of the RulerConfig health.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=status,xDescriptors="urn:alm:descriptor:io.kubernetes.conditions"
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

RulerConfigStatus defines the observed state of RulerConfig

func (*RulerConfigStatus) DeepCopy 

func (in *RulerConfigStatus) DeepCopy() *RulerConfigStatus

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RulerConfigStatus.

func (*RulerConfigStatus) DeepCopyInto 

func (in *RulerConfigStatus) DeepCopyInto(out *RulerConfigStatus)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type RulerOverrides 

type RulerOverrides struct {
	// AlertManagerOverrides defines the overrides to apply to the alertmanager config.
	//
	// +optional
	// +kubebuilder:validation:Optional
	AlertManagerOverrides *AlertManagerSpec `json:"alertmanager,omitempty"`
}

RulerOverrides defines the overrides applied per-tenant.

func (*RulerOverrides) DeepCopy 

func (in *RulerOverrides) DeepCopy() *RulerOverrides

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RulerOverrides.

func (*RulerOverrides) DeepCopyInto 

func (in *RulerOverrides) DeepCopyInto(out *RulerOverrides)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type RulesSpec 

type RulesSpec struct {
	// Enabled defines a flag to enable/disable the ruler component
	//
	// +required
	// +kubebuilder:validation:Required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:booleanSwitch",displayName="Enable"
	Enabled bool `json:"enabled"`

	// A selector to select which LokiRules to mount for loading alerting/recording
	// rules from.
	//
	// +optional
	// +kubebuilder:validation:optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Selector"
	Selector *metav1.LabelSelector `json:"selector,omitempty"`

	// Namespaces to be selected for PrometheusRules discovery. If unspecified, only
	// the same namespace as the LokiStack object is in is used.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Namespace Selector"
	NamespaceSelector *metav1.LabelSelector `json:"namespaceSelector,omitempty"`
}

RulesSpec defines the spec for the ruler component.

func (*RulesSpec) DeepCopy 

func (in *RulesSpec) DeepCopy() *RulesSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new RulesSpec.

func (*RulesSpec) DeepCopyInto 

func (in *RulesSpec) DeepCopyInto(out *RulesSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type StorageSchemaEffectiveDate 

type StorageSchemaEffectiveDate string

StorageSchemaEffectiveDate defines the type for the Storage Schema Effect Date

+kubebuilder:validation:Pattern:="^([0-9]{4,})([-]([0-9]{2})){2}$"

func (StorageSchemaEffectiveDate) UTCTime 

func (d StorageSchemaEffectiveDate) UTCTime() (time.Time, error)

UTCTime returns the date as a time object in the UTC time zone

type Subject 

type Subject struct {
	Name string      `json:"name"`
	Kind SubjectKind `json:"kind"`
}

Subject represents a subject that has been bound to a role.

func (*Subject) DeepCopy 

func (in *Subject) DeepCopy() *Subject

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new Subject.

func (*Subject) DeepCopyInto 

func (in *Subject) DeepCopyInto(out *Subject)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type SubjectKind 

type SubjectKind string

SubjectKind is a kind of LokiStack Gateway RBAC subject.

+kubebuilder:validation:Enum=user;group 

const (
	// User represents a subject that is a user.
	User SubjectKind = "user"
	// Group represents a subject that is a group.
	Group SubjectKind = "group"
)

type TenantSecretSpec 

type TenantSecretSpec struct {
	// Name of a secret in the namespace configured for tenant secrets.
	//
	// +required
	// +kubebuilder:validation:Required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:io.kubernetes:Secret",displayName="Tenant Secret Name"
	Name string `json:"name"`
}

TenantSecretSpec is a secret reference containing name only for a secret living in the same namespace as the LokiStack custom resource.

func (*TenantSecretSpec) DeepCopy 

func (in *TenantSecretSpec) DeepCopy() *TenantSecretSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TenantSecretSpec.

func (*TenantSecretSpec) DeepCopyInto 

func (in *TenantSecretSpec) DeepCopyInto(out *TenantSecretSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type TenantsSpec 

type TenantsSpec struct {
	// Mode defines the mode in which lokistack-gateway component will be configured.
	//
	// +required
	// +kubebuilder:validation:Required
	// +kubebuilder:default:=openshift-logging
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors={"urn:alm:descriptor:com.tectonic.ui:select:static","urn:alm:descriptor:com.tectonic.ui:select:dynamic","urn:alm:descriptor:com.tectonic.ui:select:openshift-logging","urn:alm:descriptor:com.tectonic.ui:select:openshift-network"},displayName="Mode"
	Mode ModeType `json:"mode"`
	// Authentication defines the lokistack-gateway component authentication configuration spec per tenant.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Authentication"
	Authentication []AuthenticationSpec `json:"authentication,omitempty"`
	// Authorization defines the lokistack-gateway component authorization configuration spec per tenant.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Authorization"
	Authorization *AuthorizationSpec `json:"authorization,omitempty"`

	// Openshift defines the configuration specific to Openshift modes.
	//
	// +optional
	// +kubebuilder:validation:Optional
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Openshift"
	Openshift *OpenshiftTenantSpec `json:"openshift,omitempty"`
}

TenantsSpec defines the mode, authentication and authorization configuration of the lokiStack gateway component.

func (*TenantsSpec) DeepCopy 

func (in *TenantsSpec) DeepCopy() *TenantsSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new TenantsSpec.

func (*TenantsSpec) DeepCopyInto 

func (in *TenantsSpec) DeepCopyInto(out *TenantsSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

type ZoneSpec 

type ZoneSpec struct {
	// MaxSkew describes the maximum degree to which Pods can be unevenly distributed.
	//
	// +required
	// +kubebuilder:default:=1
	// +operator-sdk:csv:customresourcedefinitions:type=spec,xDescriptors="urn:alm:descriptor:com.tectonic.ui:number",displayName="Max Skew"
	MaxSkew int `json:"maxSkew"`

	// TopologyKey is the key that defines a topology in the Nodes' labels.
	//
	// +required
	// +kubebuilder:validation:Required
	// +operator-sdk:csv:customresourcedefinitions:type=spec,displayName="Topology Key"
	TopologyKey string `json:"topologyKey"`
}

ZoneSpec defines the spec to support zone-aware component deployments.

func (*ZoneSpec) DeepCopy 

func (in *ZoneSpec) DeepCopy() *ZoneSpec

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ZoneSpec.

func (*ZoneSpec) DeepCopyInto 

func (in *ZoneSpec) DeepCopyInto(out *ZoneSpec)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.