@bluedynamics/cdk8s-monitoring 0.1.2 → 0.2.1

package/examples/synth.ts

@@ -19,6 +19,12 @@ const config = mergeConfig({
     grafanaSecretStore: 'example-app-secrets-store',
     grafanaCredentialsKey: 'example-grafana-admin',
   },
+  tempo: {
+    enabled: true,
+    bucket: 'example-tempo',
+    retention: '336h',
+    tailSampling: { latencyThresholdMs: 1000, probabilisticPercent: 10 },
+  },
 });
 new MonitoringChart(app, 'monitoring', config);
 app.synth();

package/lib/constructs/alloy-traces.d.ts

@@ -0,0 +1,20 @@
+import { Construct } from 'constructs';
+import { MonitoringConfig } from '../types';
+export interface AlloyTracesProps {
+    namespace: string;
+    config: MonitoringConfig;
+}
+/**
+ * Creates a dedicated Alloy deployment as the OTLP traces gateway.
+ *
+ * Apps send OTLP (gRPC 4317 / HTTP 4318) to the `alloy-traces` service. This
+ * single-replica gateway tail-samples (all errors + slow traces + a probabilistic
+ * remainder) and exports to Tempo's OTLP distributor. One replica guarantees a
+ * single instance sees all spans of a trace, which tail-sampling requires.
+ *
+ * Sync Wave: 3 (advanced services, alongside Tempo).
+ */
+export declare class AlloyTracesConstruct extends Construct {
+    constructor(scope: Construct, id: string, props: AlloyTracesProps);
+    private generateHelmValues;
+}

package/lib/constructs/alloy-traces.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlloyTracesConstruct = void 0;
+const cdk8s_1 = require("cdk8s");
+const constructs_1 = require("constructs");
+/**
+ * Creates a dedicated Alloy deployment as the OTLP traces gateway.
+ *
+ * Apps send OTLP (gRPC 4317 / HTTP 4318) to the `alloy-traces` service. This
+ * single-replica gateway tail-samples (all errors + slow traces + a probabilistic
+ * remainder) and exports to Tempo's OTLP distributor. One replica guarantees a
+ * single instance sees all spans of a trace, which tail-sampling requires.
+ *
+ * Sync Wave: 3 (advanced services, alongside Tempo).
+ */
+class AlloyTracesConstruct extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const { namespace, config } = props;
+        new cdk8s_1.ApiObject(this, 'alloy-traces', {
+            apiVersion: 'helm.cattle.io/v1',
+            kind: 'HelmChart',
+            metadata: {
+                name: 'alloy-traces',
+                namespace: namespace,
+                labels: {
+                    'app.kubernetes.io/name': 'alloy-traces',
+                    'app.kubernetes.io/component': 'trace-collector',
+                    'app.kubernetes.io/managed-by': 'cdk8s',
+                    'app.kubernetes.io/part-of': 'monitoring',
+                },
+                annotations: {
+                    'argocd.argoproj.io/sync-wave': '3',
+                },
+            },
+            spec: {
+                repo: 'https://grafana.github.io/helm-charts',
+                chart: 'alloy',
+                version: config.versions.alloy === 'latest' ? undefined : config.versions.alloy,
+                targetNamespace: namespace,
+                valuesContent: this.generateHelmValues(config),
+            },
+        });
+    }
+    generateHelmValues(config) {
+        const ts = config.tempo.tailSampling;
+        return `controller:
+  type: deployment
+  replicas: 1
+alloy:
+  extraPorts:
+    - name: otlp-grpc
+      port: 4317
+      targetPort: 4317
+      protocol: TCP
+    - name: otlp-http
+      port: 4318
+      targetPort: 4318
+      protocol: TCP
+  configMap:
+    content: |-
+      otelcol.receiver.otlp "default" {
+        grpc { endpoint = "0.0.0.0:4317" }
+        http { endpoint = "0.0.0.0:4318" }
+        output { traces = [otelcol.processor.tail_sampling.default.input] }
+      }
+
+      otelcol.processor.tail_sampling "default" {
+        decision_wait = "10s"
+
+        policy {
+          name = "errors"
+          type = "status_code"
+          status_code { status_codes = ["ERROR"] }
+        }
+
+        policy {
+          name = "slow"
+          type = "latency"
+          latency { threshold_ms = ${ts.latencyThresholdMs} }
+        }
+
+        policy {
+          name = "rest"
+          type = "probabilistic"
+          probabilistic { sampling_percentage = ${ts.probabilisticPercent} }
+        }
+
+        output { traces = [otelcol.exporter.otlp.tempo.input] }
+      }
+
+      otelcol.exporter.otlp "tempo" {
+        client {
+          endpoint = "tempo.${config.namespace}.svc.cluster.local:4317"
+          tls { insecure = true }
+        }
+      }
+resources:
+  requests:
+    cpu: ${config.resources.alloyTraces.requests.cpu}
+    memory: ${config.resources.alloyTraces.requests.memory}
+  limits:
+    cpu: ${config.resources.alloyTraces.limits.cpu}
+    memory: ${config.resources.alloyTraces.limits.memory}
+`;
+    }
+}
+exports.AlloyTracesConstruct = AlloyTracesConstruct;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/constructs/prometheus-stack.js

@@ -57,6 +57,22 @@ class PrometheusStackConstruct extends constructs_1.Construct {
         });
     }
     generateHelmValues(config) {
+        // Tempo datasource is only provisioned when tracing is enabled. When
+        // disabled this is empty, so the Grafana block is byte-identical to before.
+        const tempoDatasource = config.tempo.enabled ? `
+      - name: Tempo
+        type: tempo
+        uid: tempo
+        access: proxy
+        url: http://tempo.${config.namespace}.svc.cluster.local:3200
+        jsonData:
+          tracesToLogsV2:
+            datasourceUid: loki
+            spanStartTimeShift: "-1h"
+            spanEndTimeShift: "1h"
+            filterByTraceID: true
+          tracesToMetrics:
+            datasourceUid: thanos` : '';
         return `kubeEtcd:
   enabled: false
 
@@ -436,7 +452,7 @@ grafana:
         access: proxy
         url: http://loki-gateway.${config.namespace}.svc.cluster.local
         jsonData:
-          maxLines: 1000
+          maxLines: 1000${tempoDatasource}
 
 prometheusOperator:
   resources:
@@ -479,4 +495,4 @@ kube-state-metrics:
     }
 }
 exports.PrometheusStackConstruct = PrometheusStackConstruct;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prometheus-stack.js","sourceRoot":"","sources":["../../src/constructs/prometheus-stack.ts"],"names":[],"mappings":"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","sourcesContent":["import { ApiObject } from 'cdk8s';\nimport { Construct } from 'constructs';\nimport { MonitoringConfig } from '../types';\n\nexport interface PrometheusStackProps {\n  namespace: string;\n  config: MonitoringConfig;\n}\n\n/**\n * Creates kube-prometheus-stack HelmChart with Prometheus, Grafana, and Alertmanager.\n *\n * This is the core monitoring stack that includes:\n * - Prometheus (metrics collection, 2 replicas, 3d retention)\n * - Grafana (visualization, ingress with Let's Encrypt)\n * - Alertmanager (alert routing, SMTP notifications)\n * - Prometheus Operator (manages Prometheus CRDs)\n * - Node Exporter (system metrics DaemonSet)\n * - kube-state-metrics (Kubernetes resource metrics)\n *\n * Prerequisites:\n * - Namespace exists\n * - PriorityClass 'high-priority' exists\n * - Longhorn storage class available\n * - cert-manager ClusterIssuer configured\n * - Thanos S3 secret exists (thanos-objstore-config)\n *\n * Sync Wave: 2 (core services - after S3 buckets and secrets)\n */\nexport class PrometheusStackConstruct extends Construct {\n  constructor(scope: Construct, id: string, props: PrometheusStackProps) {\n    super(scope, id);\n\n    const { namespace, config } = props;\n\n    // Generate Helm values YAML\n    const helmValues = this.generateHelmValues(config);\n\n    // Create HelmChart resource (K3S Helm controller)\n    // Wave 2: Core Services - monitoring stack\n    new ApiObject(this, 'kube-prometheus-stack', {\n      apiVersion: 'helm.cattle.io/v1',\n      kind: 'HelmChart',\n      metadata: {\n        name: 'kube-prometheus-stack',\n        namespace: namespace,\n        labels: {\n          'app.kubernetes.io/name': 'kube-prometheus-stack',\n          'app.kubernetes.io/component': 'monitoring',\n          'app.kubernetes.io/managed-by': 'cdk8s',\n          'app.kubernetes.io/part-of': 'monitoring',\n        },\n        annotations: {\n          'argocd.argoproj.io/sync-wave': '2',\n        },\n      },\n      spec: {\n        repo: 'https://prometheus-community.github.io/helm-charts',\n        chart: 'kube-prometheus-stack',\n        version: config.versions.prometheusStack === 'latest' ? undefined : config.versions.prometheusStack,\n        targetNamespace: namespace,\n        valuesContent: helmValues,\n      },\n    });\n  }\n\n  private generateHelmValues(config: MonitoringConfig): string {\n    return `kubeEtcd:\n  enabled: false\n\n# Disable kube-controller-manager and kube-scheduler monitoring. See https://github.com/cablespaghetti/k3s-monitoring/issues/2\nkubeControllerManager:\n  enabled: false\nkubeScheduler:\n  enabled: false\n\n# Detect PodDisruptionBudgets that would block a node drain during k3s upgrades.\n# Operator-managed PDBs sit at disruptionsAllowed=0 by design (Longhorn instance-managers,\n# CNPG *-primary) and are excluded so the alert only fires on anomalous app PDBs.\nadditionalPrometheusRulesMap:\n  pdb-drain-safety:\n    groups:\n      - name: pdb.rules\n        interval: 1m\n        rules:\n          - alert: PodDisruptionBudgetUndrainable\n            expr: kube_poddisruptionbudget_status_pod_disruptions_allowed{namespace!=\"longhorn-system\", poddisruptionbudget!~\".*-primary\"} == 0\n            for: 15m\n            labels:\n              severity: warning\n              component: cluster-upgrade\n            annotations:\n              summary: \"PDB {{ $labels.namespace }}/{{ $labels.poddisruptionbudget }} allows 0 voluntary disruptions\"\n              description: |\n                The PodDisruptionBudget {{ $labels.namespace }}/{{ $labels.poddisruptionbudget }}\n                has allowed 0 voluntary disruptions for over 15 minutes. This will block a node\n                drain during k3s upgrades. Operator-managed PDBs (Longhorn, CNPG primaries) are\n                excluded from this alert. Likely a degraded deployment (0 healthy pods) or a\n                single-replica deployment with minAvailable=1.\n                Check: kubectl get pdb -n {{ $labels.namespace }} {{ $labels.poddisruptionbudget }}\n          - alert: PodDisruptionBudgetUndrainableCritical\n            expr: kube_poddisruptionbudget_status_pod_disruptions_allowed{namespace!=\"longhorn-system\", poddisruptionbudget!~\".*-primary\"} == 0\n            for: 1h\n            labels:\n              severity: critical\n              component: cluster-upgrade\n            annotations:\n              summary: \"PDB {{ $labels.namespace }}/{{ $labels.poddisruptionbudget }} undrainable >1h\"\n              description: |\n                PDB {{ $labels.namespace }}/{{ $labels.poddisruptionbudget }} has blocked\n                voluntary disruptions for over an hour. A k3s agent upgrade would stall on this node.\n  # Detect an EX dedicated worker stuck NotReady — likely a MicroOS reboot hang\n  # (pings but sshd/kubelet dead). A hung node also holds the cluster-wide kured\n  # lock, blocking all further graceful reboots, so this must be caught fast.\n  ex-worker-reboot:\n    groups:\n      - name: ex-worker.rules\n        interval: 1m\n        rules:\n          - alert: ExWorkerNotReady\n            expr: kube_node_status_condition{condition=\"Ready\",status=\"true\",node=~\"kup6s-ex-.*\"} == 0\n            for: 15m\n            labels:\n              severity: critical\n              component: node\n            annotations:\n              summary: \"EX worker {{ $labels.node }} NotReady for >15m\"\n              description: |\n                EX dedicated worker {{ $labels.node }} has been NotReady for over 15 minutes.\n                Possible MicroOS reboot hang (pings but sshd/kubelet/longhorn-manager dead) — the\n                node may still hold the cluster-wide kured lock, blocking all further reboots.\n                Recovery: Hetzner Robot hardware reset. Do NOT force-detach Longhorn volumes.\n              runbook_url: \"https://docs.kup6s.com/how-to/troubleshooting/ex-worker-ping-but-dead.html\"\n\n# Drop high-cardinality API server and etcd histogram buckets to reduce memory usage\n# These metrics alone account for ~200k series (47% of total cardinality)\n# We keep _sum and _count suffixes which are sufficient for rate calculations\nkubeApiServer:\n  serviceMonitor:\n    metricRelabelings:\n      - sourceLabels: [__name__]\n        regex: 'apiserver_request_duration_seconds_bucket'\n        action: drop\n      - sourceLabels: [__name__]\n        regex: 'apiserver_request_sli_duration_seconds_bucket'\n        action: drop\n      - sourceLabels: [__name__]\n        regex: 'apiserver_request_body_size_bytes_bucket'\n        action: drop\n      - sourceLabels: [__name__]\n        regex: 'apiserver_response_sizes_bucket'\n        action: drop\n      - sourceLabels: [__name__]\n        regex: 'etcd_request_duration_seconds_bucket'\n        action: drop\n\n# Kubelet also exposes apiserver metrics - apply same filters\nkubelet:\n  serviceMonitor:\n    metricRelabelings:\n      - sourceLabels: [__name__]\n        regex: 'apiserver_request_duration_seconds_bucket'\n        action: drop\n      - sourceLabels: [__name__]\n        regex: 'apiserver_request_sli_duration_seconds_bucket'\n        action: drop\n      - sourceLabels: [__name__]\n        regex: 'apiserver_request_body_size_bytes_bucket'\n        action: drop\n      - sourceLabels: [__name__]\n        regex: 'apiserver_response_sizes_bucket'\n        action: drop\n      - sourceLabels: [__name__]\n        regex: 'etcd_request_duration_seconds_bucket'\n        action: drop\n\nalertmanager:\n  config:\n    global:\n      smtp_from: ${config.smtp.from}\n      smtp_smarthost: ${config.smtp.host}:${config.smtp.port}\n      smtp_require_tls: ${config.smtp.requireTls}\n      smtp_auth_username: ${config.smtp.username || config.smtp.from}\n      smtp_auth_password: ${config.smtp.password || ''}\n    route:\n      group_by: ['job']\n      group_wait: 30s\n      group_interval: 5m\n      repeat_interval: 1h\n      receiver: email\n      routes:\n      - match:\n          alertname: Watchdog\n        receiver: 'null'\n      - match:\n          alertname: CPUThrottlingHigh\n        receiver: 'null'\n      - match:\n          alertname: KubeMemoryOvercommit\n        receiver: 'null'\n      - match:\n          alertname: KubeCPUOvercommit\n        receiver: 'null'\n      - match:\n          alertname: KubeletTooManyPods\n        receiver: 'null'\n\n    receivers:\n    - name: 'null'\n    - name: email\n      email_configs:\n      - send_resolved: true\n        to: ${config.smtp.from}\n\n    # Inhibition rules allow to mute a set of alerts given that another alert is firing.\n    # We use this to mute any warning-level notifications if the same alert is already critical.\n    inhibit_rules:\n    - source_match:\n        severity: 'critical'\n      target_match:\n        severity: 'warning'\n      # Apply inhibition if the alertname is the same.\n      equal: ['alertname', 'namespace']\n\n  alertmanagerSpec:\n    replicas: ${config.replicas.alertmanager}\n    podAntiAffinity: \"soft\"\n    storage:\n      volumeClaimTemplate:\n        spec:\n          accessModes: [\"ReadWriteOnce\"]\n          resources:\n            requests:\n              storage: ${config.storage.alertmanager}\n    resources:\n      limits:\n        cpu: ${config.resources.alertmanager.limits.cpu}\n        memory: ${config.resources.alertmanager.limits.memory}\n      requests:\n        cpu: ${config.resources.alertmanager.requests.cpu}\n        memory: ${config.resources.alertmanager.requests.memory}\n    priorityClassName: high-priority\n\n    # Sidecar containers resource requests (added 2025-11-18)\n    containers:\n    - name: config-reloader\n      resources:\n        requests:\n          cpu: ${config.resources.configReloader.requests.cpu}\n          memory: ${config.resources.configReloader.requests.memory}\n        limits:\n          cpu: ${config.resources.configReloader.limits.cpu}\n          memory: ${config.resources.configReloader.limits.memory}\n\n\nprometheus:\n  # Enable Thanos service for gRPC communication\n  # Required for Helm chart to properly render Thanos sidecar configuration\n  thanosService:\n    enabled: true\n\n  prometheusSpec:\n    retention: ${config.retention.prometheus}  # Reduced from 7d - Thanos provides long-term storage in S3\n\n    # Discover ALL ServiceMonitors, PodMonitors and PrometheusRules in ALL namespaces\n    # Setting NilUsesHelmValues: false means nil selectors = \"select all\"\n    # Empty namespace selectors {} mean \"search all namespaces\"\n    # Without the rule* settings, ruleSelector keeps the chart default\n    # (matchLabels: {release: <name>}) and hand-authored PrometheusRules that\n    # lack the release label are silently ignored.\n    # Note: This does NOT affect Thanos sidecar - controlled by thanos.objectStorageConfig\n    serviceMonitorSelectorNilUsesHelmValues: false\n    podMonitorSelectorNilUsesHelmValues: false\n    ruleSelectorNilUsesHelmValues: false\n    serviceMonitorNamespaceSelector: {}\n    podMonitorNamespaceSelector: {}\n    ruleNamespaceSelector: {}\n\n    replicas: ${config.replicas.prometheus}\n    podAntiAffinity: \"hard\"\n    storageSpec:\n      volumeClaimTemplate:\n        spec:\n          storageClassName: longhorn\n          accessModes: [\"ReadWriteOnce\"]\n          resources:\n            requests:\n              storage: ${config.storage.prometheus}  # Reduced from 6Gi (3d retention needs less space)\n\n    resources:\n      limits:\n        cpu: ${config.resources.prometheus.limits.cpu}\n        memory: ${config.resources.prometheus.limits.memory}\n      requests:\n        cpu: ${config.resources.prometheus.requests.cpu}\n        memory: ${config.resources.prometheus.requests.memory}\n    priorityClassName: high-priority\n\n    # External labels for multi-cluster identification and Thanos\n    externalLabels:\n      cluster: kup6s\n      replica: \"$(POD_NAME)\"\n\n    # Thanos sidecar for long-term metrics storage in S3\n    # NOTE: chart >=85.x requires the existingSecret shape. The legacy flat\n    # {name, key} form is silently dropped by the chart, which removes the\n    # sidecar and stops all S3 block uploads (regression seen 2026-03-31).\n    thanos:\n      objectStorageConfig:\n        existingSecret:\n          name: thanos-objstore-config  # ESO-managed secret\n          key: objstore.yml\n\n    # Sidecar containers resource requests (added 2025-11-18)\n    # NOTE: thanos-sidecar is NOT listed here - it's automatically injected by Prometheus Operator\n    # when thanos.objectStorageConfig is set. Specifying it in containers[] would override\n    # the operator's definition and require us to manually specify the image, which breaks\n    # when the operator updates the thanos version.\n    containers:\n    - name: config-reloader\n      resources:\n        requests:\n          cpu: ${config.resources.configReloader.requests.cpu}\n          memory: ${config.resources.configReloader.requests.memory}\n        limits:\n          cpu: ${config.resources.configReloader.limits.cpu}\n          memory: ${config.resources.configReloader.limits.memory}\n\n    service:\n      sessionAffinity: \"ClientIP\"\n\n\ngrafana:\n  # Recreate strategy is required because the storage PVC is RWO:\n  # a RollingUpdate would surge a second pod that cannot mount the\n  # volume (FailedAttachVolume), blocking the rollout indefinitely.\n  deploymentStrategy:\n    type: Recreate\n\n  # Use existing secret for admin credentials (managed by ESO)\n  # This prevents password regeneration on Helm upgrades\n  admin:\n    existingSecret: \"grafana-admin-credentials\"\n    userKey: \"admin-user\"\n    passwordKey: \"admin-password\"\n\n  # Disable default Prometheus datasource (we provide our own pointing to Thanos Query)\n  defaultDatasourceEnabled: false\n\n  # Sidecar containers for dashboard/datasource provisioning\n  sidecar:\n    resources:\n      requests:\n        cpu: 10m\n        memory: 256Mi\n      limits:\n        cpu: 100m\n        memory: 512Mi\n    dashboards:\n      enabled: true\n    datasources:\n      enabled: false  # We manually provision datasources (Prometheus→Thanos, Loki)\n\n  ingress:\n    enabled: true\n    hosts:\n      - ${config.domains.grafana}\n    annotations:\n      cert-manager.io/cluster-issuer: \"letsencrypt-cluster-issuer\"\n      traefik.ingress.kubernetes.io/router.entrypoints: websecure\n    tls:\n      - secretName: grafana-general-tls\n        hosts:\n        - ${config.domains.grafana}\n\n  resources:\n    limits:\n      cpu: ${config.resources.grafana.limits.cpu}\n      memory: ${config.resources.grafana.limits.memory}\n    requests:\n      cpu: ${config.resources.grafana.requests.cpu}\n      memory: ${config.resources.grafana.requests.memory}\n\n  readinessProbe:\n    httpGet:\n      path: /api/health\n      port: 3000\n    initialDelaySeconds: 30\n    periodSeconds: 10\n    timeoutSeconds: 5\n    failureThreshold: 3\n\n  livenessProbe:\n    httpGet:\n      path: /api/health\n      port: 3000\n    initialDelaySeconds: 60\n    periodSeconds: 10\n    timeoutSeconds: 30\n    failureThreshold: 10\n\n  persistence:\n    enabled: true\n    storageClassName: longhorn\n    accessModes:\n      - ReadWriteOnce\n    size: ${config.storage.grafana}\n\n  # Manual datasource provisioning (sidecar disabled)\n  # Thanos Query → long-term/historical metrics (S3 via Store + live sidecar), default\n  # Prometheus → local, recent/high-res only (kept for low-latency recent queries)\n  # Loki for log aggregation\n  datasources:\n    datasources.yaml:\n      apiVersion: 1\n      # Delete any pre-existing Loki datasource (e.g. one created with a\n      # randomly generated UID before we pinned uid: loki). Without this,\n      # Grafana fails provisioning with \"data source not found\" because\n      # the upsert collides with the existing entry.\n      deleteDatasources:\n      - name: Loki\n        orgId: 1\n      datasources:\n      - name: Thanos\n        type: prometheus\n        uid: thanos\n        access: proxy\n        # thanos-query Service: http port 9090 -> container http 10902\n        url: http://thanos-query.${config.namespace}.svc.cluster.local:9090\n        isDefault: true\n        jsonData:\n          timeInterval: 30s\n      - name: Prometheus\n        type: prometheus\n        uid: prometheus\n        access: proxy\n        url: http://kube-prometheus-stack-prometheus.${config.namespace}.svc.cluster.local:9090\n        isDefault: false\n        jsonData:\n          timeInterval: 30s\n      - name: Loki\n        type: loki\n        uid: loki\n        access: proxy\n        url: http://loki-gateway.${config.namespace}.svc.cluster.local\n        jsonData:\n          maxLines: 1000\n\nprometheusOperator:\n  resources:\n    limits:\n      cpu: 1\n      memory: 512Mi\n    requests:\n      cpu: 50m\n      memory: 128Mi\n  priorityClassName: high-priority\n\nprometheus-node-exporter:\n  # Bind :9100 to the node InternalIP only, not 0.0.0.0. With kubeRBACProxy\n  # disabled the sub-chart sets HOST_IP from fieldRef status.hostIP, which is\n  # the node's InternalIP (EX: vSwitch 10.6.0.x via --node-ip; cloud: hcloud\n  # private IP). node-exporter is hostNetwork, so Prometheus already scrapes\n  # that InternalIP endpoint -> scraping is unaffected, only the public-NIC\n  # exposure of the unauthenticated metrics on the EX public IPs goes away.\n  service:\n    listenOnAllInterfaces: false\n  resources:\n    limits:\n      cpu: 50m\n      memory: 50Mi\n    requests:\n      cpu: 5m\n      memory: 16Mi\n  priorityClassName: high-priority\n\nkube-state-metrics:\n  resources:\n    limits:\n      cpu: 1\n      memory: 512Mi\n    requests:\n      cpu: 5m\n      memory: 128Mi\n  priorityClassName: high-priority\n`;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prometheus-stack.js","sourceRoot":"","sources":["../../src/constructs/prometheus-stack.ts"],"names":[],"mappings":"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","sourcesContent":["import { ApiObject } from 'cdk8s';\nimport { Construct } from 'constructs';\nimport { MonitoringConfig } from '../types';\n\nexport interface PrometheusStackProps {\n  namespace: string;\n  config: MonitoringConfig;\n}\n\n/**\n * Creates kube-prometheus-stack HelmChart with Prometheus, Grafana, and Alertmanager.\n *\n * This is the core monitoring stack that includes:\n * - Prometheus (metrics collection, 2 replicas, 3d retention)\n * - Grafana (visualization, ingress with Let's Encrypt)\n * - Alertmanager (alert routing, SMTP notifications)\n * - Prometheus Operator (manages Prometheus CRDs)\n * - Node Exporter (system metrics DaemonSet)\n * - kube-state-metrics (Kubernetes resource metrics)\n *\n * Prerequisites:\n * - Namespace exists\n * - PriorityClass 'high-priority' exists\n * - Longhorn storage class available\n * - cert-manager ClusterIssuer configured\n * - Thanos S3 secret exists (thanos-objstore-config)\n *\n * Sync Wave: 2 (core services - after S3 buckets and secrets)\n */\nexport class PrometheusStackConstruct extends Construct {\n  constructor(scope: Construct, id: string, props: PrometheusStackProps) {\n    super(scope, id);\n\n    const { namespace, config } = props;\n\n    // Generate Helm values YAML\n    const helmValues = this.generateHelmValues(config);\n\n    // Create HelmChart resource (K3S Helm controller)\n    // Wave 2: Core Services - monitoring stack\n    new ApiObject(this, 'kube-prometheus-stack', {\n      apiVersion: 'helm.cattle.io/v1',\n      kind: 'HelmChart',\n      metadata: {\n        name: 'kube-prometheus-stack',\n        namespace: namespace,\n        labels: {\n          'app.kubernetes.io/name': 'kube-prometheus-stack',\n          'app.kubernetes.io/component': 'monitoring',\n          'app.kubernetes.io/managed-by': 'cdk8s',\n          'app.kubernetes.io/part-of': 'monitoring',\n        },\n        annotations: {\n          'argocd.argoproj.io/sync-wave': '2',\n        },\n      },\n      spec: {\n        repo: 'https://prometheus-community.github.io/helm-charts',\n        chart: 'kube-prometheus-stack',\n        version: config.versions.prometheusStack === 'latest' ? undefined : config.versions.prometheusStack,\n        targetNamespace: namespace,\n        valuesContent: helmValues,\n      },\n    });\n  }\n\n  private generateHelmValues(config: MonitoringConfig): string {\n    // Tempo datasource is only provisioned when tracing is enabled. When\n    // disabled this is empty, so the Grafana block is byte-identical to before.\n    const tempoDatasource = config.tempo.enabled ? `\n      - name: Tempo\n        type: tempo\n        uid: tempo\n        access: proxy\n        url: http://tempo.${config.namespace}.svc.cluster.local:3200\n        jsonData:\n          tracesToLogsV2:\n            datasourceUid: loki\n            spanStartTimeShift: \"-1h\"\n            spanEndTimeShift: \"1h\"\n            filterByTraceID: true\n          tracesToMetrics:\n            datasourceUid: thanos` : '';\n    return `kubeEtcd:\n  enabled: false\n\n# Disable kube-controller-manager and kube-scheduler monitoring. See https://github.com/cablespaghetti/k3s-monitoring/issues/2\nkubeControllerManager:\n  enabled: false\nkubeScheduler:\n  enabled: false\n\n# Detect PodDisruptionBudgets that would block a node drain during k3s upgrades.\n# Operator-managed PDBs sit at disruptionsAllowed=0 by design (Longhorn instance-managers,\n# CNPG *-primary) and are excluded so the alert only fires on anomalous app PDBs.\nadditionalPrometheusRulesMap:\n  pdb-drain-safety:\n    groups:\n      - name: pdb.rules\n        interval: 1m\n        rules:\n          - alert: PodDisruptionBudgetUndrainable\n            expr: kube_poddisruptionbudget_status_pod_disruptions_allowed{namespace!=\"longhorn-system\", poddisruptionbudget!~\".*-primary\"} == 0\n            for: 15m\n            labels:\n              severity: warning\n              component: cluster-upgrade\n            annotations:\n              summary: \"PDB {{ $labels.namespace }}/{{ $labels.poddisruptionbudget }} allows 0 voluntary disruptions\"\n              description: |\n                The PodDisruptionBudget {{ $labels.namespace }}/{{ $labels.poddisruptionbudget }}\n                has allowed 0 voluntary disruptions for over 15 minutes. This will block a node\n                drain during k3s upgrades. Operator-managed PDBs (Longhorn, CNPG primaries) are\n                excluded from this alert. Likely a degraded deployment (0 healthy pods) or a\n                single-replica deployment with minAvailable=1.\n                Check: kubectl get pdb -n {{ $labels.namespace }} {{ $labels.poddisruptionbudget }}\n          - alert: PodDisruptionBudgetUndrainableCritical\n            expr: kube_poddisruptionbudget_status_pod_disruptions_allowed{namespace!=\"longhorn-system\", poddisruptionbudget!~\".*-primary\"} == 0\n            for: 1h\n            labels:\n              severity: critical\n              component: cluster-upgrade\n            annotations:\n              summary: \"PDB {{ $labels.namespace }}/{{ $labels.poddisruptionbudget }} undrainable >1h\"\n              description: |\n                PDB {{ $labels.namespace }}/{{ $labels.poddisruptionbudget }} has blocked\n                voluntary disruptions for over an hour. A k3s agent upgrade would stall on this node.\n  # Detect an EX dedicated worker stuck NotReady — likely a MicroOS reboot hang\n  # (pings but sshd/kubelet dead). A hung node also holds the cluster-wide kured\n  # lock, blocking all further graceful reboots, so this must be caught fast.\n  ex-worker-reboot:\n    groups:\n      - name: ex-worker.rules\n        interval: 1m\n        rules:\n          - alert: ExWorkerNotReady\n            expr: kube_node_status_condition{condition=\"Ready\",status=\"true\",node=~\"kup6s-ex-.*\"} == 0\n            for: 15m\n            labels:\n              severity: critical\n              component: node\n            annotations:\n              summary: \"EX worker {{ $labels.node }} NotReady for >15m\"\n              description: |\n                EX dedicated worker {{ $labels.node }} has been NotReady for over 15 minutes.\n                Possible MicroOS reboot hang (pings but sshd/kubelet/longhorn-manager dead) — the\n                node may still hold the cluster-wide kured lock, blocking all further reboots.\n                Recovery: Hetzner Robot hardware reset. Do NOT force-detach Longhorn volumes.\n              runbook_url: \"https://docs.kup6s.com/how-to/troubleshooting/ex-worker-ping-but-dead.html\"\n\n# Drop high-cardinality API server and etcd histogram buckets to reduce memory usage\n# These metrics alone account for ~200k series (47% of total cardinality)\n# We keep _sum and _count suffixes which are sufficient for rate calculations\nkubeApiServer:\n  serviceMonitor:\n    metricRelabelings:\n      - sourceLabels: [__name__]\n        regex: 'apiserver_request_duration_seconds_bucket'\n        action: drop\n      - sourceLabels: [__name__]\n        regex: 'apiserver_request_sli_duration_seconds_bucket'\n        action: drop\n      - sourceLabels: [__name__]\n        regex: 'apiserver_request_body_size_bytes_bucket'\n        action: drop\n      - sourceLabels: [__name__]\n        regex: 'apiserver_response_sizes_bucket'\n        action: drop\n      - sourceLabels: [__name__]\n        regex: 'etcd_request_duration_seconds_bucket'\n        action: drop\n\n# Kubelet also exposes apiserver metrics - apply same filters\nkubelet:\n  serviceMonitor:\n    metricRelabelings:\n      - sourceLabels: [__name__]\n        regex: 'apiserver_request_duration_seconds_bucket'\n        action: drop\n      - sourceLabels: [__name__]\n        regex: 'apiserver_request_sli_duration_seconds_bucket'\n        action: drop\n      - sourceLabels: [__name__]\n        regex: 'apiserver_request_body_size_bytes_bucket'\n        action: drop\n      - sourceLabels: [__name__]\n        regex: 'apiserver_response_sizes_bucket'\n        action: drop\n      - sourceLabels: [__name__]\n        regex: 'etcd_request_duration_seconds_bucket'\n        action: drop\n\nalertmanager:\n  config:\n    global:\n      smtp_from: ${config.smtp.from}\n      smtp_smarthost: ${config.smtp.host}:${config.smtp.port}\n      smtp_require_tls: ${config.smtp.requireTls}\n      smtp_auth_username: ${config.smtp.username || config.smtp.from}\n      smtp_auth_password: ${config.smtp.password || ''}\n    route:\n      group_by: ['job']\n      group_wait: 30s\n      group_interval: 5m\n      repeat_interval: 1h\n      receiver: email\n      routes:\n      - match:\n          alertname: Watchdog\n        receiver: 'null'\n      - match:\n          alertname: CPUThrottlingHigh\n        receiver: 'null'\n      - match:\n          alertname: KubeMemoryOvercommit\n        receiver: 'null'\n      - match:\n          alertname: KubeCPUOvercommit\n        receiver: 'null'\n      - match:\n          alertname: KubeletTooManyPods\n        receiver: 'null'\n\n    receivers:\n    - name: 'null'\n    - name: email\n      email_configs:\n      - send_resolved: true\n        to: ${config.smtp.from}\n\n    # Inhibition rules allow to mute a set of alerts given that another alert is firing.\n    # We use this to mute any warning-level notifications if the same alert is already critical.\n    inhibit_rules:\n    - source_match:\n        severity: 'critical'\n      target_match:\n        severity: 'warning'\n      # Apply inhibition if the alertname is the same.\n      equal: ['alertname', 'namespace']\n\n  alertmanagerSpec:\n    replicas: ${config.replicas.alertmanager}\n    podAntiAffinity: \"soft\"\n    storage:\n      volumeClaimTemplate:\n        spec:\n          accessModes: [\"ReadWriteOnce\"]\n          resources:\n            requests:\n              storage: ${config.storage.alertmanager}\n    resources:\n      limits:\n        cpu: ${config.resources.alertmanager.limits.cpu}\n        memory: ${config.resources.alertmanager.limits.memory}\n      requests:\n        cpu: ${config.resources.alertmanager.requests.cpu}\n        memory: ${config.resources.alertmanager.requests.memory}\n    priorityClassName: high-priority\n\n    # Sidecar containers resource requests (added 2025-11-18)\n    containers:\n    - name: config-reloader\n      resources:\n        requests:\n          cpu: ${config.resources.configReloader.requests.cpu}\n          memory: ${config.resources.configReloader.requests.memory}\n        limits:\n          cpu: ${config.resources.configReloader.limits.cpu}\n          memory: ${config.resources.configReloader.limits.memory}\n\n\nprometheus:\n  # Enable Thanos service for gRPC communication\n  # Required for Helm chart to properly render Thanos sidecar configuration\n  thanosService:\n    enabled: true\n\n  prometheusSpec:\n    retention: ${config.retention.prometheus}  # Reduced from 7d - Thanos provides long-term storage in S3\n\n    # Discover ALL ServiceMonitors, PodMonitors and PrometheusRules in ALL namespaces\n    # Setting NilUsesHelmValues: false means nil selectors = \"select all\"\n    # Empty namespace selectors {} mean \"search all namespaces\"\n    # Without the rule* settings, ruleSelector keeps the chart default\n    # (matchLabels: {release: <name>}) and hand-authored PrometheusRules that\n    # lack the release label are silently ignored.\n    # Note: This does NOT affect Thanos sidecar - controlled by thanos.objectStorageConfig\n    serviceMonitorSelectorNilUsesHelmValues: false\n    podMonitorSelectorNilUsesHelmValues: false\n    ruleSelectorNilUsesHelmValues: false\n    serviceMonitorNamespaceSelector: {}\n    podMonitorNamespaceSelector: {}\n    ruleNamespaceSelector: {}\n\n    replicas: ${config.replicas.prometheus}\n    podAntiAffinity: \"hard\"\n    storageSpec:\n      volumeClaimTemplate:\n        spec:\n          storageClassName: longhorn\n          accessModes: [\"ReadWriteOnce\"]\n          resources:\n            requests:\n              storage: ${config.storage.prometheus}  # Reduced from 6Gi (3d retention needs less space)\n\n    resources:\n      limits:\n        cpu: ${config.resources.prometheus.limits.cpu}\n        memory: ${config.resources.prometheus.limits.memory}\n      requests:\n        cpu: ${config.resources.prometheus.requests.cpu}\n        memory: ${config.resources.prometheus.requests.memory}\n    priorityClassName: high-priority\n\n    # External labels for multi-cluster identification and Thanos\n    externalLabels:\n      cluster: kup6s\n      replica: \"$(POD_NAME)\"\n\n    # Thanos sidecar for long-term metrics storage in S3\n    # NOTE: chart >=85.x requires the existingSecret shape. The legacy flat\n    # {name, key} form is silently dropped by the chart, which removes the\n    # sidecar and stops all S3 block uploads (regression seen 2026-03-31).\n    thanos:\n      objectStorageConfig:\n        existingSecret:\n          name: thanos-objstore-config  # ESO-managed secret\n          key: objstore.yml\n\n    # Sidecar containers resource requests (added 2025-11-18)\n    # NOTE: thanos-sidecar is NOT listed here - it's automatically injected by Prometheus Operator\n    # when thanos.objectStorageConfig is set. Specifying it in containers[] would override\n    # the operator's definition and require us to manually specify the image, which breaks\n    # when the operator updates the thanos version.\n    containers:\n    - name: config-reloader\n      resources:\n        requests:\n          cpu: ${config.resources.configReloader.requests.cpu}\n          memory: ${config.resources.configReloader.requests.memory}\n        limits:\n          cpu: ${config.resources.configReloader.limits.cpu}\n          memory: ${config.resources.configReloader.limits.memory}\n\n    service:\n      sessionAffinity: \"ClientIP\"\n\n\ngrafana:\n  # Recreate strategy is required because the storage PVC is RWO:\n  # a RollingUpdate would surge a second pod that cannot mount the\n  # volume (FailedAttachVolume), blocking the rollout indefinitely.\n  deploymentStrategy:\n    type: Recreate\n\n  # Use existing secret for admin credentials (managed by ESO)\n  # This prevents password regeneration on Helm upgrades\n  admin:\n    existingSecret: \"grafana-admin-credentials\"\n    userKey: \"admin-user\"\n    passwordKey: \"admin-password\"\n\n  # Disable default Prometheus datasource (we provide our own pointing to Thanos Query)\n  defaultDatasourceEnabled: false\n\n  # Sidecar containers for dashboard/datasource provisioning\n  sidecar:\n    resources:\n      requests:\n        cpu: 10m\n        memory: 256Mi\n      limits:\n        cpu: 100m\n        memory: 512Mi\n    dashboards:\n      enabled: true\n    datasources:\n      enabled: false  # We manually provision datasources (Prometheus→Thanos, Loki)\n\n  ingress:\n    enabled: true\n    hosts:\n      - ${config.domains.grafana}\n    annotations:\n      cert-manager.io/cluster-issuer: \"letsencrypt-cluster-issuer\"\n      traefik.ingress.kubernetes.io/router.entrypoints: websecure\n    tls:\n      - secretName: grafana-general-tls\n        hosts:\n        - ${config.domains.grafana}\n\n  resources:\n    limits:\n      cpu: ${config.resources.grafana.limits.cpu}\n      memory: ${config.resources.grafana.limits.memory}\n    requests:\n      cpu: ${config.resources.grafana.requests.cpu}\n      memory: ${config.resources.grafana.requests.memory}\n\n  readinessProbe:\n    httpGet:\n      path: /api/health\n      port: 3000\n    initialDelaySeconds: 30\n    periodSeconds: 10\n    timeoutSeconds: 5\n    failureThreshold: 3\n\n  livenessProbe:\n    httpGet:\n      path: /api/health\n      port: 3000\n    initialDelaySeconds: 60\n    periodSeconds: 10\n    timeoutSeconds: 30\n    failureThreshold: 10\n\n  persistence:\n    enabled: true\n    storageClassName: longhorn\n    accessModes:\n      - ReadWriteOnce\n    size: ${config.storage.grafana}\n\n  # Manual datasource provisioning (sidecar disabled)\n  # Thanos Query → long-term/historical metrics (S3 via Store + live sidecar), default\n  # Prometheus → local, recent/high-res only (kept for low-latency recent queries)\n  # Loki for log aggregation\n  datasources:\n    datasources.yaml:\n      apiVersion: 1\n      # Delete any pre-existing Loki datasource (e.g. one created with a\n      # randomly generated UID before we pinned uid: loki). Without this,\n      # Grafana fails provisioning with \"data source not found\" because\n      # the upsert collides with the existing entry.\n      deleteDatasources:\n      - name: Loki\n        orgId: 1\n      datasources:\n      - name: Thanos\n        type: prometheus\n        uid: thanos\n        access: proxy\n        # thanos-query Service: http port 9090 -> container http 10902\n        url: http://thanos-query.${config.namespace}.svc.cluster.local:9090\n        isDefault: true\n        jsonData:\n          timeInterval: 30s\n      - name: Prometheus\n        type: prometheus\n        uid: prometheus\n        access: proxy\n        url: http://kube-prometheus-stack-prometheus.${config.namespace}.svc.cluster.local:9090\n        isDefault: false\n        jsonData:\n          timeInterval: 30s\n      - name: Loki\n        type: loki\n        uid: loki\n        access: proxy\n        url: http://loki-gateway.${config.namespace}.svc.cluster.local\n        jsonData:\n          maxLines: 1000${tempoDatasource}\n\nprometheusOperator:\n  resources:\n    limits:\n      cpu: 1\n      memory: 512Mi\n    requests:\n      cpu: 50m\n      memory: 128Mi\n  priorityClassName: high-priority\n\nprometheus-node-exporter:\n  # Bind :9100 to the node InternalIP only, not 0.0.0.0. With kubeRBACProxy\n  # disabled the sub-chart sets HOST_IP from fieldRef status.hostIP, which is\n  # the node's InternalIP (EX: vSwitch 10.6.0.x via --node-ip; cloud: hcloud\n  # private IP). node-exporter is hostNetwork, so Prometheus already scrapes\n  # that InternalIP endpoint -> scraping is unaffected, only the public-NIC\n  # exposure of the unauthenticated metrics on the EX public IPs goes away.\n  service:\n    listenOnAllInterfaces: false\n  resources:\n    limits:\n      cpu: 50m\n      memory: 50Mi\n    requests:\n      cpu: 5m\n      memory: 16Mi\n  priorityClassName: high-priority\n\nkube-state-metrics:\n  resources:\n    limits:\n      cpu: 1\n      memory: 512Mi\n    requests:\n      cpu: 5m\n      memory: 128Mi\n  priorityClassName: high-priority\n`;\n  }\n}\n"]}

package/lib/constructs/tempo-s3-bucket.d.ts

@@ -0,0 +1,24 @@
+import { Construct } from 'constructs';
+import { MonitoringConfig } from '../types';
+export interface TempoS3BucketProps {
+    config: MonitoringConfig;
+}
+/**
+ * Creates Crossplane Bucket resources for Tempo trace storage.
+ *
+ * This construct generates:
+ * - S3 Bucket (via Crossplane Upbound provider-aws-s3)
+ * - BucketVersioning (for recovery of accidentally deleted blocks)
+ * - BucketLifecycleConfiguration (retention buffer)
+ *
+ * Prerequisites:
+ * - Crossplane operator installed
+ * - Upbound provider-aws-s3 installed
+ * - Crossplane ProviderConfig named by config.integrations.s3ProviderConfig exists
+ * - Hetzner S3 credentials secret exists in crossplane-system
+ *
+ * Sync Wave: 1 (external dependencies - must exist before pods access S3)
+ */
+export declare class TempoS3BucketConstruct extends Construct {
+    constructor(scope: Construct, id: string, props: TempoS3BucketProps);
+}

package/lib/constructs/tempo-s3-bucket.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TempoS3BucketConstruct = void 0;
+const cdk8s_1 = require("cdk8s");
+const constructs_1 = require("constructs");
+const s3_aws_upbound_io_1 = require("../imports/s3.aws.upbound.io");
+/**
+ * Creates Crossplane Bucket resources for Tempo trace storage.
+ *
+ * This construct generates:
+ * - S3 Bucket (via Crossplane Upbound provider-aws-s3)
+ * - BucketVersioning (for recovery of accidentally deleted blocks)
+ * - BucketLifecycleConfiguration (retention buffer)
+ *
+ * Prerequisites:
+ * - Crossplane operator installed
+ * - Upbound provider-aws-s3 installed
+ * - Crossplane ProviderConfig named by config.integrations.s3ProviderConfig exists
+ * - Hetzner S3 credentials secret exists in crossplane-system
+ *
+ * Sync Wave: 1 (external dependencies - must exist before pods access S3)
+ */
+class TempoS3BucketConstruct extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const { config } = props;
+        const bucketName = config.tempo.bucket;
+        const region = config.s3.region;
+        // Create Bucket
+        // Wave 1: External Dependencies - S3 bucket provisioned by Crossplane
+        new cdk8s_1.ApiObject(this, 'bucket', {
+            apiVersion: 's3.aws.upbound.io/v1beta2',
+            kind: 'Bucket',
+            metadata: {
+                name: bucketName,
+                namespace: 'crossplane-system',
+                labels: {
+                    'app.kubernetes.io/name': 'tempo',
+                    'app.kubernetes.io/component': 'storage',
+                    'app.kubernetes.io/managed-by': 'cdk8s',
+                    'app.kubernetes.io/part-of': 'monitoring',
+                },
+                annotations: {
+                    'argocd.argoproj.io/sync-wave': '1',
+                    'crossplane.io/external-name': bucketName,
+                    'description': 'Tempo trace storage',
+                },
+            },
+            spec: {
+                deletionPolicy: 'Delete',
+                managementPolicies: [
+                    'Observe',
+                    'Create',
+                    'Delete',
+                    // Skip Update to avoid tagging operations (not supported by Hetzner S3)
+                ],
+                forProvider: {
+                    region: region, // Production region (endpoint determines actual location)
+                },
+                providerConfigRef: {
+                    name: config.integrations.s3ProviderConfig,
+                },
+            },
+        });
+        // Create BucketVersioning
+        new cdk8s_1.ApiObject(this, 'versioning', {
+            apiVersion: 's3.aws.upbound.io/v1beta2',
+            kind: 'BucketVersioning',
+            metadata: {
+                name: 'tempo-traces-versioning',
+                namespace: 'crossplane-system',
+                labels: {
+                    'app.kubernetes.io/name': 'tempo',
+                    'app.kubernetes.io/component': 'storage',
+                    'app.kubernetes.io/managed-by': 'cdk8s',
+                    'app.kubernetes.io/part-of': 'monitoring',
+                },
+                annotations: {
+                    'argocd.argoproj.io/sync-wave': '1',
+                },
+            },
+            spec: {
+                forProvider: {
+                    region: region,
+                    bucketRef: {
+                        name: bucketName,
+                    },
+                    versioningConfiguration: {
+                        status: 'Enabled',
+                    },
+                },
+                providerConfigRef: {
+                    name: config.integrations.s3ProviderConfig,
+                },
+            },
+        });
+        // Create BucketLifecycleConfiguration
+        // Lifecycle policy: delete trace blocks older than the buffer window.
+        // Tempo's own compactor enforces tempo.retention; this is a storage-side safety net.
+        new s3_aws_upbound_io_1.BucketLifecycleConfiguration(this, 'lifecycle', {
+            metadata: {
+                name: 'tempo-traces-lifecycle',
+                namespace: 'crossplane-system',
+                labels: {
+                    'app.kubernetes.io/name': 'tempo',
+                    'app.kubernetes.io/component': 'storage',
+                    'app.kubernetes.io/managed-by': 'cdk8s',
+                    'app.kubernetes.io/part-of': 'monitoring',
+                },
+                annotations: {
+                    'argocd.argoproj.io/sync-wave': '1',
+                },
+            },
+            spec: {
+                managementPolicies: [
+                    s3_aws_upbound_io_1.BucketLifecycleConfigurationSpecManagementPolicies.OBSERVE,
+                    s3_aws_upbound_io_1.BucketLifecycleConfigurationSpecManagementPolicies.CREATE,
+                    s3_aws_upbound_io_1.BucketLifecycleConfigurationSpecManagementPolicies.DELETE,
+                ],
+                forProvider: {
+                    region: region,
+                    bucketRef: {
+                        name: bucketName,
+                    },
+                    rule: [
+                        {
+                            id: 'delete-old-traces',
+                            status: 'Enabled',
+                            expiration: [
+                                {
+                                    days: 30, // storage-side safety net beyond Tempo's block retention
+                                },
+                            ],
+                        },
+                    ],
+                },
+                providerConfigRef: {
+                    name: config.integrations.s3ProviderConfig,
+                },
+            },
+        });
+    }
+}
+exports.TempoS3BucketConstruct = TempoS3BucketConstruct;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tempo-s3-bucket.js","sourceRoot":"","sources":["../../src/constructs/tempo-s3-bucket.ts"],"names":[],"mappings":"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","sourcesContent":["import { ApiObject } from 'cdk8s';\nimport { Construct } from 'constructs';\nimport { BucketLifecycleConfiguration, BucketLifecycleConfigurationSpecManagementPolicies } from '../imports/s3.aws.upbound.io';\nimport { MonitoringConfig } from '../types';\n\nexport interface TempoS3BucketProps {\n  config: MonitoringConfig;\n}\n\n/**\n * Creates Crossplane Bucket resources for Tempo trace storage.\n *\n * This construct generates:\n * - S3 Bucket (via Crossplane Upbound provider-aws-s3)\n * - BucketVersioning (for recovery of accidentally deleted blocks)\n * - BucketLifecycleConfiguration (retention buffer)\n *\n * Prerequisites:\n * - Crossplane operator installed\n * - Upbound provider-aws-s3 installed\n * - Crossplane ProviderConfig named by config.integrations.s3ProviderConfig exists\n * - Hetzner S3 credentials secret exists in crossplane-system\n *\n * Sync Wave: 1 (external dependencies - must exist before pods access S3)\n */\nexport class TempoS3BucketConstruct extends Construct {\n  constructor(scope: Construct, id: string, props: TempoS3BucketProps) {\n    super(scope, id);\n\n    const { config } = props;\n    const bucketName = config.tempo.bucket;\n    const region = config.s3.region;\n\n    // Create Bucket\n    // Wave 1: External Dependencies - S3 bucket provisioned by Crossplane\n    new ApiObject(this, 'bucket', {\n      apiVersion: 's3.aws.upbound.io/v1beta2',\n      kind: 'Bucket',\n      metadata: {\n        name: bucketName,\n        namespace: 'crossplane-system',\n        labels: {\n          'app.kubernetes.io/name': 'tempo',\n          'app.kubernetes.io/component': 'storage',\n          'app.kubernetes.io/managed-by': 'cdk8s',\n          'app.kubernetes.io/part-of': 'monitoring',\n        },\n        annotations: {\n          'argocd.argoproj.io/sync-wave': '1',\n          'crossplane.io/external-name': bucketName,\n          'description': 'Tempo trace storage',\n        },\n      },\n      spec: {\n        deletionPolicy: 'Delete',\n        managementPolicies: [\n          'Observe',\n          'Create',\n          'Delete',\n          // Skip Update to avoid tagging operations (not supported by Hetzner S3)\n        ],\n        forProvider: {\n          region: region, // Production region (endpoint determines actual location)\n        },\n        providerConfigRef: {\n          name: config.integrations.s3ProviderConfig,\n        },\n      },\n    });\n\n    // Create BucketVersioning\n    new ApiObject(this, 'versioning', {\n      apiVersion: 's3.aws.upbound.io/v1beta2',\n      kind: 'BucketVersioning',\n      metadata: {\n        name: 'tempo-traces-versioning',\n        namespace: 'crossplane-system',\n        labels: {\n          'app.kubernetes.io/name': 'tempo',\n          'app.kubernetes.io/component': 'storage',\n          'app.kubernetes.io/managed-by': 'cdk8s',\n          'app.kubernetes.io/part-of': 'monitoring',\n        },\n        annotations: {\n          'argocd.argoproj.io/sync-wave': '1',\n        },\n      },\n      spec: {\n        forProvider: {\n          region: region,\n          bucketRef: {\n            name: bucketName,\n          },\n          versioningConfiguration: {\n            status: 'Enabled',\n          },\n        },\n        providerConfigRef: {\n          name: config.integrations.s3ProviderConfig,\n        },\n      },\n    });\n\n    // Create BucketLifecycleConfiguration\n    // Lifecycle policy: delete trace blocks older than the buffer window.\n    // Tempo's own compactor enforces tempo.retention; this is a storage-side safety net.\n    new BucketLifecycleConfiguration(this, 'lifecycle', {\n      metadata: {\n        name: 'tempo-traces-lifecycle',\n        namespace: 'crossplane-system',\n        labels: {\n          'app.kubernetes.io/name': 'tempo',\n          'app.kubernetes.io/component': 'storage',\n          'app.kubernetes.io/managed-by': 'cdk8s',\n          'app.kubernetes.io/part-of': 'monitoring',\n        },\n        annotations: {\n          'argocd.argoproj.io/sync-wave': '1',\n        },\n      },\n      spec: {\n        managementPolicies: [\n          BucketLifecycleConfigurationSpecManagementPolicies.OBSERVE,\n          BucketLifecycleConfigurationSpecManagementPolicies.CREATE,\n          BucketLifecycleConfigurationSpecManagementPolicies.DELETE,\n        ],\n        forProvider: {\n          region: region,\n          bucketRef: {\n            name: bucketName,\n          },\n          rule: [\n            {\n              id: 'delete-old-traces',\n              status: 'Enabled',\n              expiration: [\n                {\n                  days: 30, // storage-side safety net beyond Tempo's block retention\n                },\n              ],\n            },\n          ],\n        },\n        providerConfigRef: {\n          name: config.integrations.s3ProviderConfig,\n        },\n      },\n    });\n  }\n}\n"]}

package/lib/constructs/tempo-s3-credentials.d.ts

@@ -0,0 +1,27 @@
+import { Construct } from 'constructs';
+import { MonitoringConfig } from '../types';
+export interface TempoS3CredentialsProps {
+    namespace: string;
+    config: MonitoringConfig;
+}
+/**
+ * Creates ExternalSecret for Tempo S3 credentials.
+ *
+ * Replicates the S3 credentials (same store/key as Loki and Thanos) into the
+ * monitoring namespace for Tempo's object storage.
+ *
+ * Prerequisites:
+ * - External Secrets Operator installed
+ * - ClusterSecretStore named by config.integrations.s3SecretStore exists
+ * - Source secret addressed by config.integrations.s3CredentialsKey exists in that store
+ *
+ * Generated Secret:
+ * - Name: tempo-s3-credentials
+ * - Keys: AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY
+ *
+ * Sync Wave: 1 (external dependencies - must exist before Tempo starts)
+ */
+export declare class TempoS3CredentialsConstruct extends Construct {
+    readonly secretName = "tempo-s3-credentials";
+    constructor(scope: Construct, id: string, props: TempoS3CredentialsProps);
+}

package/lib/constructs/tempo-s3-credentials.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TempoS3CredentialsConstruct = void 0;
+const constructs_1 = require("constructs");
+const external_secrets_io_1 = require("../imports/external-secrets.io");
+/**
+ * Creates ExternalSecret for Tempo S3 credentials.
+ *
+ * Replicates the S3 credentials (same store/key as Loki and Thanos) into the
+ * monitoring namespace for Tempo's object storage.
+ *
+ * Prerequisites:
+ * - External Secrets Operator installed
+ * - ClusterSecretStore named by config.integrations.s3SecretStore exists
+ * - Source secret addressed by config.integrations.s3CredentialsKey exists in that store
+ *
+ * Generated Secret:
+ * - Name: tempo-s3-credentials
+ * - Keys: AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY
+ *
+ * Sync Wave: 1 (external dependencies - must exist before Tempo starts)
+ */
+class TempoS3CredentialsConstruct extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.secretName = 'tempo-s3-credentials';
+        const { namespace, config } = props;
+        // Create ExternalSecret that replicates S3 credentials
+        // Wave 1: External Dependencies - credentials must exist before Tempo
+        new external_secrets_io_1.ExternalSecret(this, 'tempo-s3-external-secret', {
+            metadata: {
+                name: 'tempo-s3-credentials-es',
+                namespace: namespace,
+                labels: {
+                    'app.kubernetes.io/name': 'tempo',
+                    'app.kubernetes.io/component': 's3-credentials',
+                    'app.kubernetes.io/managed-by': 'cdk8s',
+                    'app.kubernetes.io/part-of': 'monitoring',
+                },
+                annotations: {
+                    'argocd.argoproj.io/sync-wave': '1',
+                },
+            },
+            spec: {
+                refreshInterval: '1h0m0s',
+                secretStoreRef: {
+                    name: config.integrations.s3SecretStore,
+                    kind: external_secrets_io_1.ExternalSecretSpecSecretStoreRefKind.CLUSTER_SECRET_STORE,
+                },
+                target: {
+                    name: this.secretName,
+                    creationPolicy: external_secrets_io_1.ExternalSecretSpecTargetCreationPolicy.OWNER,
+                },
+                dataFrom: [
+                    {
+                        extract: {
+                            key: config.integrations.s3CredentialsKey,
+                        },
+                    },
+                ],
+            },
+        });
+    }
+}
+exports.TempoS3CredentialsConstruct = TempoS3CredentialsConstruct;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/constructs/tempo.d.ts

@@ -0,0 +1,20 @@
+import { Construct } from 'constructs';
+import { MonitoringConfig } from '../types';
+export interface TempoProps {
+    namespace: string;
+    config: MonitoringConfig;
+    s3CredentialsSecretName: string;
+}
+/**
+ * Creates the Grafana Tempo (monolithic) HelmChart for trace storage on S3.
+ *
+ * Single-binary Tempo backed by object storage, exposing an OTLP receiver that
+ * the Alloy traces gateway forwards to. Block retention is enforced by Tempo's
+ * compactor (config.tempo.retention).
+ *
+ * Sync Wave: 3 (advanced services, after core stack).
+ */
+export declare class TempoConstruct extends Construct {
+    constructor(scope: Construct, id: string, props: TempoProps);
+    private generateHelmValues;
+}

package/lib/constructs/tempo.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TempoConstruct = void 0;
+const cdk8s_1 = require("cdk8s");
+const constructs_1 = require("constructs");
+/**
+ * Creates the Grafana Tempo (monolithic) HelmChart for trace storage on S3.
+ *
+ * Single-binary Tempo backed by object storage, exposing an OTLP receiver that
+ * the Alloy traces gateway forwards to. Block retention is enforced by Tempo's
+ * compactor (config.tempo.retention).
+ *
+ * Sync Wave: 3 (advanced services, after core stack).
+ */
+class TempoConstruct extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const { namespace, config, s3CredentialsSecretName } = props;
+        new cdk8s_1.ApiObject(this, 'tempo', {
+            apiVersion: 'helm.cattle.io/v1',
+            kind: 'HelmChart',
+            metadata: {
+                name: 'tempo',
+                namespace: namespace,
+                labels: {
+                    'app.kubernetes.io/name': 'tempo',
+                    'app.kubernetes.io/component': 'tracing',
+                    'app.kubernetes.io/managed-by': 'cdk8s',
+                    'app.kubernetes.io/part-of': 'monitoring',
+                },
+                annotations: {
+                    'argocd.argoproj.io/sync-wave': '3',
+                },
+            },
+            spec: {
+                repo: 'https://grafana.github.io/helm-charts',
+                chart: 'tempo',
+                version: config.versions.tempo === 'latest' ? undefined : config.versions.tempo,
+                targetNamespace: namespace,
+                valuesContent: this.generateHelmValues(config, s3CredentialsSecretName),
+            },
+        });
+    }
+    generateHelmValues(config, s3CredentialsSecretName) {
+        // Values follow the monolithic grafana/tempo chart schema: storage,
+        // receivers, resources, extraEnv live under `tempo:`; replicas/persistence/
+        // tempoQuery are top-level. S3 credentials are NOT inlined into the config;
+        // Tempo's S3 client picks up AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY from the
+        // environment (set below from the ESO-synced secret) via the default chain.
+        return `replicas: ${config.replicas.tempo}
+tempo:
+  retention: ${config.tempo.retention}
+  storage:
+    trace:
+      backend: s3
+      s3:
+        bucket: ${config.tempo.bucket}
+        endpoint: ${config.s3.endpointNoProtocol}
+        region: ${config.s3.region}
+        forcepathstyle: false
+        insecure: false
+      wal:
+        path: /var/tempo/wal
+  receivers:
+    otlp:
+      protocols:
+        grpc:
+          endpoint: "0.0.0.0:4317"
+        http:
+          endpoint: "0.0.0.0:4318"
+  resources:
+    requests:
+      cpu: ${config.resources.tempo.requests.cpu}
+      memory: ${config.resources.tempo.requests.memory}
+    limits:
+      cpu: ${config.resources.tempo.limits.cpu}
+      memory: ${config.resources.tempo.limits.memory}
+  extraEnv:
+    - name: AWS_ACCESS_KEY_ID
+      valueFrom:
+        secretKeyRef:
+          name: ${s3CredentialsSecretName}
+          key: AWS_ACCESS_KEY_ID
+    - name: AWS_SECRET_ACCESS_KEY
+      valueFrom:
+        secretKeyRef:
+          name: ${s3CredentialsSecretName}
+          key: AWS_SECRET_ACCESS_KEY
+persistence:
+  enabled: true
+  storageClassName: longhorn
+  size: ${config.storage.tempo}
+tempoQuery:
+  enabled: false
+`;
+    }
+}
+exports.TempoConstruct = TempoConstruct;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/default-config.js

@@ -14,6 +14,7 @@ exports.DEFAULT_CONFIG = {
         loki: '7.0.0',
         alloy: '1.10.0',
         thanos: 'v0.41.0',
+        tempo: '1.24.4', // grafana/tempo chart (Tempo app 2.9.0)
     },
     retention: {
         prometheus: '2d',
@@ -30,6 +31,7 @@ exports.DEFAULT_CONFIG = {
         lokiWrite: '3Gi',
         thanosStore: '10Gi',
         thanosCompactor: '20Gi',
+        tempo: '5Gi',
     },
     replicas: {
         prometheus: 2,
@@ -40,6 +42,7 @@ exports.DEFAULT_CONFIG = {
         lokiWrite: 2,
         thanosQuery: 2,
         thanosStore: 2,
+        tempo: 1,
     },
     resources: {
         prometheus: { requests: { cpu: '100m', memory: '1500Mi' }, limits: { cpu: '2', memory: '3000Mi' } },
@@ -55,6 +58,14 @@ exports.DEFAULT_CONFIG = {
         thanosCompactor: { requests: { cpu: '500m', memory: '2Gi' }, limits: { cpu: '2000m', memory: '4Gi' } },
         configReloader: { requests: { cpu: '10m', memory: '50Mi' }, limits: { cpu: '50m', memory: '100Mi' } },
         thanosSidecar: { requests: { cpu: '10m', memory: '50Mi' }, limits: { cpu: '100m', memory: '100Mi' } },
+        tempo: { requests: { cpu: '100m', memory: '256Mi' }, limits: { cpu: '1', memory: '1Gi' } },
+        alloyTraces: { requests: { cpu: '100m', memory: '256Mi' }, limits: { cpu: '500m', memory: '512Mi' } },
+    },
+    tempo: {
+        enabled: false,
+        bucket: '',
+        retention: '336h',
+        tailSampling: { latencyThresholdMs: 1000, probabilisticPercent: 10 },
     },
 };
 /**
@@ -62,6 +73,10 @@ exports.DEFAULT_CONFIG = {
  * DEFAULT_CONFIG. Required cluster values are passed through verbatim.
  */
 function mergeConfig(input) {
+    const tempo = (0, deepmerge_ts_1.deepmerge)(exports.DEFAULT_CONFIG.tempo, input.tempo ?? {});
+    if (tempo.enabled && !tempo.bucket) {
+        throw new Error('tempo.bucket is required when tempo.enabled is true');
+    }
     return {
         namespace: input.namespace,
         domains: input.domains,
@@ -73,6 +88,7 @@ function mergeConfig(input) {
         storage: (0, deepmerge_ts_1.deepmerge)(exports.DEFAULT_CONFIG.storage, input.storage ?? {}),
         replicas: (0, deepmerge_ts_1.deepmerge)(exports.DEFAULT_CONFIG.replicas, input.replicas ?? {}),
         resources: (0, deepmerge_ts_1.deepmerge)(exports.DEFAULT_CONFIG.resources, input.resources ?? {}),
+        tempo,
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"default-config.js","sourceRoot":"","sources":["../src/default-config.ts"],"names":[],"mappings":"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","sourcesContent":["import { deepmerge } from 'deepmerge-ts';\nimport {\n  DefaultableConfig, MonitoringConfig, MonitoringConfigInput,\n  VersionConfig, RetentionConfig, StorageConfig, ReplicaConfig, ResourceConfig,\n} from './types';\n\n/**\n * Package-shipped defaults for everything that has a sensible universal value.\n * Values mirror the kup6s production config at the time of extraction; integration\n * charts override only what they need via {@link mergeConfig}.\n */\nexport const DEFAULT_CONFIG: DefaultableConfig = {\n  versions: {\n    prometheusStack: '87.0.0',\n    loki: '7.0.0',\n    alloy: '1.10.0',\n    thanos: 'v0.41.0',\n  },\n  retention: {\n    prometheus: '2d',\n    prometheusS3Raw: 30,\n    prometheusS35m: 180,\n    prometheusS31h: 730,\n    loki: '744h',\n  },\n  storage: {\n    prometheus: '15Gi',\n    grafana: '5Gi',\n    alertmanager: '1Gi',\n    lokiBackend: '10Gi',\n    lokiWrite: '3Gi',\n    thanosStore: '10Gi',\n    thanosCompactor: '20Gi',\n  },\n  replicas: {\n    prometheus: 2,\n    alertmanager: 2,\n    grafana: 1,\n    lokiBackend: 2,\n    lokiRead: 2,\n    lokiWrite: 2,\n    thanosQuery: 2,\n    thanosStore: 2,\n  },\n  resources: {\n    prometheus: { requests: { cpu: '100m', memory: '1500Mi' }, limits: { cpu: '2', memory: '3000Mi' } },\n    grafana: { requests: { cpu: '50m', memory: '512Mi' }, limits: { cpu: '200m', memory: '1Gi' } },\n    alertmanager: { requests: { cpu: '25m', memory: '100Mi' }, limits: { cpu: '100m', memory: '200Mi' } },\n    lokiBackend: { requests: { cpu: '100m', memory: '256Mi' }, limits: { cpu: '500m', memory: '512Mi' } },\n    lokiRead: { requests: { cpu: '100m', memory: '256Mi' }, limits: { cpu: '500m', memory: '512Mi' } },\n    lokiWrite: { requests: { cpu: '100m', memory: '512Mi' }, limits: { cpu: '1', memory: '1Gi' } },\n    lokiGateway: { requests: { cpu: '50m', memory: '128Mi' }, limits: { cpu: '200m', memory: '256Mi' } },\n    alloy: { requests: { cpu: '100m', memory: '128Mi' }, limits: { cpu: '200m', memory: '256Mi' } },\n    thanosQuery: { requests: { cpu: '200m', memory: '512Mi' }, limits: { cpu: '1000m', memory: '1Gi' } },\n    thanosStore: { requests: { cpu: '200m', memory: '1Gi' }, limits: { cpu: '1000m', memory: '2Gi' } },\n    thanosCompactor: { requests: { cpu: '500m', memory: '2Gi' }, limits: { cpu: '2000m', memory: '4Gi' } },\n    configReloader: { requests: { cpu: '10m', memory: '50Mi' }, limits: { cpu: '50m', memory: '100Mi' } },\n    thanosSidecar: { requests: { cpu: '10m', memory: '50Mi' }, limits: { cpu: '100m', memory: '100Mi' } },\n  },\n};\n\n/**\n * Resolve a full MonitoringConfig by deep-merging the caller's overrides over\n * DEFAULT_CONFIG. Required cluster values are passed through verbatim.\n */\nexport function mergeConfig(input: MonitoringConfigInput): MonitoringConfig {\n  return {\n    namespace: input.namespace,\n    domains: input.domains,\n    s3: input.s3,\n    smtp: input.smtp,\n    integrations: input.integrations,\n    versions: deepmerge(DEFAULT_CONFIG.versions, input.versions ?? {}) as VersionConfig,\n    retention: deepmerge(DEFAULT_CONFIG.retention, input.retention ?? {}) as RetentionConfig,\n    storage: deepmerge(DEFAULT_CONFIG.storage, input.storage ?? {}) as StorageConfig,\n    replicas: deepmerge(DEFAULT_CONFIG.replicas, input.replicas ?? {}) as ReplicaConfig,\n    resources: deepmerge(DEFAULT_CONFIG.resources, input.resources ?? {}) as ResourceConfig,\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"default-config.js","sourceRoot":"","sources":["../src/default-config.ts"],"names":[],"mappings":"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","sourcesContent":["import { deepmerge } from 'deepmerge-ts';\nimport {\n  DefaultableConfig, MonitoringConfig, MonitoringConfigInput,\n  VersionConfig, RetentionConfig, StorageConfig, ReplicaConfig, ResourceConfig, TempoConfig,\n} from './types';\n\n/**\n * Package-shipped defaults for everything that has a sensible universal value.\n * Values mirror the kup6s production config at the time of extraction; integration\n * charts override only what they need via {@link mergeConfig}.\n */\nexport const DEFAULT_CONFIG: DefaultableConfig = {\n  versions: {\n    prometheusStack: '87.0.0',\n    loki: '7.0.0',\n    alloy: '1.10.0',\n    thanos: 'v0.41.0',\n    tempo: '1.24.4', // grafana/tempo chart (Tempo app 2.9.0)\n  },\n  retention: {\n    prometheus: '2d',\n    prometheusS3Raw: 30,\n    prometheusS35m: 180,\n    prometheusS31h: 730,\n    loki: '744h',\n  },\n  storage: {\n    prometheus: '15Gi',\n    grafana: '5Gi',\n    alertmanager: '1Gi',\n    lokiBackend: '10Gi',\n    lokiWrite: '3Gi',\n    thanosStore: '10Gi',\n    thanosCompactor: '20Gi',\n    tempo: '5Gi',\n  },\n  replicas: {\n    prometheus: 2,\n    alertmanager: 2,\n    grafana: 1,\n    lokiBackend: 2,\n    lokiRead: 2,\n    lokiWrite: 2,\n    thanosQuery: 2,\n    thanosStore: 2,\n    tempo: 1,\n  },\n  resources: {\n    prometheus: { requests: { cpu: '100m', memory: '1500Mi' }, limits: { cpu: '2', memory: '3000Mi' } },\n    grafana: { requests: { cpu: '50m', memory: '512Mi' }, limits: { cpu: '200m', memory: '1Gi' } },\n    alertmanager: { requests: { cpu: '25m', memory: '100Mi' }, limits: { cpu: '100m', memory: '200Mi' } },\n    lokiBackend: { requests: { cpu: '100m', memory: '256Mi' }, limits: { cpu: '500m', memory: '512Mi' } },\n    lokiRead: { requests: { cpu: '100m', memory: '256Mi' }, limits: { cpu: '500m', memory: '512Mi' } },\n    lokiWrite: { requests: { cpu: '100m', memory: '512Mi' }, limits: { cpu: '1', memory: '1Gi' } },\n    lokiGateway: { requests: { cpu: '50m', memory: '128Mi' }, limits: { cpu: '200m', memory: '256Mi' } },\n    alloy: { requests: { cpu: '100m', memory: '128Mi' }, limits: { cpu: '200m', memory: '256Mi' } },\n    thanosQuery: { requests: { cpu: '200m', memory: '512Mi' }, limits: { cpu: '1000m', memory: '1Gi' } },\n    thanosStore: { requests: { cpu: '200m', memory: '1Gi' }, limits: { cpu: '1000m', memory: '2Gi' } },\n    thanosCompactor: { requests: { cpu: '500m', memory: '2Gi' }, limits: { cpu: '2000m', memory: '4Gi' } },\n    configReloader: { requests: { cpu: '10m', memory: '50Mi' }, limits: { cpu: '50m', memory: '100Mi' } },\n    thanosSidecar: { requests: { cpu: '10m', memory: '50Mi' }, limits: { cpu: '100m', memory: '100Mi' } },\n    tempo: { requests: { cpu: '100m', memory: '256Mi' }, limits: { cpu: '1', memory: '1Gi' } },\n    alloyTraces: { requests: { cpu: '100m', memory: '256Mi' }, limits: { cpu: '500m', memory: '512Mi' } },\n  },\n  tempo: {\n    enabled: false,\n    bucket: '',\n    retention: '336h',\n    tailSampling: { latencyThresholdMs: 1000, probabilisticPercent: 10 },\n  },\n};\n\n/**\n * Resolve a full MonitoringConfig by deep-merging the caller's overrides over\n * DEFAULT_CONFIG. Required cluster values are passed through verbatim.\n */\nexport function mergeConfig(input: MonitoringConfigInput): MonitoringConfig {\n  const tempo = deepmerge(DEFAULT_CONFIG.tempo, input.tempo ?? {}) as TempoConfig;\n  if (tempo.enabled && !tempo.bucket) {\n    throw new Error('tempo.bucket is required when tempo.enabled is true');\n  }\n  return {\n    namespace: input.namespace,\n    domains: input.domains,\n    s3: input.s3,\n    smtp: input.smtp,\n    integrations: input.integrations,\n    versions: deepmerge(DEFAULT_CONFIG.versions, input.versions ?? {}) as VersionConfig,\n    retention: deepmerge(DEFAULT_CONFIG.retention, input.retention ?? {}) as RetentionConfig,\n    storage: deepmerge(DEFAULT_CONFIG.storage, input.storage ?? {}) as StorageConfig,\n    replicas: deepmerge(DEFAULT_CONFIG.replicas, input.replicas ?? {}) as ReplicaConfig,\n    resources: deepmerge(DEFAULT_CONFIG.resources, input.resources ?? {}) as ResourceConfig,\n    tempo,\n  };\n}\n"]}

package/lib/index.d.ts

@@ -15,3 +15,7 @@ export * from './constructs/alloy';
 export * from './constructs/thanos-query';
 export * from './constructs/thanos-store';
 export * from './constructs/thanos-compactor';
+export * from './constructs/tempo-s3-bucket';
+export * from './constructs/tempo-s3-credentials';
+export * from './constructs/tempo';
+export * from './constructs/alloy-traces';

package/lib/index.js

@@ -35,4 +35,8 @@ __exportStar(require("./constructs/alloy"), exports);
 __exportStar(require("./constructs/thanos-query"), exports);
 __exportStar(require("./constructs/thanos-store"), exports);
 __exportStar(require("./constructs/thanos-compactor"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSwwQ0FBd0I7QUFDeEIsbURBQWlDO0FBQ2pDLHFEQUFtQztBQUNuQyw2RUFBNkU7QUFDN0UsbUZBQW1GO0FBQ25GLHFDQUE4QztBQUFyQyxvR0FBQSxhQUFhLE9BQUE7QUFDdEIseURBQXVDO0FBQ3ZDLDhEQUE0QztBQUM1QyxnRUFBOEM7QUFDOUMsOERBQTRDO0FBQzVDLHFFQUFtRDtBQUNuRCxtRUFBaUQ7QUFDakQsdUVBQXFEO0FBQ3JELGdFQUE4QztBQUM5QyxvREFBa0M7QUFDbEMscURBQW1DO0FBQ25DLDREQUEwQztBQUMxQyw0REFBMEM7QUFDMUMsZ0VBQThDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90eXBlcyc7XG5leHBvcnQgKiBmcm9tICcuL2RlZmF1bHQtY29uZmlnJztcbmV4cG9ydCAqIGZyb20gJy4vbW9uaXRvcmluZy1jaGFydCc7XG4vLyBDb252ZW5pZW5jZSByZS1leHBvcnQgc28gaW50ZWdyYXRpb24gY2hhcnRzIGNhbiBidWlsZCBkYXNoYm9hcmQgQ29uZmlnTWFwc1xuLy8gKEdyYWZhbmEgc2lkZWNhciBkaXNjb3ZlcnkpIHdpdGhvdXQgZGVwZW5kaW5nIG9uIHRoZSBnZW5lcmF0ZWQgaW1wb3J0cyBkaXJlY3RseS5cbmV4cG9ydCB7IEt1YmVDb25maWdNYXAgfSBmcm9tICcuL2ltcG9ydHMvazhzJztcbmV4cG9ydCAqIGZyb20gJy4vY29uc3RydWN0cy9uYW1lc3BhY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9jb25zdHJ1Y3RzL3ByaW9yaXR5LWNsYXNzJztcbmV4cG9ydCAqIGZyb20gJy4vY29uc3RydWN0cy90aGFub3MtczMtYnVja2V0JztcbmV4cG9ydCAqIGZyb20gJy4vY29uc3RydWN0cy9sb2tpLXMzLWJ1Y2tldCc7XG5leHBvcnQgKiBmcm9tICcuL2NvbnN0cnVjdHMvdGhhbm9zLXMzLWNyZWRlbnRpYWxzJztcbmV4cG9ydCAqIGZyb20gJy4vY29uc3RydWN0cy9sb2tpLXMzLWNyZWRlbnRpYWxzJztcbmV4cG9ydCAqIGZyb20gJy4vY29uc3RydWN0cy9ncmFmYW5hLXBhc3N3b3JkLXNlY3JldCc7XG5leHBvcnQgKiBmcm9tICcuL2NvbnN0cnVjdHMvcHJvbWV0aGV1cy1zdGFjayc7XG5leHBvcnQgKiBmcm9tICcuL2NvbnN0cnVjdHMvbG9raSc7XG5leHBvcnQgKiBmcm9tICcuL2NvbnN0cnVjdHMvYWxsb3knO1xuZXhwb3J0ICogZnJvbSAnLi9jb25zdHJ1Y3RzL3RoYW5vcy1xdWVyeSc7XG5leHBvcnQgKiBmcm9tICcuL2NvbnN0cnVjdHMvdGhhbm9zLXN0b3JlJztcbmV4cG9ydCAqIGZyb20gJy4vY29uc3RydWN0cy90aGFub3MtY29tcGFjdG9yJztcbiJdfQ==
+__exportStar(require("./constructs/tempo-s3-bucket"), exports);
+__exportStar(require("./constructs/tempo-s3-credentials"), exports);
+__exportStar(require("./constructs/tempo"), exports);
+__exportStar(require("./constructs/alloy-traces"), exports);
+//# sourceMappingURL=data:application/json;base64,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

package/lib/monitoring-chart.js

@@ -4,6 +4,7 @@ exports.MonitoringChart = void 0;
 const cdk8s_1 = require("cdk8s");
 // Import all constructs
 const alloy_1 = require("./constructs/alloy");
+const alloy_traces_1 = require("./constructs/alloy-traces");
 const grafana_password_secret_1 = require("./constructs/grafana-password-secret");
 const loki_1 = require("./constructs/loki");
 const loki_s3_bucket_1 = require("./constructs/loki-s3-bucket");
@@ -11,6 +12,9 @@ const loki_s3_credentials_1 = require("./constructs/loki-s3-credentials");
 const namespace_1 = require("./constructs/namespace");
 const priority_class_1 = require("./constructs/priority-class");
 const prometheus_stack_1 = require("./constructs/prometheus-stack");
+const tempo_1 = require("./constructs/tempo");
+const tempo_s3_bucket_1 = require("./constructs/tempo-s3-bucket");
+const tempo_s3_credentials_1 = require("./constructs/tempo-s3-credentials");
 const thanos_compactor_1 = require("./constructs/thanos-compactor");
 const thanos_query_1 = require("./constructs/thanos-query");
 const thanos_s3_bucket_1 = require("./constructs/thanos-s3-bucket");
@@ -122,7 +126,25 @@ class MonitoringChart extends cdk8s_1.Chart {
             namespace,
             config,
         });
+        // =========================================================================
+        // Tempo tracing (opt-in)
+        // =========================================================================
+        // Only created when config.tempo.enabled is true. Apps send OTLP to the
+        // alloy-traces gateway, which tail-samples and forwards to Tempo (S3-backed).
+        if (config.tempo.enabled) {
+            new tempo_s3_bucket_1.TempoS3BucketConstruct(this, 'tempo-s3-bucket', { config });
+            const tempoCreds = new tempo_s3_credentials_1.TempoS3CredentialsConstruct(this, 'tempo-s3-credentials', {
+                namespace,
+                config,
+            });
+            new tempo_1.TempoConstruct(this, 'tempo', {
+                namespace,
+                config,
+                s3CredentialsSecretName: tempoCreds.secretName,
+            });
+            new alloy_traces_1.AlloyTracesConstruct(this, 'alloy-traces', { namespace, config });
+        }
     }
 }
 exports.MonitoringChart = MonitoringChart;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"monitoring-chart.js","sourceRoot":"","sources":["../src/monitoring-chart.ts"],"names":[],"mappings":";;;AAAA,iCAA0C;AAG1C,wBAAwB;AACxB,8CAAoD;AACpD,kFAA6E;AAC7E,4CAAkD;AAClD,gEAAoE;AACpE,0EAA8E;AAC9E,sDAA4D;AAC5D,gEAAqE;AACrE,oEAAyE;AACzE,oEAAyE;AACzE,4DAAiE;AACjE,oEAAwE;AACxE,8EAAkF;AAClF,4DAAiE;AAGjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAa,eAAgB,SAAQ,aAAK;IACxC,YAAY,KAAgB,EAAE,EAAU,EAAW,MAAwB,EAAE,QAAoB,EAAE;QACjG,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;QADyB,WAAM,GAAN,MAAM,CAAkB;QAGzE,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;QAEnC,4EAA4E;QAC5E,qBAAqB;QACrB,4EAA4E;QAC5E,wCAAwC;QACxC,IAAI,8BAAkB,CAAC,IAAI,EAAE,WAAW,EAAE;YACxC,IAAI,EAAE,SAAS;SAChB,CAAC,CAAC;QAEH,IAAI,uCAAsB,CAAC,IAAI,EAAE,gBAAgB,CAAC,CAAC;QAEnD,4EAA4E;QAC5E,gCAAgC;QAChC,4EAA4E;QAC5E,4DAA4D;QAC5D,IAAI,0CAAuB,CAAC,IAAI,EAAE,kBAAkB,EAAE;YACpD,MAAM;SACP,CAAC,CAAC;QAEH,IAAI,sCAAqB,CAAC,IAAI,EAAE,gBAAgB,EAAE;YAChD,MAAM;SACP,CAAC,CAAC;QAEH,4CAA4C;QAC5C,IAAI,oDAA4B,CAAC,IAAI,EAAE,uBAAuB,EAAE;YAC9D,SAAS;YACT,MAAM;SACP,CAAC,CAAC;QAEH,MAAM,iBAAiB,GAAG,IAAI,gDAA0B,CAAC,IAAI,EAAE,qBAAqB,EAAE;YACpF,SAAS;YACT,MAAM;SACP,CAAC,CAAC;QAEH,mEAAmE;QACnE,IAAI,+CAAqB,CAAC,IAAI,EAAE,kBAAkB,EAAE;YAClD,SAAS;YACT,MAAM;SACP,CAAC,CAAC;QAEH,4EAA4E;QAC5E,wBAAwB;QACxB,4EAA4E;QAC5E,2EAA2E;QAC3E,IAAI,2CAAwB,CAAC,IAAI,EAAE,kBAAkB,EAAE;YACrD,SAAS;YACT,MAAM;SACP,CAAC,CAAC;QAEH,yBAAyB;QACzB,IAAI,oBAAa,CAAC,IAAI,EAAE,MAAM,EAAE;YAC9B,SAAS;YACT,MAAM;YACN,uBAAuB,EAAE,iBAAiB,CAAC,UAAU;SACtD,CAAC,CAAC;QAEH,4EAA4E;QAC5E,4BAA4B;QAC5B,4EAA4E;QAC5E,+CAA+C;QAC/C,IAAI,sBAAc,CAAC,IAAI,EAAE,OAAO,EAAE;YAChC,SAAS;YACT,MAAM;SACP,CAAC,CAAC;QAEH,qEAAqE;QACrE,IAAI,mCAAoB,CAAC,IAAI,EAAE,cAAc,EAAE;YAC7C,SAAS;YACT,MAAM;SACP,CAAC,CAAC;QAEH,8DAA8D;QAC9D,IAAI,mCAAoB,CAAC,IAAI,EAAE,cAAc,EAAE;YAC7C,SAAS;YACT,MAAM;SACP,CAAC,CAAC;QAEH,oEAAoE;QACpE,IAAI,2CAAwB,CAAC,IAAI,EAAE,kBAAkB,EAAE;YACrD,SAAS;YACT,MAAM;SACP,CAAC,CAAC;IACL,CAAC;CACF;AAxFD,0CAwFC","sourcesContent":["import { Chart, ChartProps } from 'cdk8s';\nimport { Construct } from 'constructs';\n\n// Import all constructs\nimport { AlloyConstruct } from './constructs/alloy';\nimport { GrafanaPasswordSecret } from './constructs/grafana-password-secret';\nimport { LokiConstruct } from './constructs/loki';\nimport { LokiS3BucketConstruct } from './constructs/loki-s3-bucket';\nimport { LokiS3CredentialsConstruct } from './constructs/loki-s3-credentials';\nimport { NamespaceConstruct } from './constructs/namespace';\nimport { PriorityClassConstruct } from './constructs/priority-class';\nimport { PrometheusStackConstruct } from './constructs/prometheus-stack';\nimport { ThanosCompactorConstruct } from './constructs/thanos-compactor';\nimport { ThanosQueryConstruct } from './constructs/thanos-query';\nimport { ThanosS3BucketConstruct } from './constructs/thanos-s3-bucket';\nimport { ThanosS3CredentialsConstruct } from './constructs/thanos-s3-credentials';\nimport { ThanosStoreConstruct } from './constructs/thanos-store';\nimport { MonitoringConfig } from './types';\n\n/**\n * MonitoringChart orchestrates the complete monitoring stack.\n *\n * This chart creates all resources in the correct order using ArgoCD sync-waves:\n *\n * Wave 0: Foundation\n * - Namespace\n * - PriorityClass\n *\n * Wave 1: External Dependencies\n * - S3 Buckets (Crossplane)\n * - S3 Credentials (ExternalSecret)\n *\n * Wave 2: Core Services\n * - Prometheus Stack (Prometheus, Grafana, Alertmanager)\n * - Loki (log aggregation)\n *\n * Wave 3: Advanced Services\n * - Alloy (log collection)\n * - Thanos Query (unified metrics query)\n * - Thanos Store (S3 gateway)\n * - Thanos Compactor (downsampling)\n *\n * App-specific dashboards and alert rules are intentionally NOT part of this\n * chart. Integration charts attach their own dashboard/alert constructs beside\n * this one (the Grafana sidecar discovers ConfigMaps labeled\n * `grafana_dashboard: \"1\"` in the same namespace).\n *\n * Configuration is provided via the MonitoringConfig interface, which combines:\n * - config.yaml (default values)\n * - Environment variables (overrides)\n */\nexport class MonitoringChart extends Chart {\n  constructor(scope: Construct, id: string, readonly config: MonitoringConfig, props: ChartProps = {}) {\n    super(scope, id, props);\n\n    const namespace = config.namespace;\n\n    // =========================================================================\n    // Wave 0: Foundation\n    // =========================================================================\n    // Must exist before any other resources\n    new NamespaceConstruct(this, 'namespace', {\n      name: namespace,\n    });\n\n    new PriorityClassConstruct(this, 'priority-class');\n\n    // =========================================================================\n    // Wave 1: External Dependencies\n    // =========================================================================\n    // S3 buckets must be created before pods try to access them\n    new ThanosS3BucketConstruct(this, 'thanos-s3-bucket', {\n      config,\n    });\n\n    new LokiS3BucketConstruct(this, 'loki-s3-bucket', {\n      config,\n    });\n\n    // Secrets must exist before pods mount them\n    new ThanosS3CredentialsConstruct(this, 'thanos-s3-credentials', {\n      namespace,\n      config,\n    });\n\n    const lokiS3Credentials = new LokiS3CredentialsConstruct(this, 'loki-s3-credentials', {\n      namespace,\n      config,\n    });\n\n    // Grafana admin credentials (stable password across Helm upgrades)\n    new GrafanaPasswordSecret(this, 'grafana-password', {\n      namespace,\n      config,\n    });\n\n    // =========================================================================\n    // Wave 2: Core Services\n    // =========================================================================\n    // Prometheus Stack (includes Prometheus, Grafana, Alertmanager, operators)\n    new PrometheusStackConstruct(this, 'prometheus-stack', {\n      namespace,\n      config,\n    });\n\n    // Loki (log aggregation)\n    new LokiConstruct(this, 'loki', {\n      namespace,\n      config,\n      s3CredentialsSecretName: lokiS3Credentials.secretName,\n    });\n\n    // =========================================================================\n    // Wave 3: Advanced Services\n    // =========================================================================\n    // Alloy (log collection - after Loki is ready)\n    new AlloyConstruct(this, 'alloy', {\n      namespace,\n      config,\n    });\n\n    // Thanos Query (unified query interface - after Prometheus is ready)\n    new ThanosQueryConstruct(this, 'thanos-query', {\n      namespace,\n      config,\n    });\n\n    // Thanos Store (S3 gateway - after S3 bucket and credentials)\n    new ThanosStoreConstruct(this, 'thanos-store', {\n      namespace,\n      config,\n    });\n\n    // Thanos Compactor (downsampling - after S3 bucket and credentials)\n    new ThanosCompactorConstruct(this, 'thanos-compactor', {\n      namespace,\n      config,\n    });\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"monitoring-chart.js","sourceRoot":"","sources":["../src/monitoring-chart.ts"],"names":[],"mappings":";;;AAAA,iCAA0C;AAG1C,wBAAwB;AACxB,8CAAoD;AACpD,4DAAiE;AACjE,kFAA6E;AAC7E,4CAAkD;AAClD,gEAAoE;AACpE,0EAA8E;AAC9E,sDAA4D;AAC5D,gEAAqE;AACrE,oEAAyE;AACzE,8CAAoD;AACpD,kEAAsE;AACtE,4EAAgF;AAChF,oEAAyE;AACzE,4DAAiE;AACjE,oEAAwE;AACxE,8EAAkF;AAClF,4DAAiE;AAGjE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAa,eAAgB,SAAQ,aAAK;IACxC,YAAY,KAAgB,EAAE,EAAU,EAAW,MAAwB,EAAE,QAAoB,EAAE;QACjG,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;QADyB,WAAM,GAAN,MAAM,CAAkB;QAGzE,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;QAEnC,4EAA4E;QAC5E,qBAAqB;QACrB,4EAA4E;QAC5E,wCAAwC;QACxC,IAAI,8BAAkB,CAAC,IAAI,EAAE,WAAW,EAAE;YACxC,IAAI,EAAE,SAAS;SAChB,CAAC,CAAC;QAEH,IAAI,uCAAsB,CAAC,IAAI,EAAE,gBAAgB,CAAC,CAAC;QAEnD,4EAA4E;QAC5E,gCAAgC;QAChC,4EAA4E;QAC5E,4DAA4D;QAC5D,IAAI,0CAAuB,CAAC,IAAI,EAAE,kBAAkB,EAAE;YACpD,MAAM;SACP,CAAC,CAAC;QAEH,IAAI,sCAAqB,CAAC,IAAI,EAAE,gBAAgB,EAAE;YAChD,MAAM;SACP,CAAC,CAAC;QAEH,4CAA4C;QAC5C,IAAI,oDAA4B,CAAC,IAAI,EAAE,uBAAuB,EAAE;YAC9D,SAAS;YACT,MAAM;SACP,CAAC,CAAC;QAEH,MAAM,iBAAiB,GAAG,IAAI,gDAA0B,CAAC,IAAI,EAAE,qBAAqB,EAAE;YACpF,SAAS;YACT,MAAM;SACP,CAAC,CAAC;QAEH,mEAAmE;QACnE,IAAI,+CAAqB,CAAC,IAAI,EAAE,kBAAkB,EAAE;YAClD,SAAS;YACT,MAAM;SACP,CAAC,CAAC;QAEH,4EAA4E;QAC5E,wBAAwB;QACxB,4EAA4E;QAC5E,2EAA2E;QAC3E,IAAI,2CAAwB,CAAC,IAAI,EAAE,kBAAkB,EAAE;YACrD,SAAS;YACT,MAAM;SACP,CAAC,CAAC;QAEH,yBAAyB;QACzB,IAAI,oBAAa,CAAC,IAAI,EAAE,MAAM,EAAE;YAC9B,SAAS;YACT,MAAM;YACN,uBAAuB,EAAE,iBAAiB,CAAC,UAAU;SACtD,CAAC,CAAC;QAEH,4EAA4E;QAC5E,4BAA4B;QAC5B,4EAA4E;QAC5E,+CAA+C;QAC/C,IAAI,sBAAc,CAAC,IAAI,EAAE,OAAO,EAAE;YAChC,SAAS;YACT,MAAM;SACP,CAAC,CAAC;QAEH,qEAAqE;QACrE,IAAI,mCAAoB,CAAC,IAAI,EAAE,cAAc,EAAE;YAC7C,SAAS;YACT,MAAM;SACP,CAAC,CAAC;QAEH,8DAA8D;QAC9D,IAAI,mCAAoB,CAAC,IAAI,EAAE,cAAc,EAAE;YAC7C,SAAS;YACT,MAAM;SACP,CAAC,CAAC;QAEH,oEAAoE;QACpE,IAAI,2CAAwB,CAAC,IAAI,EAAE,kBAAkB,EAAE;YACrD,SAAS;YACT,MAAM;SACP,CAAC,CAAC;QAEH,4EAA4E;QAC5E,yBAAyB;QACzB,4EAA4E;QAC5E,wEAAwE;QACxE,8EAA8E;QAC9E,IAAI,MAAM,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;YACzB,IAAI,wCAAsB,CAAC,IAAI,EAAE,iBAAiB,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;YAChE,MAAM,UAAU,GAAG,IAAI,kDAA2B,CAAC,IAAI,EAAE,sBAAsB,EAAE;gBAC/E,SAAS;gBACT,MAAM;aACP,CAAC,CAAC;YACH,IAAI,sBAAc,CAAC,IAAI,EAAE,OAAO,EAAE;gBAChC,SAAS;gBACT,MAAM;gBACN,uBAAuB,EAAE,UAAU,CAAC,UAAU;aAC/C,CAAC,CAAC;YACH,IAAI,mCAAoB,CAAC,IAAI,EAAE,cAAc,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,CAAC,CAAC;QACxE,CAAC;IACH,CAAC;CACF;AA3GD,0CA2GC","sourcesContent":["import { Chart, ChartProps } from 'cdk8s';\nimport { Construct } from 'constructs';\n\n// Import all constructs\nimport { AlloyConstruct } from './constructs/alloy';\nimport { AlloyTracesConstruct } from './constructs/alloy-traces';\nimport { GrafanaPasswordSecret } from './constructs/grafana-password-secret';\nimport { LokiConstruct } from './constructs/loki';\nimport { LokiS3BucketConstruct } from './constructs/loki-s3-bucket';\nimport { LokiS3CredentialsConstruct } from './constructs/loki-s3-credentials';\nimport { NamespaceConstruct } from './constructs/namespace';\nimport { PriorityClassConstruct } from './constructs/priority-class';\nimport { PrometheusStackConstruct } from './constructs/prometheus-stack';\nimport { TempoConstruct } from './constructs/tempo';\nimport { TempoS3BucketConstruct } from './constructs/tempo-s3-bucket';\nimport { TempoS3CredentialsConstruct } from './constructs/tempo-s3-credentials';\nimport { ThanosCompactorConstruct } from './constructs/thanos-compactor';\nimport { ThanosQueryConstruct } from './constructs/thanos-query';\nimport { ThanosS3BucketConstruct } from './constructs/thanos-s3-bucket';\nimport { ThanosS3CredentialsConstruct } from './constructs/thanos-s3-credentials';\nimport { ThanosStoreConstruct } from './constructs/thanos-store';\nimport { MonitoringConfig } from './types';\n\n/**\n * MonitoringChart orchestrates the complete monitoring stack.\n *\n * This chart creates all resources in the correct order using ArgoCD sync-waves:\n *\n * Wave 0: Foundation\n * - Namespace\n * - PriorityClass\n *\n * Wave 1: External Dependencies\n * - S3 Buckets (Crossplane)\n * - S3 Credentials (ExternalSecret)\n *\n * Wave 2: Core Services\n * - Prometheus Stack (Prometheus, Grafana, Alertmanager)\n * - Loki (log aggregation)\n *\n * Wave 3: Advanced Services\n * - Alloy (log collection)\n * - Thanos Query (unified metrics query)\n * - Thanos Store (S3 gateway)\n * - Thanos Compactor (downsampling)\n *\n * App-specific dashboards and alert rules are intentionally NOT part of this\n * chart. Integration charts attach their own dashboard/alert constructs beside\n * this one (the Grafana sidecar discovers ConfigMaps labeled\n * `grafana_dashboard: \"1\"` in the same namespace).\n *\n * Configuration is provided via the MonitoringConfig interface, which combines:\n * - config.yaml (default values)\n * - Environment variables (overrides)\n */\nexport class MonitoringChart extends Chart {\n  constructor(scope: Construct, id: string, readonly config: MonitoringConfig, props: ChartProps = {}) {\n    super(scope, id, props);\n\n    const namespace = config.namespace;\n\n    // =========================================================================\n    // Wave 0: Foundation\n    // =========================================================================\n    // Must exist before any other resources\n    new NamespaceConstruct(this, 'namespace', {\n      name: namespace,\n    });\n\n    new PriorityClassConstruct(this, 'priority-class');\n\n    // =========================================================================\n    // Wave 1: External Dependencies\n    // =========================================================================\n    // S3 buckets must be created before pods try to access them\n    new ThanosS3BucketConstruct(this, 'thanos-s3-bucket', {\n      config,\n    });\n\n    new LokiS3BucketConstruct(this, 'loki-s3-bucket', {\n      config,\n    });\n\n    // Secrets must exist before pods mount them\n    new ThanosS3CredentialsConstruct(this, 'thanos-s3-credentials', {\n      namespace,\n      config,\n    });\n\n    const lokiS3Credentials = new LokiS3CredentialsConstruct(this, 'loki-s3-credentials', {\n      namespace,\n      config,\n    });\n\n    // Grafana admin credentials (stable password across Helm upgrades)\n    new GrafanaPasswordSecret(this, 'grafana-password', {\n      namespace,\n      config,\n    });\n\n    // =========================================================================\n    // Wave 2: Core Services\n    // =========================================================================\n    // Prometheus Stack (includes Prometheus, Grafana, Alertmanager, operators)\n    new PrometheusStackConstruct(this, 'prometheus-stack', {\n      namespace,\n      config,\n    });\n\n    // Loki (log aggregation)\n    new LokiConstruct(this, 'loki', {\n      namespace,\n      config,\n      s3CredentialsSecretName: lokiS3Credentials.secretName,\n    });\n\n    // =========================================================================\n    // Wave 3: Advanced Services\n    // =========================================================================\n    // Alloy (log collection - after Loki is ready)\n    new AlloyConstruct(this, 'alloy', {\n      namespace,\n      config,\n    });\n\n    // Thanos Query (unified query interface - after Prometheus is ready)\n    new ThanosQueryConstruct(this, 'thanos-query', {\n      namespace,\n      config,\n    });\n\n    // Thanos Store (S3 gateway - after S3 bucket and credentials)\n    new ThanosStoreConstruct(this, 'thanos-store', {\n      namespace,\n      config,\n    });\n\n    // Thanos Compactor (downsampling - after S3 bucket and credentials)\n    new ThanosCompactorConstruct(this, 'thanos-compactor', {\n      namespace,\n      config,\n    });\n\n    // =========================================================================\n    // Tempo tracing (opt-in)\n    // =========================================================================\n    // Only created when config.tempo.enabled is true. Apps send OTLP to the\n    // alloy-traces gateway, which tail-samples and forwards to Tempo (S3-backed).\n    if (config.tempo.enabled) {\n      new TempoS3BucketConstruct(this, 'tempo-s3-bucket', { config });\n      const tempoCreds = new TempoS3CredentialsConstruct(this, 'tempo-s3-credentials', {\n        namespace,\n        config,\n      });\n      new TempoConstruct(this, 'tempo', {\n        namespace,\n        config,\n        s3CredentialsSecretName: tempoCreds.secretName,\n      });\n      new AlloyTracesConstruct(this, 'alloy-traces', { namespace, config });\n    }\n  }\n}\n"]}

package/lib/types.d.ts

@@ -74,6 +74,7 @@ export interface StorageConfig {
     lokiWrite: string;
     thanosStore: string;
     thanosCompactor: string;
+    tempo: string;
 }
 /**
  * Replica counts for high availability
@@ -87,6 +88,7 @@ export interface ReplicaConfig {
     lokiWrite: number;
     thanosQuery: number;
     thanosStore: number;
+    tempo: number;
 }
 /**
  * Resource requirements for all components
@@ -105,6 +107,8 @@ export interface ResourceConfig {
     thanosCompactor: ResourceRequirements;
     configReloader: ResourceRequirements;
     thanosSidecar: ResourceRequirements;
+    tempo: ResourceRequirements;
+    alloyTraces: ResourceRequirements;
 }
 /**
  * Helm chart version configuration
@@ -114,6 +118,23 @@ export interface VersionConfig {
     loki: string;
     alloy: string;
     thanos: string;
+    tempo: string;
+}
+/**
+ * Tail-sampling policy for the Alloy traces gateway.
+ */
+export interface TempoTailSamplingConfig {
+    latencyThresholdMs: number;
+    probabilisticPercent: number;
+}
+/**
+ * Grafana Tempo tracing configuration (opt-in).
+ */
+export interface TempoConfig {
+    enabled: boolean;
+    bucket: string;
+    retention: string;
+    tailSampling: TempoTailSamplingConfig;
 }
 /**
  * Configuration the package ships sensible defaults for.
@@ -125,6 +146,7 @@ export interface DefaultableConfig {
     storage: StorageConfig;
     replicas: ReplicaConfig;
     resources: ResourceConfig;
+    tempo: TempoConfig;
 }
 /**
  * Cluster-specific configuration with no sensible universal default.

package/lib/types.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Resource allocation for a component (CPU and memory)\n */\nexport interface ResourceAllocation {\n  cpu: string;\n  memory: string;\n}\n\n/**\n * Resource requests and limits for a component\n */\nexport interface ResourceRequirements {\n  requests: ResourceAllocation;\n  limits: ResourceAllocation;\n}\n\n/**\n * S3 configuration for object storage\n */\nexport interface S3Config {\n  endpoint: string; // Full endpoint with protocol (e.g., https://fsn1.your-objectstorage.com)\n  endpointNoProtocol: string; // Endpoint without protocol (for Thanos)\n  region: string; // S3 region (e.g., fsn1)\n  buckets: {\n    thanos: string; // Thanos metrics bucket\n    loki: string; // Loki logs bucket\n  };\n}\n\n/**\n * SMTP configuration for alerting\n */\nexport interface SmtpConfig {\n  host: string; // SMTP server hostname\n  port: number; // SMTP server port\n  from: string; // From email address\n  username?: string; // SMTP username (optional)\n  password?: string; // SMTP password (optional)\n  requireTls: boolean; // Require TLS for SMTP\n}\n\n/**\n * Domain configuration for ingresses\n */\nexport interface DomainConfig {\n  grafana: string; // Grafana domain (e.g., grafana.ops.kup6s.net)\n}\n\n/**\n * Names of the external Crossplane and External Secrets Operator resources this\n * stack references. These are not created by the library; they must already exist\n * in your cluster. There are no defaults — every consumer wires its own names.\n */\nexport interface IntegrationsConfig {\n  s3ProviderConfig: string; // Crossplane ProviderConfig name the Bucket resources reconcile against\n  s3SecretStore: string; // ESO ClusterSecretStore name holding the S3 credentials\n  s3CredentialsKey: string; // Remote key in the store to extract S3 credentials from (provides AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY)\n  grafanaSecretStore: string; // ESO ClusterSecretStore name holding the Grafana admin credentials\n  grafanaCredentialsKey: string; // Remote key in the store to extract the Grafana admin credentials from\n}\n\n/**\n * Retention policies for metrics and logs\n */\nexport interface RetentionConfig {\n  prometheus: string; // Prometheus local retention (e.g., \"3d\")\n  prometheusS3Raw: number; // Thanos raw data retention (days)\n  prometheusS35m: number; // Thanos 5-minute downsampled retention (days)\n  prometheusS31h: number; // Thanos 1-hour downsampled retention (days)\n  loki: string; // Loki retention (e.g., \"744h\" for 31 days)\n}\n\n/**\n * Storage sizes for persistent volumes\n */\nexport interface StorageConfig {\n  prometheus: string; // Prometheus PVC size\n  grafana: string; // Grafana PVC size\n  alertmanager: string; // Alertmanager PVC size\n  lokiBackend: string; // Loki backend PVC size\n  lokiWrite: string; // Loki write PVC size\n  thanosStore: string; // Thanos store PVC size (per replica)\n  thanosCompactor: string; // Thanos compactor PVC size\n}\n\n/**\n * Replica counts for high availability\n */\nexport interface ReplicaConfig {\n  prometheus: number; // Prometheus replicas\n  alertmanager: number; // Alertmanager replicas\n  grafana: number; // Grafana replicas (usually 1)\n  lokiBackend: number; // Loki backend replicas\n  lokiRead: number; // Loki read replicas\n  lokiWrite: number; // Loki write replicas\n  thanosQuery: number; // Thanos Query replicas\n  thanosStore: number; // Thanos Store replicas\n}\n\n/**\n * Resource requirements for all components\n */\nexport interface ResourceConfig {\n  prometheus: ResourceRequirements;\n  grafana: ResourceRequirements;\n  alertmanager: ResourceRequirements;\n  lokiBackend: ResourceRequirements;\n  lokiRead: ResourceRequirements;\n  lokiWrite: ResourceRequirements;\n  lokiGateway: ResourceRequirements;\n  alloy: ResourceRequirements;\n  thanosQuery: ResourceRequirements;\n  thanosStore: ResourceRequirements;\n  thanosCompactor: ResourceRequirements;\n  // Sidecar containers (added 2025-11-18)\n  configReloader: ResourceRequirements; // config-reloader sidecar (Prometheus, Alertmanager, Alloy)\n  thanosSidecar: ResourceRequirements; // thanos-sidecar for Prometheus\n}\n\n/**\n * Helm chart version configuration\n */\nexport interface VersionConfig {\n  prometheusStack: string; // kube-prometheus-stack chart version (e.g., \"latest\" or \"65.0.0\")\n  loki: string; // Loki chart version\n  alloy: string; // Alloy chart version\n  thanos: string; // Thanos image version (e.g., \"v0.36.1\")\n}\n\n/**\n * Configuration the package ships sensible defaults for.\n * Integration charts may override any of these (deep-merged over DEFAULT_CONFIG).\n */\nexport interface DefaultableConfig {\n  versions: VersionConfig; // Chart and image versions\n  retention: RetentionConfig; // Data retention policies\n  storage: StorageConfig; // PVC storage sizes\n  replicas: ReplicaConfig; // Replica counts\n  resources: ResourceConfig; // Resource requests and limits\n}\n\n/**\n * Cluster-specific configuration with no sensible universal default.\n * Integration charts must provide these.\n */\nexport interface RequiredClusterConfig {\n  namespace: string; // Kubernetes namespace\n  domains: DomainConfig; // Domain names for ingresses\n  s3: S3Config; // S3 object storage configuration\n  smtp: SmtpConfig; // SMTP alerting configuration\n  integrations: IntegrationsConfig; // Names of external Crossplane/ESO resources to reference\n}\n\n/**\n * Recursive partial — every property (including nested ones) becomes optional.\n */\nexport type DeepPartial<T> = {\n  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];\n};\n\n/**\n * Input accepted by mergeConfig: required cluster values plus optional,\n * deeply-partial overrides of the package defaults.\n */\nexport type MonitoringConfigInput = RequiredClusterConfig & DeepPartial<DefaultableConfig>;\n\n/**\n * Complete, resolved monitoring stack configuration consumed by MonitoringChart.\n */\nexport interface MonitoringConfig extends RequiredClusterConfig, DefaultableConfig {}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Resource allocation for a component (CPU and memory)\n */\nexport interface ResourceAllocation {\n  cpu: string;\n  memory: string;\n}\n\n/**\n * Resource requests and limits for a component\n */\nexport interface ResourceRequirements {\n  requests: ResourceAllocation;\n  limits: ResourceAllocation;\n}\n\n/**\n * S3 configuration for object storage\n */\nexport interface S3Config {\n  endpoint: string; // Full endpoint with protocol (e.g., https://fsn1.your-objectstorage.com)\n  endpointNoProtocol: string; // Endpoint without protocol (for Thanos)\n  region: string; // S3 region (e.g., fsn1)\n  buckets: {\n    thanos: string; // Thanos metrics bucket\n    loki: string; // Loki logs bucket\n  };\n}\n\n/**\n * SMTP configuration for alerting\n */\nexport interface SmtpConfig {\n  host: string; // SMTP server hostname\n  port: number; // SMTP server port\n  from: string; // From email address\n  username?: string; // SMTP username (optional)\n  password?: string; // SMTP password (optional)\n  requireTls: boolean; // Require TLS for SMTP\n}\n\n/**\n * Domain configuration for ingresses\n */\nexport interface DomainConfig {\n  grafana: string; // Grafana domain (e.g., grafana.ops.kup6s.net)\n}\n\n/**\n * Names of the external Crossplane and External Secrets Operator resources this\n * stack references. These are not created by the library; they must already exist\n * in your cluster. There are no defaults — every consumer wires its own names.\n */\nexport interface IntegrationsConfig {\n  s3ProviderConfig: string; // Crossplane ProviderConfig name the Bucket resources reconcile against\n  s3SecretStore: string; // ESO ClusterSecretStore name holding the S3 credentials\n  s3CredentialsKey: string; // Remote key in the store to extract S3 credentials from (provides AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY)\n  grafanaSecretStore: string; // ESO ClusterSecretStore name holding the Grafana admin credentials\n  grafanaCredentialsKey: string; // Remote key in the store to extract the Grafana admin credentials from\n}\n\n/**\n * Retention policies for metrics and logs\n */\nexport interface RetentionConfig {\n  prometheus: string; // Prometheus local retention (e.g., \"3d\")\n  prometheusS3Raw: number; // Thanos raw data retention (days)\n  prometheusS35m: number; // Thanos 5-minute downsampled retention (days)\n  prometheusS31h: number; // Thanos 1-hour downsampled retention (days)\n  loki: string; // Loki retention (e.g., \"744h\" for 31 days)\n}\n\n/**\n * Storage sizes for persistent volumes\n */\nexport interface StorageConfig {\n  prometheus: string; // Prometheus PVC size\n  grafana: string; // Grafana PVC size\n  alertmanager: string; // Alertmanager PVC size\n  lokiBackend: string; // Loki backend PVC size\n  lokiWrite: string; // Loki write PVC size\n  thanosStore: string; // Thanos store PVC size (per replica)\n  thanosCompactor: string; // Thanos compactor PVC size\n  tempo: string; // Tempo WAL/local-blocks PVC size\n}\n\n/**\n * Replica counts for high availability\n */\nexport interface ReplicaConfig {\n  prometheus: number; // Prometheus replicas\n  alertmanager: number; // Alertmanager replicas\n  grafana: number; // Grafana replicas (usually 1)\n  lokiBackend: number; // Loki backend replicas\n  lokiRead: number; // Loki read replicas\n  lokiWrite: number; // Loki write replicas\n  thanosQuery: number; // Thanos Query replicas\n  thanosStore: number; // Thanos Store replicas\n  tempo: number; // Tempo replicas\n}\n\n/**\n * Resource requirements for all components\n */\nexport interface ResourceConfig {\n  prometheus: ResourceRequirements;\n  grafana: ResourceRequirements;\n  alertmanager: ResourceRequirements;\n  lokiBackend: ResourceRequirements;\n  lokiRead: ResourceRequirements;\n  lokiWrite: ResourceRequirements;\n  lokiGateway: ResourceRequirements;\n  alloy: ResourceRequirements;\n  thanosQuery: ResourceRequirements;\n  thanosStore: ResourceRequirements;\n  thanosCompactor: ResourceRequirements;\n  // Sidecar containers (added 2025-11-18)\n  configReloader: ResourceRequirements; // config-reloader sidecar (Prometheus, Alertmanager, Alloy)\n  thanosSidecar: ResourceRequirements; // thanos-sidecar for Prometheus\n  tempo: ResourceRequirements; // Tempo (monolithic)\n  alloyTraces: ResourceRequirements; // Alloy traces OTLP gateway\n}\n\n/**\n * Helm chart version configuration\n */\nexport interface VersionConfig {\n  prometheusStack: string; // kube-prometheus-stack chart version (e.g., \"latest\" or \"65.0.0\")\n  loki: string; // Loki chart version\n  alloy: string; // Alloy chart version\n  thanos: string; // Thanos image version (e.g., \"v0.36.1\")\n  tempo: string; // grafana/tempo chart version\n}\n\n/**\n * Tail-sampling policy for the Alloy traces gateway.\n */\nexport interface TempoTailSamplingConfig {\n  latencyThresholdMs: number; // keep traces slower than this\n  probabilisticPercent: number; // keep this % of the remaining (\"normal\") traces\n}\n\n/**\n * Grafana Tempo tracing configuration (opt-in).\n */\nexport interface TempoConfig {\n  enabled: boolean; // default false — when false, no Tempo resources are created\n  bucket: string; // S3 bucket for traces (required when enabled)\n  retention: string; // block retention, e.g. '336h' (14 days)\n  tailSampling: TempoTailSamplingConfig;\n}\n\n/**\n * Configuration the package ships sensible defaults for.\n * Integration charts may override any of these (deep-merged over DEFAULT_CONFIG).\n */\nexport interface DefaultableConfig {\n  versions: VersionConfig; // Chart and image versions\n  retention: RetentionConfig; // Data retention policies\n  storage: StorageConfig; // PVC storage sizes\n  replicas: ReplicaConfig; // Replica counts\n  resources: ResourceConfig; // Resource requests and limits\n  tempo: TempoConfig; // Grafana Tempo tracing (opt-in)\n}\n\n/**\n * Cluster-specific configuration with no sensible universal default.\n * Integration charts must provide these.\n */\nexport interface RequiredClusterConfig {\n  namespace: string; // Kubernetes namespace\n  domains: DomainConfig; // Domain names for ingresses\n  s3: S3Config; // S3 object storage configuration\n  smtp: SmtpConfig; // SMTP alerting configuration\n  integrations: IntegrationsConfig; // Names of external Crossplane/ESO resources to reference\n}\n\n/**\n * Recursive partial — every property (including nested ones) becomes optional.\n */\nexport type DeepPartial<T> = {\n  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];\n};\n\n/**\n * Input accepted by mergeConfig: required cluster values plus optional,\n * deeply-partial overrides of the package defaults.\n */\nexport type MonitoringConfigInput = RequiredClusterConfig & DeepPartial<DefaultableConfig>;\n\n/**\n * Complete, resolved monitoring stack configuration consumed by MonitoringChart.\n */\nexport interface MonitoringConfig extends RequiredClusterConfig, DefaultableConfig {}\n"]}

package/package.json

@@ -66,7 +66,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.2",
+  "version": "0.2.1",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [