values.yaml

# Base64 encoded contents of a bootstrap address book
addressBook: ""

affinity:
  podAntiAffinity:
    preferredDuringSchedulingIgnoredDuringExecution:
      - weight: 100
        podAffinityTerm:
          topologyKey: kubernetes.io/hostname
          labelSelector:
            matchLabels:
              app.kubernetes.io/component: importer

alertmanager:
  inhibitRules:
    enabled: false

    InhibitAllWhenPodIssues:
      enabled: true
      matches:
        - sourceMatch:
            - name: area
              value: resource
          targetMatch:
            - name: application
              value: hedera-mirror-importer
          equal:
            - namespace
            - pod

    InhibitCloudLatencyAlertsWhenCloudError:
      enabled: true
      matches:
        - sourceMatch:
            - name: alertname
              value: ImporterCloudStorageErrors
          targetMatch:
            - name: alertname
              value: ImporterCloudStorageLatency
          equal:
            - type
            - namespace
            - pod

    InhibitLogAlertsWhenErrors:
      enabled: true
      matches:
        - sourceMatch:
            - name: alertname
              regex: true
              value: Importer[a-zA-Z]+Errors
          targetMatch:
            - name: alertname
              value: ImporterLogErrors
          equal:
            - namespace
            - pod

    InhibitParserLatencyAlertsWhenParseOrVerificationErrors:
      enabled: true
      matches:
        - sourceMatch:
            - name: alertname
              regex: true
              value: (ImporterFileVerificationErrors|ImporterParseErrors)
          targetMatch:
            - name: area
              value: parser
          equal:
            - namespace
            - pod
            - type

    InhibitStreamAlertsWhenCloudErrors:
      enabled: true
      matches:
        - sourceMatch:
            - name: area
              value: cloud
          targetMatch:
            - name: area
              regex: true
              value: (parser|downloader)
          equal:
            - type
            - namespace
            - pod

    InhibitVerificationErrorsWhenNoConsensus:
      enabled: true
      matches:
        - sourceMatch:
            - name: alertname
              value: ImporterNoConsensus
          targetMatch:
            - name: alertname
              value: ImporterFileVerificationErrors
          equal:
            - type
            - namespace
            - pod

annotations: {}

config:
  hedera:
    mirror:
      importer:
        db:
          loadBalance: false

# Environment variables to add to the container. The value can either be a string or an EnvVarSource. Evaluated as a template.
env:
  SPRING_CLOUD_KUBERNETES_ENABLED: "true"
  SPRING_CONFIG_ADDITIONAL_LOCATION: "file:/usr/etc/hedera/"
  # FOO:
  #   valueFrom:
  #     secretKeyRef:
  #       name: '{{ .Release.Name }}-custom'
  #       key: BAR

# Add config maps or secrets as environment variables. Evaluated as a template.
envFrom: []
# - secretRef:
#     name: '{{ .Release.Name }}-env'

fullnameOverride: ""

global:
  image: {}
  namespaceOverride: ""
  podAnnotations: {}

image:
  pullPolicy: IfNotPresent
  registry: gcr.io
  repository: mirrornode/hedera-mirror-importer
  tag: ""  # Defaults to the chart's app version

imagePullSecrets: []

labels: {}

livenessProbe:
  httpGet:
    path: /actuator/health/liveness
    port: http
  initialDelaySeconds: 60
  periodSeconds: 30
  timeoutSeconds: 2

nameOverride: ""

networkPolicy:
  enabled: false

nodeSelector: {}

podAnnotations:
  "cluster-autoscaler.kubernetes.io/safe-to-evict": "true"

podDisruptionBudget:
  enabled: false
  # maxUnavailable: 0
  minAvailable: 1

podMonitor:
  enabled: false
  interval: 30s

podSecurityContext:
  fsGroup: 1000
  runAsGroup: 1000
  runAsNonRoot: true
  runAsUser: 1000
  seccompProfile:
    type: RuntimeDefault

priorityClassName: ""

prometheusRules:
  enabled: false
  ImporterBalanceParseLatency:
    annotations:
      description: Averaging {{ $value | humanizeDuration }} trying to parse balance stream files for {{ $labels.namespace }}/{{ $labels.pod }}
      summary: Took longer than 2m to parse balance stream files
    enabled: true
    expr: sum(rate(hedera_mirror_parse_duration_seconds_sum{application="hedera-mirror-importer",type="BALANCE"}[15m])) by (namespace, pod) / sum(rate(hedera_mirror_parse_duration_seconds_count{application="hedera-mirror-importer",type="BALANCE"}[15m])) by (namespace, pod) > 120
    for: 2m
    labels:
      severity: critical
      application: hedera-mirror-importer
      type: BALANCE
      area: parser

  ImporterBalanceStreamFallenBehind:
    annotations:
      description: The difference between the file timestamp and when it was processed is {{ $value | humanizeDuration }} for {{ $labels.namespace }}/{{ $labels.pod }}
      summary: Mirror Importer balance stream processing has fallen behind
    enabled: true
    expr: sum(rate(hedera_mirror_parse_latency_seconds_sum{application="hedera-mirror-importer",type="BALANCE"}[15m])) by (namespace, pod) / sum(rate(hedera_mirror_parse_latency_seconds_count{application="hedera-mirror-importer",type="BALANCE"}[15m])) by (namespace, pod) > 960
    for: 3m
    labels:
      severity: critical
      application: hedera-mirror-importer
      type: BALANCE
      area: parser

  ImporterCloudStorageErrors:
    annotations:
      description: 'Averaging {{ $value | humanizePercentage }} error rate trying to {{ if ne $labels.action "list" }} retrieve{{ end }} {{ $labels.action }} {{ $labels.type }} files from cloud storage for {{ $labels.namespace }}/{{ $labels.pod }}'
      summary: "Cloud storage error rate exceeds 5%"
    enabled: true
    expr: (sum(rate(hedera_mirror_download_request_seconds_count{application="hedera-mirror-importer", status!~"^2.*"}[2m])) by (namespace, pod, type, action) / sum(rate(hedera_mirror_download_request_seconds_count{application="hedera-mirror-importer"}[2m])) by (namespace, pod, type, action)) > 0.05
    for: 2m
    labels:
      severity: critical
      application: hedera-mirror-importer
      area: cloud

  ImporterCloudStorageLatency:
    annotations:
      description: Averaging {{ $value | humanizeDuration }} cloud storage latency trying to {{ if ne $labels.action "list" }} retrieve{{ end }} {{ $labels.action }} {{ $labels.type }} files from cloud storage for {{ $labels.namespace }}/{{ $labels.pod }}
      summary: Cloud storage latency exceeds 2s
    enabled: true
    expr: sum(rate(hedera_mirror_download_request_seconds_sum{application="hedera-mirror-importer", status=~"^2.*"}[2m])) by (namespace, pod, type, action) / sum(rate(hedera_mirror_download_request_seconds_count{application="hedera-mirror-importer", status=~"^2.*"}[2m])) by (namespace, pod, type, action) > 2
    for: 2m
    labels:
      severity: critical
      application: hedera-mirror-importer
      area: cloud

  ImporterFileVerificationErrors:
    annotations:
      description: "Error rate of {{ $value | humanizePercentage }} trying to download and verify {{ $labels.type }} stream files for {{ $labels.namespace }}/{{ $labels.pod }}"
      summary: "{{ $labels.type }} file verification error rate exceeds 5%"
    enabled: true
    expr: sum(rate(hedera_mirror_download_stream_verification_seconds_count{application="hedera-mirror-importer", success="false"}[3m])) by (namespace, pod, type) / sum(rate(hedera_mirror_download_stream_verification_seconds_count{application="hedera-mirror-importer"}[3m])) by (namespace, pod, type) > 0.05
    for: 2m
    labels:
      severity: critical
      application: hedera-mirror-importer
      area: downloader

  ImporterHighCPU:
    annotations:
      description: "{{ $labels.namespace }}/{{ $labels.pod }} CPU usage reached {{ $value | humanizePercentage }}"
      summary: "Mirror Importer CPU usage exceeds 80%"
    enabled: true
    expr: sum(process_cpu_usage{application="hedera-mirror-importer"}) by (namespace, pod) / sum(system_cpu_count{application="hedera-mirror-importer"}) by (namespace, pod) > 0.8
    for: 5m
    labels:
      severity: critical
      application: hedera-mirror-importer
      area: resource

  ImporterHighDBConnections:
    annotations:
      description: "{{ $labels.namespace }}/{{ $labels.pod }} is using {{ $value | humanizePercentage }} of available database connections"
      summary: "Mirror Importer database connection utilization exceeds 75%"
    enabled: true
    expr: sum(hikaricp_connections_active{application="hedera-mirror-importer"}) by (namespace, pod) / sum(hikaricp_connections_max{application="hedera-mirror-importer"}) by (namespace, pod) > 0.75
    for: 5m
    labels:
      severity: critical
      application: hedera-mirror-importer
      area: resource

  ImporterHighFileDescriptors:
    annotations:
      description: "{{ $labels.namespace }}/{{ $labels.pod }} file descriptor usage reached {{ $value | humanizePercentage }}"
      summary: "Mirror Importer file descriptor usage exceeds 80%"
    enabled: true
    expr: sum(process_files_open_files{application="hedera-mirror-importer"}) by (namespace, pod) / sum(process_files_max_files{application="hedera-mirror-importer"}) by (namespace, pod) > 0.8
    for: 5m
    labels:
      severity: critical
      application: hedera-mirror-importer
      area: resource

  ImporterHighMemory:
    annotations:
      description: "{{ $labels.namespace }}/{{ $labels.pod }} memory usage reached {{ $value | humanizePercentage }}"
      summary: "Mirror Importer memory usage exceeds 80%"
    enabled: true
    expr: sum(jvm_memory_used_bytes{application="hedera-mirror-importer"}) by (namespace, pod) / sum(jvm_memory_max_bytes{application="hedera-mirror-importer"}) by (namespace, pod) > 0.8
    for: 5m
    labels:
      severity: critical
      application: hedera-mirror-importer
      area: resource

  ImporterLogErrors:
    annotations:
      description: "Logs for {{ $labels.namespace }}/{{ $labels.pod }} have reached {{ $value }} error messages/s in a 3m period"
      summary: High rate of log errors
    enabled: true
    expr: sum(increase(log4j2_events_total{application="hedera-mirror-importer", level="error"}[2m])) by (namespace, pod) >= 2
    for: 3m
    labels:
      severity: critical
      application: hedera-mirror-importer
      area: log

  ImporterNoBalanceFile:
    annotations:
      description: Have not processed a balance stream file in {{ $labels.namespace }} for the last 15 min
      summary: Missing balance stream files
    enabled: true
    expr: sum(increase(hedera_mirror_parse_latency_seconds_count{application="hedera-mirror-importer",type="BALANCE"}[16m])) by (namespace) < 1
    for: 5m
    labels:
      application: hedera-mirror-importer
      area: parser
      severity: critical
      type: BALANCE

  ImporterNoConsensus:
    annotations:
      description: "{{ $labels.namespace }} only able to achieve {{ $value | humanizePercentage }} consensus during {{ $labels.type }} stream signature verification"
      summary: Unable to verify {{ $labels.type }} stream signatures
    enabled: true
    expr: sum(rate(hedera_mirror_download_signature_verification_total{application="hedera-mirror-importer", status="CONSENSUS_REACHED"}[2m])) by (namespace, pod, type) / sum(rate(hedera_mirror_download_signature_verification_total{application="hedera-mirror-importer"}[2m])) by (namespace, pod, type) < 0.33
    for: 2m
    labels:
      severity: critical
      application: hedera-mirror-importer
      area: downloader

  ImporterNoPodsReady:
    annotations:
      description: "No importer instances are currently ready in {{ $labels.namespace }}"
      summary: No importer instances are ready
    enabled: true
    expr: sum(kube_pod_status_ready{pod=~".*-importer-.*",condition="true"}) by (namespace) < 1
    for: 2m
    labels:
      severity: critical
      application: hedera-mirror-importer
      area: resource

  ImporterNoTransactions:
    annotations:
      description: "Record stream TPS has dropped to {{ $value }} for {{ $labels.namespace }}. This may be because importer is down, can't connect to cloud storage, main nodes are not uploading, error parsing the streams, no traffic, etc."
      summary: "No transactions seen for 2m"
    enabled: true
    expr: sum(rate(hedera_mirror_transaction_latency_seconds_count{application="hedera-mirror-importer"}[5m])) by (namespace) <= 0
    for: 2m
    labels:
      severity: critical
      application: hedera-mirror-importer
      type: RECORD
      area: parser

  ImporterParseErrors:
    annotations:
      description: "Encountered {{ $value | humanizePercentage }} errors trying to parse {{ $labels.type }} stream files for {{ $labels.namespace }}/{{ $labels.pod }}"
      summary: "Error rate parsing {{ $labels.type }} exceeds 5%"
    enabled: true
    expr: sum(rate(hedera_mirror_parse_duration_seconds_count{application="hedera-mirror-importer", success="false"}[3m])) by (namespace, pod, type) / sum(rate(hedera_mirror_parse_duration_seconds_count{application="hedera-mirror-importer"}[3m])) by (namespace, pod, type) > 0.05
    for: 2m
    labels:
      severity: critical
      application: hedera-mirror-importer
      area: parser

  ImporterPublishLatency:
    annotations:
      description: Took {{ $value | humanizeDuration }} to publish {{ $labels.entity }}s to {{ $labels.type }} for {{ $labels.namespace }}/{{ $labels.pod }}
      summary: Slow {{ $labels.type }} publishing
    enabled: true
    expr: sum(rate(hedera_mirror_importer_publish_duration_seconds_sum{application="hedera-mirror-importer"}[3m])) by (namespace, pod, type, entity) / sum(rate(hedera_mirror_importer_publish_duration_seconds_count{application="hedera-mirror-importer"}[3m])) by (namespace, pod, type, entity) > 1
    for: 1m
    labels:
      severity: critical
      application: hedera-mirror-importer
      area: publisher

  ImporterQueryLatency:
    annotations:
      description: "High average database query latency of {{ $value | humanizeDuration }} for {{ $labels.namespace }}/{{ $labels.pod }}"
      summary: "Mirror Importer query latency exceeds 1s"
    enabled: true
    expr: sum(rate(spring_data_repository_invocations_seconds_sum{application="hedera-mirror-importer"}[5m])) by (namespace, pod) / sum(rate(spring_data_repository_invocations_seconds_count{application="hedera-mirror-importer"}[5m])) by (namespace, pod) > 1
    for: 1m
    labels:
      severity: warning
      application: hedera-mirror-importer

  ImporterReconciliationFailed:
    annotations:
      description: "Unable to reconcile balance information for {{ $labels.namespace }}/{{ $labels.pod }}"
      summary: "Mirror reconciliation job failed"
    enabled: true
    expr: sum(hedera_mirror_reconciliation{application="hedera-mirror-importer"}) by (namespace, pod) > 2
    for: 1m
    labels:
      severity: critical
      application: hedera-mirror-importer

  ImporterRecordParseLatency:
    annotations:
      description: Averaging {{ $value | humanizeDuration }} trying to parse record stream files for {{ $labels.namespace }}/{{ $labels.pod }}
      summary: Took longer than 2s to parse record stream files
    enabled: true
    expr: sum(rate(hedera_mirror_parse_duration_seconds_sum{application="hedera-mirror-importer",type="RECORD"}[3m])) by (namespace, pod) / sum(rate(hedera_mirror_parse_duration_seconds_count{application="hedera-mirror-importer",type="RECORD"}[3m])) by (namespace, pod) > 2
    for: 1m
    labels:
      severity: critical
      application: hedera-mirror-importer
      type: RECORD
      area: parser

  ImporterRecordStreamFallenBehind:
    annotations:
      description: The difference between the file timestamp and when it was processed is {{ $value | humanizeDuration }} for {{ $labels.namespace }}/{{ $labels.pod }}
      summary: Mirror Importer record stream processing has fallen behind
    enabled: true
    expr: sum(rate(hedera_mirror_parse_latency_seconds_sum{application="hedera-mirror-importer",type="RECORD"}[3m])) by (namespace, pod) / sum(rate(hedera_mirror_parse_latency_seconds_count{application="hedera-mirror-importer",type="RECORD"}[3m])) by (namespace, pod) > 20
    for: 3m
    labels:
      severity: critical
      application: hedera-mirror-importer
      type: RECORD
      area: parser

  ImporterStreamCloseInterval:
    annotations:
      description: "{{ $labels.namespace }}/{{ $labels.pod }} file stream should close every 2s but is actually {{ $value | humanizeDuration }}. This could just be due to the lack of traffic in the environment, but it could potentially be something more serious to look into."
      summary: Record stream close interval exceeds 10s
    enabled: true
    expr: sum(rate(hedera_mirror_stream_close_latency_seconds_sum{application="hedera-mirror-importer", type="RECORD"}[5m])) by (namespace, pod) / sum(rate(hedera_mirror_stream_close_latency_seconds_count{application="hedera-mirror-importer", type="RECORD"}[5m])) by (namespace, pod) > 10
    for: 1m
    labels:
      severity: warning
      application: hedera-mirror-importer
      type: RECORD
      area: downloader

rbac:
  enabled: true

readinessProbe:
  httpGet:
    path: /actuator/health/readiness
    port: http
  initialDelaySeconds: 60
  timeoutSeconds: 2

replicas: 1

resources:
  limits:
    cpu: 4
    memory: 4Gi
  requests:
    cpu: 200m
    memory: 512Mi

revisionHistoryLimit: 3

securityContext:
  allowPrivilegeEscalation: false
  capabilities:
    drop: [ALL]
  readOnlyRootFilesystem: true

serviceAccount:
  create: true
  # The name of the service account to use. If not set and create is true, a name is generated using the fullname template
  name:

startupProbe:
  failureThreshold: 8640
  httpGet:
    path: /actuator/health/startup
    port: http
  initialDelaySeconds: 60
  periodSeconds: 10
  timeoutSeconds: 2

terminationGracePeriodSeconds: 30

tolerations: []

updateStrategy:
  type: Recreate

# Volumes to add to the container. The key is the volume name and the value is the volume mount definition. The same keys should also appear in volumes below.
volumeMounts:
  config:
    mountPath: /usr/etc/hedera
  temp:
    mountPath: /tmp

# Volume mounts to add to the container. The key is the volume name and the value is the volume definition. Evaluated as a template.
volumes:
  config:
    secret:
      defaultMode: 420
      secretName: '{{ include "hedera-mirror-importer.fullname" . }}'
  temp:
    emptyDir:
      medium: Memory
      sizeLimit: 500Mi