{{ define "alloy.config.processors" }}
// Processors
{{- if or .Values.receivers.grpc.enabled .Values.receivers.http.enabled .Values.receivers.zipkin.enabled }}
{{- if .Values.metrics.enabled }}
otelcol.processor.transform "add_metric_datapoint_attributes" {
  // Grafana Cloud Kubernetes monitoring expects Loki labels `cluster`, `pod`, and `namespace`
  error_mode = "ignore"
  metric_statements {
    context = "datapoint"
    statements = [
      "set(attributes[\"deployment.environment\"], resource.attributes[\"deployment.environment\"])",
      "set(attributes[\"service.version\"], resource.attributes[\"service.version\"])",
    ]
  }
  output {
    metrics = [otelcol.processor.k8sattributes.default.input]
  }
}
{{- end }}

otelcol.processor.resourcedetection "default" {
  detectors = ["env", "system"]

  system {
    hostname_sources = ["os"]
  }

  output {
{{- if .Values.metrics.enabled }}
    metrics = [otelcol.processor.transform.add_metric_datapoint_attributes.input]
{{- end }}
{{- if .Values.logs.enabled }}
    logs    = [otelcol.processor.k8sattributes.default.input]
{{- end }}
{{- if .Values.traces.enabled }}
    traces  = [otelcol.processor.k8sattributes.default.input]
{{- end }}
  }
}

otelcol.processor.k8sattributes "default" {
  extract {
{{- if .Values.receivers.processors.k8sattributes.metadata }}
    metadata = {{ .Values.receivers.processors.k8sattributes.metadata | toJson }}
{{- end }}
{{- range .Values.receivers.processors.k8sattributes.labels }}
    label {
    {{- range $k, $v := . }}
      {{ $k }} = {{ $v | quote }}
    {{- end }}
    }
{{- end }}
{{- range .Values.receivers.processors.k8sattributes.annotations }}
    annotation {
    {{- range $k, $v := . }}
      {{ $k }} = {{ $v | quote }}
    {{- end }}
    }
{{- end }}
  }
  pod_association {
    source {
      from = "connection"
    }
  }

  output {
{{- if .Values.metrics.enabled }}
    metrics = [otelcol.processor.transform.default.input]
{{- end }}
{{- if .Values.logs.enabled }}
    logs    = [otelcol.processor.transform.default.input]
{{- end }}
{{- if .Values.traces.enabled }}
    traces  = [
      otelcol.processor.transform.default.input, 
    {{- if and .Values.metrics.enabled .Values.receivers.grafanaCloudMetrics.enabled }}
      otelcol.connector.host_info.default.input,
    {{- end }}
    ]
{{- end }}
  }
}

{{- if and .Values.metrics.enabled .Values.traces.enabled .Values.receivers.grafanaCloudMetrics.enabled }}
otelcol.connector.host_info "default" {
  host_identifiers = [ "k8s.node.name" ]
  output {
    metrics = [otelcol.processor.batch.host_info_batch.input]
  }
}

otelcol.processor.batch "host_info_batch" {
  output {
  {{- if or (eq .Values.externalServices.prometheus.protocol "otlp") (eq .Values.externalServices.prometheus.protocol "otlphttp") }}
    metrics = [otelcol.processor.batch.metrics_service.input]
  }
}
  {{- end }}
  {{- if eq .Values.externalServices.prometheus.protocol "remote_write" }}
    metrics = [otelcol.exporter.prometheus.host_info_metrics.input]
  }
}

otelcol.exporter.prometheus "host_info_metrics" {
  add_metric_suffixes = false
  forward_to = [prometheus.remote_write.metrics_service.receiver]
}
  {{- end }}
{{- end }}

otelcol.processor.transform "default" {
  // Grafana Cloud Kubernetes monitoring expects Loki labels `cluster`, `pod`, and `namespace`
  error_mode = "ignore"
{{- if .Values.metrics.enabled }}
  metric_statements {
    context = "resource"
    statements = [
{{- if .Values.metrics.receiver.transforms.resource }}
{{- range $transform := .Values.metrics.receiver.transforms.resource }}
{{ $transform | quote | indent 6 }},
{{- end }}
{{- end }}
      "set(attributes[\"k8s.cluster.name\"], \"{{ required ".Values.cluster.name is a required value. Please set it and try again." .Values.cluster.name }}\") where attributes[\"k8s.cluster.name\"] == nil",
    ]
  }
{{- if .Values.metrics.receiver.transforms.metric }}
  metric_statements {
    context = "metric"
    statements = [
{{- range $transform := .Values.metrics.receiver.transforms.metric }}
{{ $transform | quote | indent 6 }},
{{- end }}
    ]
  }
{{- end }}
{{- if .Values.metrics.receiver.transforms.datapoint }}
  metric_statements {
    context = "datapoint"
    statements = [
{{- range $transform := .Values.metrics.receiver.transforms.datapoint }}
{{ $transform | quote | indent 6 }},
{{- end }}
    ]
  }
{{- end }}
{{- end }}
{{- if .Values.logs.enabled }}
  log_statements {
    context = "resource"
    statements = [
{{- if .Values.logs.receiver.transforms.resource }}
{{- range $transform := .Values.logs.receiver.transforms.resource }}
{{ $transform | quote | indent 6 }},
{{- end }}
{{- end }}
      "set(attributes[\"pod\"], attributes[\"k8s.pod.name\"])",
      "set(attributes[\"namespace\"], attributes[\"k8s.namespace.name\"])",
      "set(attributes[\"loki.resource.labels\"], \"{{ .Values.logs.receiver.transforms.labels | join ", " }}\")",
      "set(attributes[\"k8s.cluster.name\"], \"{{ required ".Values.cluster.name is a required value. Please set it and try again." .Values.cluster.name }}\") where attributes[\"k8s.cluster.name\"] == nil",
    ]
  }
{{- if .Values.logs.receiver.transforms.log }}
  log_statements {
    context = "log"
    statements = [
{{- range $transform := .Values.logs.receiver.transforms.log }}
{{ $transform | quote | indent 6 }},
{{- end }}
    ]
  }
{{- end }}
{{- end }}
{{- if .Values.traces.enabled }}
  trace_statements {
    context = "resource"
    statements = [
{{- if .Values.traces.receiver.transforms.resource }}
{{- range $transform := .Values.traces.receiver.transforms.resource }}
{{ $transform | quote | indent 6 }},
{{- end }}
{{- end }}
      "set(attributes[\"k8s.cluster.name\"], \"{{ required ".Values.cluster.name is a required value. Please set it and try again." .Values.cluster.name }}\") where attributes[\"k8s.cluster.name\"] == nil",
    ]
  }
{{- if .Values.traces.receiver.transforms.span }}
  trace_statements {
    context = "span"
    statements = [
{{- range $transform := .Values.traces.receiver.transforms.span }}
{{ $transform | quote | indent 6 }},
{{- end }}
    ]
  }
{{- end }}
{{- if .Values.traces.receiver.transforms.spanevent }}
  trace_statements {
    context = "spanevent"
    statements = [
{{- range $transform := .Values.traces.receiver.transforms.spanevent }}
{{ $transform | quote | indent 6 }},
{{- end }}
    ]
  }
{{- end }}
{{- end }}
  output {
{{- if .Values.metrics.enabled }}
    metrics = [otelcol.processor.filter.default.input]
{{- end }}
{{- if .Values.logs.enabled }}
    logs = [otelcol.processor.filter.default.input]
{{- end }}
{{- if .Values.traces.enabled }}
    traces = [otelcol.processor.filter.default.input]
{{- end }}
  }
}

otelcol.processor.filter "default" {
  error_mode = "ignore"

{{- if and .Values.metrics.enabled (or .Values.metrics.receiver.filters.metric .Values.metrics.receiver.filters.datapoint) }}
  metrics {
{{- if .Values.metrics.receiver.filters.metric }}
    metric = [
{{- range $filter := .Values.metrics.receiver.filters.metric }}
{{ $filter | quote | indent 6 }},
{{- end }}
    ]
{{- end }}
{{- if .Values.metrics.receiver.filters.datapoint }}
    datapoint = [
{{- range $filter := .Values.metrics.receiver.filters.datapoint }}
{{ $filter | quote | indent 6 }},
{{- end }}
    ]
{{- end }}
  }
{{- end }}
{{- if and .Values.logs.enabled .Values.logs.receiver.filters.log_record }}
  logs {
    log_record = [
{{- range $filter := .Values.logs.receiver.filters.log_record }}
{{ $filter | quote | indent 6 }},
{{- end }}
    ]
  }
{{- end }}
{{- if and .Values.traces.enabled (or .Values.traces.receiver.filters.span .Values.traces.receiver.filters.spanevent) }}
  traces {
{{- if .Values.traces.receiver.filters.span }}
    span = [
{{- range $filter := .Values.traces.receiver.filters.span }}
{{ $filter | quote | indent 6 }},
{{- end }}
    ]
{{- end }}
{{- if .Values.traces.receiver.filters.spanevent }}
    spanevent = [
{{- range $filter := .Values.traces.receiver.filters.spanevent }}
{{ $filter | quote | indent 6 }},
{{- end }}
    ]
{{- end }}
  }
{{- end }}

  output {
{{- if .Values.metrics.enabled }}
    metrics = [otelcol.processor.batch.batch_processor.input]
{{- end }}
{{- if .Values.logs.enabled }}
    logs = [otelcol.processor.batch.batch_processor.input]
{{- end }}
{{- if .Values.traces.enabled }}
    traces = [otelcol.processor.batch.batch_processor.input]
{{- end }}
  }
}

otelcol.processor.batch "batch_processor" {
{{- with .Values.receivers.processors.batch }}
  send_batch_size = {{ .size | int }}
  send_batch_max_size = {{ .maxSize | int }}
  timeout = {{ .timeout | quote}}
{{- end }}
  output {
{{- if .Values.metrics.enabled }}
    metrics = [otelcol.exporter.prometheus.metrics_converter.input]
{{- end }}
{{- if .Values.logs.enabled }}
    logs = [otelcol.exporter.loki.logs_converter.input]
{{- end }}
{{- if .Values.traces.enabled }}
{{- if eq .Values.externalServices.tempo.protocol "otlp" }}
    traces = [otelcol.exporter.otlp.traces_service.input]
{{- else if eq .Values.externalServices.tempo.protocol "otlphttp" }}
    traces = [otelcol.exporter.otlphttp.traces_service.input]
{{- end }}
{{- end }}
  }
}

{{- if .Values.metrics.enabled }}
otelcol.exporter.prometheus "metrics_converter" {
  forward_to = [prometheus.relabel.metrics_service.receiver]
}
{{- end }}
{{- if .Values.logs.enabled }}
otelcol.exporter.loki "logs_converter" {
  forward_to = [loki.process.pod_logs.receiver]
}
{{- end }}
{{- end }}
{{- end }}
