COMPUTED VALUES:
backend:
  affinity: |
    podAntiAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        - labelSelector:
            matchLabels:
              {{- include "loki.backendSelectorLabels" . | nindent 10 }}
          topologyKey: kubernetes.io/hostname
  annotations: {}
  autoscaling:
    behavior: {}
    enabled: false
    maxReplicas: 6
    minReplicas: 3
    targetCPUUtilizationPercentage: 60
    targetMemoryUtilizationPercentage: null
  dnsConfig: {}
  extraArgs: []
  extraEnv: []
  extraEnvFrom: []
  extraVolumeMounts: []
  extraVolumes: []
  image:
    registry: null
    repository: null
    tag: null
  initContainers: []
  nodeSelector: {}
  persistence:
    dataVolumeParameters:
      emptyDir: {}
    enableStatefulSetAutoDeletePVC: true
    selector: null
    size: 10Gi
    storageClass: null
    volumeClaimsEnabled: true
  podAnnotations: {}
  podLabels: {}
  podManagementPolicy: Parallel
  priorityClassName: null
  replicas: 0
  resources: {}
  selectorLabels: {}
  service:
    annotations: {}
    labels: {}
  targetModule: backend
  terminationGracePeriodSeconds: 300
  tolerations: []
  topologySpreadConstraints: []
clusterLabelOverride: null
enterprise:
  adminApi:
    enabled: true
  adminToken:
    additionalNamespaces: []
    secret: null
  canarySecret: null
  cluster_name: null
  config: |
    {{- if .Values.enterprise.adminApi.enabled }}
    {{- if or .Values.minio.enabled (eq .Values.loki.storage.type "s3") (eq .Values.loki.storage.type "gcs") (eq .Values.loki.storage.type "azure") }}
    admin_client:
      storage:
        s3:
          bucket_name: {{ .Values.loki.storage.bucketNames.admin }}
    {{- end }}
    {{- end }}
    auth:
      type: {{ .Values.enterprise.adminApi.enabled | ternary "enterprise" "trust" }}
    auth_enabled: {{ .Values.loki.auth_enabled }}
    cluster_name: {{ include "loki.clusterName" . }}
    license:
      path: /etc/loki/license/license.jwt
  enabled: false
  externalConfigName: ""
  externalLicenseName: null
  image:
    digest: null
    pullPolicy: IfNotPresent
    registry: docker.io
    repository: grafana/enterprise-logs
    tag: null
  license:
    contents: NOTAVALIDLICENSE
  provisioner:
    additionalTenants: []
    annotations: {}
    enabled: true
    env: []
    extraVolumeMounts: []
    image:
      digest: null
      pullPolicy: IfNotPresent
      registry: docker.io
      repository: grafana/enterprise-logs-provisioner
      tag: null
    labels: {}
    priorityClassName: null
    provisionedSecretPrefix: null
    securityContext:
      fsGroup: 10001
      runAsGroup: 10001
      runAsNonRoot: true
      runAsUser: 10001
  tokengen:
    annotations: {}
    enabled: true
    env: []
    extraArgs: []
    extraEnvFrom: []
    extraVolumeMounts: []
    extraVolumes: []
    labels: {}
    priorityClassName: ""
    securityContext:
      fsGroup: 10001
      runAsGroup: 10001
      runAsNonRoot: true
      runAsUser: 10001
    targetModule: tokengen
    tolerations: []
  useExternalLicense: false
  version: v1.8.6
extraObjects:
- apiVersion: v1
  data:
    loki-alerting-rules.yaml: |-
      groups:
        - name: additional-loki-rules
          rules:
            - alert: NovaCellNotResponding
              expr: 'count_over_time({pod_label_component="compute"} |= "not responding and hence is being omitted from the results" [1m]) > 0'
              labels:
                severity: critical
              annotations:
                summary: Nova Cell is not responding. It can cause port deletion in CAPI.
  kind: ConfigMap
  metadata:
    labels:
      loki_rule: atmosphere
    name: loki-alerting-rules
fullnameOverride: null
gateway:
  affinity: |
    podAntiAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        - labelSelector:
            matchLabels:
              {{- include "loki.gatewaySelectorLabels" . | nindent 10 }}
          topologyKey: kubernetes.io/hostname
  annotations: {}
  autoscaling:
    behavior: {}
    enabled: false
    maxReplicas: 3
    minReplicas: 1
    targetCPUUtilizationPercentage: 60
    targetMemoryUtilizationPercentage: null
  basicAuth:
    enabled: false
    existingSecret: null
    htpasswd: |-
      {{ if .Values.loki.tenants }}

        {{- range $t := .Values.loki.tenants }}
      {{ htpasswd (required "All tenants must have a 'name' set" $t.name) (required "All tenants must have a 'password' set" $t.password) }}

        {{- end }}
      {{ else }} {{ htpasswd (required "'gateway.basicAuth.username' is required" .Values.gateway.basicAuth.username) (required "'gateway.basicAuth.password' is required" .Values.gateway.basicAuth.password) }} {{ end }}
    password: null
    username: null
  containerSecurityContext:
    allowPrivilegeEscalation: false
    capabilities:
      drop:
      - ALL
    readOnlyRootFilesystem: true
  deploymentStrategy:
    type: RollingUpdate
  dnsConfig: {}
  enabled: true
  extraArgs: []
  extraContainers: []
  extraEnv: []
  extraEnvFrom: []
  extraVolumeMounts: []
  extraVolumes: []
  image:
    digest: null
    pullPolicy: IfNotPresent
    registry: harbor.atmosphere.dev
    repository: docker.io/nginxinc/nginx-unprivileged
    tag: 1.24-alpine
  ingress:
    annotations: {}
    enabled: false
    hosts:
    - host: gateway.loki.example.com
      paths:
      - path: /
    ingressClassName: ""
    labels: {}
    tls:
    - hosts:
      - gateway.loki.example.com
      secretName: loki-gateway-tls
  lifecycle: {}
  nginxConfig:
    customBackendUrl: null
    customReadUrl: null
    customWriteUrl: null
    enableIPv6: true
    file: |
      {{- include "loki.nginxFile" . | indent 2 -}}
    httpSnippet: '{{ if .Values.loki.tenants }}proxy_set_header X-Scope-OrgID $remote_user;{{
      end }}'
    logFormat: |-
      main '$remote_addr - $remote_user [$time_local]  $status '
              '"$request" $body_bytes_sent "$http_referer" '
              '"$http_user_agent" "$http_x_forwarded_for"';
    resolver: ""
    serverSnippet: ""
  nodeSelector:
    openstack-control-plane: enabled
  podAnnotations: {}
  podLabels: {}
  podSecurityContext:
    fsGroup: 101
    runAsGroup: 101
    runAsNonRoot: true
    runAsUser: 101
  priorityClassName: null
  readinessProbe:
    httpGet:
      path: /
      port: http
    initialDelaySeconds: 15
    timeoutSeconds: 1
  replicas: 1
  resources: {}
  service:
    annotations: {}
    clusterIP: null
    labels: {}
    loadBalancerIP: null
    nodePort: null
    port: 80
    type: ClusterIP
  terminationGracePeriodSeconds: 30
  tolerations: []
  topologySpreadConstraints: []
  verboseLogging: true
global:
  clusterDomain: cluster.local
  dnsNamespace: kube-system
  dnsService: kube-dns
  image:
    registry: null
  priorityClassName: null
imagePullSecrets: []
ingress:
  annotations: {}
  enabled: false
  hosts:
  - loki.example.com
  ingressClassName: ""
  labels: {}
  paths:
    read:
    - /api/prom/tail
    - /loki/api/v1/tail
    - /loki/api
    - /api/prom/rules
    - /loki/api/v1/rules
    - /prometheus/api/v1/rules
    - /prometheus/api/v1/alerts
    singleBinary:
    - /api/prom/push
    - /loki/api/v1/push
    - /api/prom/tail
    - /loki/api/v1/tail
    - /loki/api
    - /api/prom/rules
    - /loki/api/v1/rules
    - /prometheus/api/v1/rules
    - /prometheus/api/v1/alerts
    write:
    - /api/prom/push
    - /loki/api/v1/push
  tls: []
kubectlImage:
  digest: null
  pullPolicy: IfNotPresent
  registry: docker.io
  repository: bitnami/kubectl
  tag: null
loki:
  analytics: {}
  annotations: {}
  auth_enabled: false
  commonConfig:
    compactor_address: '{{ include "loki.compactorAddress" . }}'
    path_prefix: /var/loki
    replication_factor: 1
  compactor:
    compaction_interval: 10m
    delete_request_store: filesystem
    retention_delete_delay: 2h
    retention_delete_worker_count: 150
    retention_enabled: true
    working_directory: /var/loki/compactor
  config: |
    {{- if .Values.enterprise.enabled}}
    {{- tpl .Values.enterprise.config . }}
    {{- else }}
    auth_enabled: {{ .Values.loki.auth_enabled }}
    {{- end }}

    {{- with .Values.loki.server }}
    server:
      {{- toYaml . | nindent 2}}
    {{- end}}

    memberlist:
    {{- if .Values.loki.memberlistConfig }}
      {{- toYaml .Values.loki.memberlistConfig | nindent 2 }}
    {{- else }}
    {{- if .Values.loki.extraMemberlistConfig}}
    {{- toYaml .Values.loki.extraMemberlistConfig | nindent 2}}
    {{- end }}
      join_members:
        - {{ include "loki.memberlist" . }}
        {{- with .Values.migrate.fromDistributed }}
        {{- if .enabled }}
        - {{ .memberlistService }}
        {{- end }}
        {{- end }}
    {{- end }}

    {{- with .Values.loki.ingester }}
    ingester:
      {{- tpl (. | toYaml) $ | nindent 4 }}
    {{- end }}

    {{- if .Values.loki.commonConfig}}
    common:
    {{- toYaml .Values.loki.commonConfig | nindent 2}}
      storage:
      {{- include "loki.commonStorageConfig" . | nindent 4}}
    {{- end}}

    {{- with .Values.loki.limits_config }}
    limits_config:
      {{- tpl (. | toYaml) $ | nindent 4 }}
    {{- end }}

    runtime_config:
      file: /etc/loki/runtime-config/runtime-config.yaml

    {{- with .Values.loki.memcached.chunk_cache }}
    {{- if and .enabled (or .host .addresses) }}
    chunk_store_config:
      chunk_cache_config:
        memcached:
          batch_size: {{ .batch_size }}
          parallelism: {{ .parallelism }}
        memcached_client:
          {{- if .host }}
          host: {{ .host }}
          {{- end }}
          {{- if .addresses }}
          addresses: {{ .addresses }}
          {{- end }}
          service: {{ .service }}
    {{- end }}
    {{- end }}

    {{- if .Values.loki.schemaConfig }}
    schema_config:
    {{- toYaml .Values.loki.schemaConfig | nindent 2}}
    {{- else }}
    schema_config:
      configs:
        - from: 2022-01-11
          store: boltdb-shipper
          object_store: {{ .Values.loki.storage.type }}
          schema: v12
          index:
            prefix: loki_index_
            period: 24h
    {{- end }}

    {{ include "loki.rulerConfig" . }}

    {{- if or .Values.tableManager.retention_deletes_enabled .Values.tableManager.retention_period }}
    table_manager:
      retention_deletes_enabled: {{ .Values.tableManager.retention_deletes_enabled }}
      retention_period: {{ .Values.tableManager.retention_period }}
    {{- end }}

    {{- with .Values.loki.memcached.results_cache }}
    query_range:
      align_queries_with_step: true
      {{- if and .enabled (or .host .addresses) }}
      cache_results: {{ .enabled }}
      results_cache:
        cache:
          default_validity: {{ .default_validity }}
          memcached_client:
            {{- if .host }}
            host: {{ .host }}
            {{- end }}
            {{- if .addresses }}
            addresses: {{ .addresses }}
            {{- end }}
            service: {{ .service }}
            timeout: {{ .timeout }}
      {{- end }}
    {{- end }}

    {{- with .Values.loki.storage_config }}
    storage_config:
      {{- tpl (. | toYaml) $ | nindent 4 }}
    {{- end }}

    {{- with .Values.loki.query_scheduler }}
    query_scheduler:
      {{- tpl (. | toYaml) $ | nindent 4 }}
    {{- end }}

    {{- with .Values.loki.compactor }}
    compactor:
      {{- tpl (. | toYaml) $ | nindent 4 }}
    {{- end }}

    {{- with .Values.loki.analytics }}
    analytics:
      {{- tpl (. | toYaml) $ | nindent 4 }}
    {{- end }}

    {{- with .Values.loki.querier }}
    querier:
      {{- tpl (. | toYaml) $ | nindent 4 }}
    {{- end }}

    {{- with .Values.loki.index_gateway }}
    index_gateway:
      {{- tpl (. | toYaml) $ | nindent 4 }}
    {{- end }}

    {{- with .Values.loki.frontend }}
    frontend:
      {{- tpl (. | toYaml) $ | nindent 4 }}
    {{- end }}

    {{- with .Values.loki.frontend_worker }}
    frontend_worker:
      {{- tpl (. | toYaml) $ | nindent 4 }}
    {{- end }}

    {{- with .Values.loki.distributor }}
    distributor:
      {{- tpl (. | toYaml) $ | nindent 4 }}
    {{- end }}

    tracing:
      enabled: {{ .Values.loki.tracing.enabled }}
  configStorageType: ConfigMap
  containerSecurityContext:
    allowPrivilegeEscalation: false
    capabilities:
      drop:
      - ALL
    readOnlyRootFilesystem: true
  distributor: {}
  enableServiceLinks: true
  existingSecretForConfig: ""
  externalConfigSecretName: '{{ include "loki.name" . }}'
  extraMemberlistConfig: {}
  frontend:
    scheduler_address: '{{ include "loki.querySchedulerAddress" . }}'
  frontend_worker:
    scheduler_address: '{{ include "loki.querySchedulerAddress" . }}'
  image:
    digest: null
    pullPolicy: IfNotPresent
    registry: harbor.atmosphere.dev
    repository: docker.io/grafana/loki
    tag: 2.9.6
  index_gateway:
    mode: ring
  ingester: {}
  limits_config:
    max_cache_freshness_per_query: 10m
    max_label_names_per_series: 25
    reject_old_samples: true
    reject_old_samples_max_age: 168h
    retention_period: 30d
    split_queries_by_interval: 15m
  memberlistConfig: {}
  memcached:
    chunk_cache:
      batch_size: 256
      enabled: false
      host: ""
      parallelism: 10
      service: memcached-client
    results_cache:
      default_validity: 12h
      enabled: false
      host: ""
      service: memcached-client
      timeout: 500ms
  podAnnotations: {}
  podLabels: {}
  podSecurityContext:
    fsGroup: 10001
    runAsGroup: 10001
    runAsNonRoot: true
    runAsUser: 10001
  querier: {}
  query_scheduler: {}
  readinessProbe:
    httpGet:
      path: /ready
      port: http-metrics
    initialDelaySeconds: 30
    timeoutSeconds: 1
  revisionHistoryLimit: 10
  rulerConfig:
    alertmanager_url: http://alertmanager-operated.monitoring:9093
    enable_alertmanager_v2: true
    enable_api: true
    ring:
      kvstore:
        store: inmemory
    rule_path: /var/loki/rules-temp
    storage:
      local:
        directory: /var/loki/rulestorage
      type: local
  runtimeConfig: {}
  schemaConfig: {}
  server:
    grpc_listen_port: 9095
    http_listen_port: 3100
    log_level: warn
  serviceAnnotations: {}
  serviceLabels: {}
  storage:
    azure:
      accountKey: null
      accountName: null
      connectionString: null
      endpointSuffix: null
      requestTimeout: null
      useFederatedToken: false
      useManagedIdentity: false
      userAssignedId: null
    bucketNames:
      admin: admin
      chunks: chunks
      ruler: ruler
    filesystem:
      chunks_directory: /var/loki/chunks
      rules_directory: /var/loki/rules
    gcs:
      chunkBufferSize: 0
      enableHttp2: true
      requestTimeout: 0s
    s3:
      accessKeyId: null
      backoff_config: {}
      endpoint: null
      http_config: {}
      insecure: false
      region: null
      s3: null
      s3ForcePathStyle: false
      secretAccessKey: null
      signatureVersion: null
    swift:
      auth_url: null
      auth_version: null
      connect_timeout: null
      container_name: null
      domain_id: null
      domain_name: null
      internal: null
      max_retries: null
      password: null
      project_domain_id: null
      project_domain_name: null
      project_id: null
      project_name: null
      region_name: null
      request_timeout: null
      user_domain_id: null
      user_domain_name: null
      user_id: null
      username: null
    type: filesystem
  storage_config:
    hedging:
      at: 250ms
      max_per_second: 20
      up_to: 3
  structuredConfig: {}
  tenants: []
  tracing:
    enabled: false
lokiCanary:
  enabled: false
memberlist:
  service:
    publishNotReadyAddresses: false
migrate:
  fromDistributed:
    enabled: false
    memberlistService: ""
minio:
  DeploymentUpdate:
    maxSurge: 100%
    maxUnavailable: 0
    type: RollingUpdate
  StatefulSetUpdate:
    updateStrategy: RollingUpdate
  additionalAnnotations: {}
  additionalLabels: {}
  affinity: {}
  bucketRoot: ""
  buckets:
  - name: chunks
    policy: none
    purge: false
  - name: ruler
    policy: none
    purge: false
  - name: admin
    policy: none
    purge: false
  certsPath: /etc/minio/certs/
  clusterDomain: cluster.local
  configPathmc: /etc/minio/mc/
  consoleIngress:
    annotations: {}
    enabled: false
    hosts:
    - console.minio-example.local
    labels: {}
    path: /
    tls: []
  consoleService:
    clusterIP: null
    nodePort: 32001
    port: "9001"
    type: ClusterIP
  customCommandJob:
    affinity: {}
    annotations: {}
    exitCommand: ""
    nodeSelector: {}
    podAnnotations: {}
    resources:
      requests:
        memory: 128Mi
    securityContext:
      enabled: false
      fsGroup: 1000
      runAsGroup: 1000
      runAsUser: 1000
    tolerations: []
  customCommands: null
  drivesPerNode: 2
  enabled: false
  environment: null
  etcd:
    clientCert: ""
    clientCertKey: ""
    corednsPathPrefix: ""
    endpoints: []
    pathPrefix: ""
  existingSecret: ""
  extraArgs: []
  extraVolumeMounts: []
  extraVolumes: []
  fullnameOverride: ""
  gateway:
    replicas: 4
    type: nas
  global:
    clusterDomain: cluster.local
    dnsNamespace: kube-system
    dnsService: kube-dns
    image:
      registry: null
    priorityClassName: null
  ignoreChartChecksums: false
  image:
    pullPolicy: IfNotPresent
    repository: quay.io/minio/minio
    tag: RELEASE.2022-09-17T00-09-45Z
  imagePullSecrets: []
  ingress:
    annotations: {}
    enabled: false
    hosts:
    - minio-example.local
    labels: {}
    path: /
    tls: []
  makeBucketJob:
    affinity: {}
    annotations: {}
    exitCommand: ""
    extraVolumeMounts: []
    extraVolumes: []
    nodeSelector: {}
    podAnnotations: {}
    resources:
      requests:
        memory: 128Mi
    securityContext:
      enabled: false
      fsGroup: 1000
      runAsGroup: 1000
      runAsUser: 1000
    tolerations: []
  makePolicyJob:
    affinity: {}
    annotations: {}
    exitCommand: ""
    extraVolumeMounts: []
    extraVolumes: []
    nodeSelector: {}
    podAnnotations: {}
    resources:
      requests:
        memory: 128Mi
    securityContext:
      enabled: false
      fsGroup: 1000
      runAsGroup: 1000
      runAsUser: 1000
    tolerations: []
  makeUserJob:
    affinity: {}
    annotations: {}
    exitCommand: ""
    extraVolumeMounts: []
    extraVolumes: []
    nodeSelector: {}
    podAnnotations: {}
    resources:
      requests:
        memory: 128Mi
    securityContext:
      enabled: false
      fsGroup: 1000
      runAsGroup: 1000
      runAsUser: 1000
    tolerations: []
  mcImage:
    pullPolicy: IfNotPresent
    repository: quay.io/minio/mc
    tag: RELEASE.2022-09-16T09-16-47Z
  metrics:
    serviceMonitor:
      additionalLabels: {}
      enabled: false
      includeNode: false
      public: true
      relabelConfigs: {}
      relabelConfigsCluster: {}
  minioAPIPort: "9000"
  minioConsolePort: "9001"
  mode: distributed
  mountPath: /export
  nameOverride: ""
  networkPolicy:
    allowExternal: true
    enabled: false
  nodeSelector: {}
  oidc:
    claimName: policy
    claimPrefix: ""
    clientId: minio
    clientSecret: ""
    comment: ""
    configUrl: https://identity-provider-url/.well-known/openid-configuration
    enabled: false
    redirectUri: https://console-endpoint-url/oauth_callback
    scopes: openid,profile,email
  persistence:
    VolumeName: ""
    accessMode: ReadWriteOnce
    annotations: {}
    enabled: true
    existingClaim: ""
    size: 5Gi
    storageClass: ""
    subPath: ""
  podAnnotations: {}
  podDisruptionBudget:
    enabled: false
    maxUnavailable: 1
  podLabels: {}
  policies: []
  pools: 1
  priorityClassName: ""
  replicas: 1
  resources:
    requests:
      cpu: 100m
      memory: 128Mi
  rootPassword: supersecret
  rootUser: enterprise-logs
  runtimeClassName: ""
  securityContext:
    enabled: true
    fsGroup: 1000
    fsGroupChangePolicy: OnRootMismatch
    runAsGroup: 1000
    runAsUser: 1000
  service:
    clusterIP: null
    nodePort: 32000
    port: "9000"
    type: ClusterIP
  serviceAccount:
    create: true
    name: minio-sa
  tls:
    certSecret: ""
    enabled: false
    privateKey: private.key
    publicCrt: public.crt
  tolerations: []
  topologySpreadConstraints: []
  trustedCertsSecret: ""
  users:
  - accessKey: console
    policy: consoleAdmin
    secretKey: console123
monitoring:
  dashboards:
    annotations: {}
    enabled: true
    labels:
      grafana_dashboard: "1"
    namespace: null
  lokiCanary:
    annotations: {}
    dnsConfig: {}
    enabled: false
    extraArgs: []
    extraEnv: []
    extraEnvFrom: []
    image:
      digest: null
      pullPolicy: IfNotPresent
      registry: docker.io
      repository: grafana/loki-canary
      tag: null
    labelname: pod
    nodeSelector: {}
    podLabels: {}
    priorityClassName: null
    resources: {}
    service:
      annotations: {}
      labels: {}
    tolerations: []
    updateStrategy:
      rollingUpdate:
        maxUnavailable: 1
      type: RollingUpdate
  rules:
    additionalGroups: []
    additionalRuleLabels: {}
    alerting: true
    annotations: {}
    disabled: {}
    enabled: true
    labels: {}
    namespace: null
  selfMonitoring:
    enabled: false
    grafanaAgent:
      annotations: {}
      enableConfigReadAPI: false
      installOperator: false
      labels: {}
      priorityClassName: null
      resources: {}
      tolerations: []
    logsInstance:
      annotations: {}
      clients: null
      labels: {}
    podLogs:
      additionalPipelineStages: []
      annotations: {}
      apiVersion: monitoring.grafana.com/v1alpha1
      labels: {}
      relabelings: []
    tenant:
      name: self-monitoring
      secretNamespace: '{{ .Release.Namespace }}'
  serviceMonitor:
    annotations: {}
    enabled: true
    interval: 15s
    labels: {}
    metricRelabelings: []
    metricsInstance:
      annotations: {}
      enabled: true
      labels: {}
      remoteWrite: null
    namespaceSelector: {}
    relabelings: []
    scheme: http
    scrapeTimeout: null
    tlsConfig: null
nameOverride: null
networkPolicy:
  alertmanager:
    namespaceSelector: {}
    podSelector: {}
    port: 9093
  discovery:
    namespaceSelector: {}
    podSelector: {}
    port: null
  egressKubeApiserver:
    enabled: false
  egressWorld:
    enabled: false
  enabled: false
  externalStorage:
    cidrs: []
    ports: []
  flavor: kubernetes
  ingress:
    namespaceSelector: {}
    podSelector: {}
  metrics:
    cidrs: []
    namespaceSelector: {}
    podSelector: {}
rbac:
  namespaced: false
  pspAnnotations: {}
  pspEnabled: false
  sccEnabled: false
read:
  affinity: |
    podAntiAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        - labelSelector:
            matchLabels:
              {{- include "loki.readSelectorLabels" . | nindent 10 }}
          topologyKey: kubernetes.io/hostname
  annotations: {}
  autoscaling:
    behavior: {}
    enabled: false
    maxReplicas: 6
    minReplicas: 2
    targetCPUUtilizationPercentage: 60
    targetMemoryUtilizationPercentage: null
  dnsConfig: {}
  extraArgs: []
  extraContainers: []
  extraEnv: []
  extraEnvFrom: []
  extraVolumeMounts: []
  extraVolumes: []
  image:
    registry: null
    repository: null
    tag: null
  legacyReadTarget: false
  lifecycle: {}
  nodeSelector: {}
  persistence:
    enableStatefulSetAutoDeletePVC: true
    selector: null
    size: 10Gi
    storageClass: null
  podAnnotations: {}
  podLabels: {}
  podManagementPolicy: Parallel
  priorityClassName: null
  replicas: 0
  resources: {}
  selectorLabels: {}
  service:
    annotations: {}
    labels: {}
  targetModule: read
  terminationGracePeriodSeconds: 30
  tolerations: []
  topologySpreadConstraints: []
serviceAccount:
  annotations: {}
  automountServiceAccountToken: true
  create: true
  imagePullSecrets: []
  labels: {}
  name: null
sidecar:
  enableUniqueFilenames: false
  image:
    pullPolicy: IfNotPresent
    repository: kiwigrid/k8s-sidecar
    sha: ""
    tag: 1.24.3
  livenessProbe: {}
  readinessProbe: {}
  resources: {}
  rules:
    enabled: true
    folder: /rules
    label: loki_rule
    labelValue: ""
    logLevel: INFO
    resource: both
    script: null
    searchNamespace: null
    watchClientTimeout: 60
    watchMethod: WATCH
    watchServerTimeout: 60
  securityContext: {}
  skipTlsVerify: false
singleBinary:
  affinity: |
    podAntiAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        - labelSelector:
            matchLabels:
              {{- include "loki.singleBinarySelectorLabels" . | nindent 10 }}
          topologyKey: kubernetes.io/hostname
  annotations: {}
  autoscaling:
    enabled: false
    maxReplicas: 3
    minReplicas: 1
    targetCPUUtilizationPercentage: 60
    targetMemoryUtilizationPercentage: null
  dnsConfig: {}
  extraArgs: []
  extraContainers: []
  extraEnv: []
  extraEnvFrom: []
  extraVolumeMounts:
  - mountPath: /var/loki/rulestorage/fake
    name: rules
  extraVolumes:
  - configMap:
      name: loki-alerting-rules
    name: rules
  image:
    registry: null
    repository: null
    tag: null
  initContainers: []
  nodeSelector:
    openstack-control-plane: enabled
  persistence:
    enableStatefulSetAutoDeletePVC: true
    enabled: true
    selector: null
    size: 256Gi
    storageClass: null
  podAnnotations: {}
  podLabels: {}
  priorityClassName: null
  replicas: 1
  resources: {}
  selectorLabels: {}
  service:
    annotations: {}
    labels: {}
  targetModule: all
  terminationGracePeriodSeconds: 30
  tolerations: []
tableManager:
  affinity: |
    podAntiAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        - labelSelector:
            matchLabels:
              {{- include "loki.tableManagerSelectorLabels" . | nindent 10 }}
          topologyKey: kubernetes.io/hostname
      preferredDuringSchedulingIgnoredDuringExecution:
        - weight: 100
          podAffinityTerm:
            labelSelector:
              matchLabels:
                {{- include "loki.tableManagerSelectorLabels" . | nindent 12 }}
            topologyKey: failure-domain.beta.kubernetes.io/zone
  annotations: {}
  command: null
  dnsConfig: {}
  enabled: false
  extraArgs: []
  extraContainers: []
  extraEnv: []
  extraEnvFrom: []
  extraVolumeMounts: []
  extraVolumes: []
  image:
    registry: null
    repository: null
    tag: null
  nodeSelector: {}
  podAnnotations: {}
  podLabels: {}
  priorityClassName: null
  resources: {}
  retention_deletes_enabled: false
  retention_period: 0
  service:
    annotations: {}
    labels: {}
  terminationGracePeriodSeconds: 30
  tolerations: []
test:
  annotations: {}
  enabled: false
  image:
    digest: null
    pullPolicy: IfNotPresent
    registry: docker.io
    repository: grafana/loki-helm-test
    tag: null
  labels: {}
  prometheusAddress: http://prometheus:9090
  timeout: 1m
write:
  affinity: |
    podAntiAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        - labelSelector:
            matchLabels:
              {{- include "loki.writeSelectorLabels" . | nindent 10 }}
          topologyKey: kubernetes.io/hostname
  annotations: {}
  autoscaling:
    behavior:
      scaleDown:
        policies:
        - periodSeconds: 1800
          type: Pods
          value: 1
        stabilizationWindowSeconds: 3600
      scaleUp:
        policies:
        - periodSeconds: 900
          type: Pods
          value: 1
    enabled: false
    maxReplicas: 6
    minReplicas: 2
    targetCPUUtilizationPercentage: 60
    targetMemoryUtilizationPercentage: null
  dnsConfig: {}
  extraArgs: []
  extraContainers: []
  extraEnv: []
  extraEnvFrom: []
  extraVolumeClaimTemplates: []
  extraVolumeMounts: []
  extraVolumes: []
  image:
    registry: null
    repository: null
    tag: null
  initContainers: []
  lifecycle: {}
  nodeSelector: {}
  persistence:
    dataVolumeParameters:
      emptyDir: {}
    enableStatefulSetAutoDeletePVC: false
    selector: null
    size: 10Gi
    storageClass: null
    volumeClaimsEnabled: true
  podAnnotations: {}
  podLabels: {}
  podManagementPolicy: Parallel
  priorityClassName: null
  replicas: 0
  resources: {}
  selectorLabels: {}
  service:
    annotations: {}
    labels: {}
  targetModule: write
  terminationGracePeriodSeconds: 300
  tolerations: []
  topologySpreadConstraints: []
