@bluedynamics/cdk8s-monitoring 0.3.1 → 1.0.0

package/CLAUDE.md

@@ -46,6 +46,7 @@ documentation/        # Sphinx/MyST docs (Diataxis, plone-doc-style)
 ## Design Rules
 
 - **App-agnostic**: never add cluster- or application-specific resources (dashboards, alert rules, domains) to this library. Integration charts attach those beside `MonitoringChart`.
+  - *Exception — generic infra monitors*: monitors for infrastructure components that are generic across clusters using this stack (Traefik ingress, Longhorn storage) may live here as **opt-in, off-by-default** constructs (`config.traefik`, `config.longhorn`), including their scrape config and — gated by their own sub-toggle — the matching generic dashboard/alert. They must stay disabled unless a consumer explicitly enables them. This is *not* a license for anything cluster- or app-specific.
 - **Defaults in the package, overrides in the chart**: universal values live in `DEFAULT_CONFIG`; cluster-specific values are required input. `mergeConfig` deep-merges.
 - **Generated `imports/` are not hand-edited** and are excluded from lint/style.
 

package/README.md

@@ -71,6 +71,23 @@ new MyAppDashboardConstruct(chart, 'my-app-dashboard', { namespace: config.names
 
 A dashboard construct is a `ConfigMap` (use the re-exported `KubeConfigMap`) labeled `grafana_dashboard: "1"` so the Grafana sidecar discovers it. Alert rules are plain `PrometheusRule` resources you manage in your integration repo.
 
+### Generic infrastructure monitors (opt-in)
+
+Monitors for infrastructure components that are generic across clusters running this stack are built in but **disabled by default** — enable them per cluster. They are the exception to the "no dashboards/alerts in the library" rule because they are not app- or cluster-specific.
+
+```typescript
+new MonitoringChart(app, 'monitoring', mergeConfig({
+  // ...required config...
+  traefik: { enabled: true, namespace: 'traefik' }, // PodMonitor + Grafana dashboard
+  longhorn: { enabled: true },                       // ServiceMonitor + volume-health alerts
+}));
+```
+
+- **`traefik`** (`TraefikConfig`): a `PodMonitor` (the k3s-bundled Traefik exposes the metrics port on the Pod, not the Service) plus, unless `dashboard: false`, a Grafana dashboard `ConfigMap`. `namespace` is where Traefik runs (default `traefik`).
+- **`longhorn`** (`LonghornConfig`): a `ServiceMonitor` for `longhorn-manager` (port `manager`) plus, unless `alerts: false`, a `PrometheusRule` with `LonghornVolumeFaulted` (critical) / `LonghornVolumeUnhealthy` (warning). `namespace` defaults to `longhorn-system`.
+
+Both stay inert unless `enabled: true`, so the base stack and existing consumers are unaffected.
+
 ## Prerequisites
 
 The stack expects these to exist in the cluster:

package/lib/constructs/alloy-traces.js

@@ -44,6 +44,16 @@ class AlloyTracesConstruct extends constructs_1.Construct {
     }
     generateHelmValues(config) {
         const ts = config.tempo.tailSampling;
+        // The probabilistic policy keeps a percentage of the traces that no other
+        // policy matched (i.e. fast, non-error traces). Omit it entirely when set to
+        // 0 so those traces are dropped instead of leaking a fraction to Tempo.
+        const probabilisticPolicy = ts.probabilisticPercent > 0 ? `
+
+        policy {
+          name = "rest"
+          type = "probabilistic"
+          probabilistic { sampling_percentage = ${ts.probabilisticPercent} }
+        }` : '';
         return `controller:
   type: deployment
   replicas: 1
@@ -78,13 +88,7 @@ alloy:
           name = "slow"
           type = "latency"
           latency { threshold_ms = ${ts.latencyThresholdMs} }
-        }
-
-        policy {
-          name = "rest"
-          type = "probabilistic"
-          probabilistic { sampling_percentage = ${ts.probabilisticPercent} }
-        }
+        }${probabilisticPolicy}
 
         output { traces = [otelcol.exporter.otlp.tempo.input] }
       }
@@ -106,4 +110,4 @@ resources:
     }
 }
 exports.AlloyTracesConstruct = AlloyTracesConstruct;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/constructs/longhorn-monitor.d.ts

@@ -0,0 +1,24 @@
+import { Construct } from 'constructs';
+import { LonghornConfig } from '../types';
+export interface LonghornMonitorProps {
+    /** Namespace the monitoring stack lives in (where the ServiceMonitor/PrometheusRule go). */
+    readonly monitoringNamespace: string;
+    /** Longhorn config (namespace it runs in + alerts toggle). */
+    readonly longhorn: LonghornConfig;
+}
+/**
+ * Generic, opt-in monitor for Longhorn distributed storage.
+ *
+ * ServiceMonitor scrapes the longhorn-manager metrics (port `manager`, 9500):
+ * volume/node/storage-pool health and capacity.
+ *
+ * Optionally ships volume-health alerts (config.longhorn.alerts). Motivated by a
+ * real incident (2026-05-21): a CNPG replica PVC went detached/unknown with no
+ * alert; noticed only 2h later via a downstream CNPG error. These rules surface
+ * storage health within minutes.
+ *
+ * longhorn_volume_robustness: 0=unknown, 1=healthy, 2=degraded, 3=faulted.
+ */
+export declare class LonghornMonitorConstruct extends Construct {
+    constructor(scope: Construct, id: string, props: LonghornMonitorProps);
+}

package/lib/constructs/longhorn-monitor.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LonghornMonitorConstruct = void 0;
+const constructs_1 = require("constructs");
+const monitoring_coreos_com_1 = require("../imports/monitoring.coreos.com");
+/**
+ * Generic, opt-in monitor for Longhorn distributed storage.
+ *
+ * ServiceMonitor scrapes the longhorn-manager metrics (port `manager`, 9500):
+ * volume/node/storage-pool health and capacity.
+ *
+ * Optionally ships volume-health alerts (config.longhorn.alerts). Motivated by a
+ * real incident (2026-05-21): a CNPG replica PVC went detached/unknown with no
+ * alert; noticed only 2h later via a downstream CNPG error. These rules surface
+ * storage health within minutes.
+ *
+ * longhorn_volume_robustness: 0=unknown, 1=healthy, 2=degraded, 3=faulted.
+ */
+class LonghornMonitorConstruct extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const { monitoringNamespace, longhorn } = props;
+        const labels = {
+            'app.kubernetes.io/name': 'longhorn',
+            'app.kubernetes.io/component': 'storage',
+            'app.kubernetes.io/managed-by': 'cdk8s',
+            'app.kubernetes.io/part-of': 'monitoring',
+            'release': 'kube-prometheus-stack',
+        };
+        new monitoring_coreos_com_1.ServiceMonitor(this, 'longhorn-metrics', {
+            metadata: { name: 'longhorn-metrics', namespace: monitoringNamespace, labels },
+            spec: {
+                selector: { matchLabels: { app: 'longhorn-manager' } },
+                namespaceSelector: { matchNames: [longhorn.namespace] },
+                endpoints: [
+                    { port: 'manager', path: '/metrics', interval: '30s', scrapeTimeout: '10s' },
+                ],
+            },
+        });
+        if (longhorn.alerts) {
+            new monitoring_coreos_com_1.PrometheusRule(this, 'longhorn-volume-health-rules', {
+                metadata: { name: 'longhorn-volume-health', namespace: monitoringNamespace, labels },
+                spec: {
+                    groups: [
+                        {
+                            name: 'longhorn.volume-health',
+                            rules: [
+                                {
+                                    alert: 'LonghornVolumeFaulted',
+                                    expr: monitoring_coreos_com_1.PrometheusRuleSpecGroupsRulesExpr.fromString('longhorn_volume_robustness == 3'),
+                                    for: '1m',
+                                    labels: { severity: 'critical' },
+                                    annotations: {
+                                        summary: 'Longhorn volume {{ $labels.volume }} is faulted',
+                                        description: 'Volume {{ $labels.volume }} (node={{ $labels.node }}, pvc={{ $labels.pvc }}) is in faulted state. ' +
+                                            'Data may be lost. Recovery: scale workload down, delete PVC, scale up so the StatefulSet/operator re-creates and re-syncs from a healthy source.',
+                                    },
+                                },
+                                {
+                                    alert: 'LonghornVolumeUnhealthy',
+                                    expr: monitoring_coreos_com_1.PrometheusRuleSpecGroupsRulesExpr.fromString('longhorn_volume_robustness == 0 or longhorn_volume_robustness == 2'),
+                                    for: '10m',
+                                    labels: { severity: 'warning' },
+                                    annotations: {
+                                        summary: 'Longhorn volume {{ $labels.volume }} not healthy (robustness={{ $value }})',
+                                        description: 'Volume {{ $labels.volume }} (node={{ $labels.node }}, pvc={{ $labels.pvc }}) has been non-healthy for >10m. ' +
+                                            'robustness values: 0=unknown, 2=degraded. A short degraded window during a replica rebuild is normal; 10m+ means manual investigation.',
+                                    },
+                                },
+                            ],
+                        },
+                    ],
+                },
+            });
+        }
+    }
+}
+exports.LonghornMonitorConstruct = LonghornMonitorConstruct;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/constructs/prometheus-stack.js

@@ -66,6 +66,7 @@ class PrometheusStackConstruct extends constructs_1.Construct {
         access: proxy
         url: http://tempo.${config.namespace}.svc.cluster.local:3200
         jsonData:
+          timeout: 60
           tracesToLogsV2:
             datasourceUid: loki
             spanStartTimeShift: "-1h"
@@ -472,4 +473,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":";;;AAAA,iCAAkC;AAClC,2CAAuC;AAQvC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAa,wBAAyB,SAAQ,sBAAS;IACrD,YAAY,KAAgB,EAAE,EAAU,EAAE,KAA2B;QACnE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC;QAEpC,4BAA4B;QAC5B,MAAM,UAAU,GAAG,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC;QAEnD,kDAAkD;QAClD,2CAA2C;QAC3C,IAAI,iBAAS,CAAC,IAAI,EAAE,uBAAuB,EAAE;YAC3C,UAAU,EAAE,mBAAmB;YAC/B,IAAI,EAAE,WAAW;YACjB,QAAQ,EAAE;gBACR,IAAI,EAAE,uBAAuB;gBAC7B,SAAS,EAAE,SAAS;gBACpB,MAAM,EAAE;oBACN,wBAAwB,EAAE,uBAAuB;oBACjD,6BAA6B,EAAE,YAAY;oBAC3C,8BAA8B,EAAE,OAAO;oBACvC,2BAA2B,EAAE,YAAY;iBAC1C;gBACD,WAAW,EAAE;oBACX,8BAA8B,EAAE,GAAG;iBACpC;aACF;YACD,IAAI,EAAE;gBACJ,IAAI,EAAE,oDAAoD;gBAC1D,KAAK,EAAE,uBAAuB;gBAC9B,OAAO,EAAE,MAAM,CAAC,QAAQ,CAAC,eAAe,KAAK,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe;gBACnG,eAAe,EAAE,SAAS;gBAC1B,aAAa,EAAE,UAAU;aAC1B;SACF,CAAC,CAAC;IACL,CAAC;IAEO,kBAAkB,CAAC,MAAwB;QACjD,qEAAqE;QACrE,4EAA4E;QAC5E,MAAM,eAAe,GAAG,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;;;;;4BAKvB,MAAM,CAAC,SAAS;;;;;;;;kCAQV,CAAC,CAAC,CAAC,EAAE,CAAC;QACpC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAyFQ,MAAM,CAAC,IAAI,CAAC,IAAI;wBACX,MAAM,CAAC,IAAI,CAAC,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI;0BAClC,MAAM,CAAC,IAAI,CAAC,UAAU;4BACpB,MAAM,CAAC,IAAI,CAAC,QAAQ,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI;4BACxC,MAAM,CAAC,IAAI,CAAC,QAAQ,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA6BxC,MAAM,CAAC,IAAI,CAAC,IAAI;;;;;;;;;;;;;gBAad,MAAM,CAAC,QAAQ,CAAC,YAAY;;;;;;;;yBAQnB,MAAM,CAAC,OAAO,CAAC,YAAY;;;eAGrC,MAAM,CAAC,SAAS,CAAC,YAAY,CAAC,MAAM,CAAC,GAAG;kBACrC,MAAM,CAAC,SAAS,CAAC,YAAY,CAAC,MAAM,CAAC,MAAM;;eAE9C,MAAM,CAAC,SAAS,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG;kBACvC,MAAM,CAAC,SAAS,CAAC,YAAY,CAAC,QAAQ,CAAC,MAAM;;;;;;;;iBAQ9C,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,QAAQ,CAAC,GAAG;oBACzC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,QAAQ,CAAC,MAAM;;iBAElD,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,MAAM,CAAC,GAAG;oBACvC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,MAAM,CAAC,MAAM;;;;;;;;;;iBAUhD,MAAM,CAAC,SAAS,CAAC,UAAU;;;;;;;;;;;;;;;;gBAgB5B,MAAM,CAAC,QAAQ,CAAC,UAAU;;;;;;;;;yBASjB,MAAM,CAAC,OAAO,CAAC,UAAU;;;;eAInC,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG;kBACnC,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,MAAM,CAAC,MAAM;;eAE5C,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,QAAQ,CAAC,GAAG;kBACrC,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,QAAQ,CAAC,MAAM;;;;;iBAK5C,MAAM,CAAC,WAAW;;;;;;;;;;;;;;;;;;;;;;iBAsBlB,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,QAAQ,CAAC,GAAG;oBACzC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,QAAQ,CAAC,MAAM;;iBAElD,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,MAAM,CAAC,GAAG;oBACvC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,MAAM,CAAC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAwCvD,MAAM,CAAC,OAAO,CAAC,OAAO;;;;;;;YAOpB,MAAM,CAAC,OAAO,CAAC,OAAO;;;;aAIrB,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG;gBAChC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM;;aAEzC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG;gBAClC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;YAyB5C,MAAM,CAAC,OAAO,CAAC,OAAO;;;;;;;;;;;;;;;;;;;;;;mCAsBC,MAAM,CAAC,SAAS;;;;;;;;uDAQI,MAAM,CAAC,SAAS;;;;;;;;mCAQpC,MAAM,CAAC,SAAS;;0BAEzB,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCxC,CAAC;IACA,CAAC;CACF;AAncD,4DAmcC","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# 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: ${config.clusterName}\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"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prometheus-stack.js","sourceRoot":"","sources":["../../src/constructs/prometheus-stack.ts"],"names":[],"mappings":";;;AAAA,iCAAkC;AAClC,2CAAuC;AAQvC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAa,wBAAyB,SAAQ,sBAAS;IACrD,YAAY,KAAgB,EAAE,EAAU,EAAE,KAA2B;QACnE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC;QAEpC,4BAA4B;QAC5B,MAAM,UAAU,GAAG,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC;QAEnD,kDAAkD;QAClD,2CAA2C;QAC3C,IAAI,iBAAS,CAAC,IAAI,EAAE,uBAAuB,EAAE;YAC3C,UAAU,EAAE,mBAAmB;YAC/B,IAAI,EAAE,WAAW;YACjB,QAAQ,EAAE;gBACR,IAAI,EAAE,uBAAuB;gBAC7B,SAAS,EAAE,SAAS;gBACpB,MAAM,EAAE;oBACN,wBAAwB,EAAE,uBAAuB;oBACjD,6BAA6B,EAAE,YAAY;oBAC3C,8BAA8B,EAAE,OAAO;oBACvC,2BAA2B,EAAE,YAAY;iBAC1C;gBACD,WAAW,EAAE;oBACX,8BAA8B,EAAE,GAAG;iBACpC;aACF;YACD,IAAI,EAAE;gBACJ,IAAI,EAAE,oDAAoD;gBAC1D,KAAK,EAAE,uBAAuB;gBAC9B,OAAO,EAAE,MAAM,CAAC,QAAQ,CAAC,eAAe,KAAK,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe;gBACnG,eAAe,EAAE,SAAS;gBAC1B,aAAa,EAAE,UAAU;aAC1B;SACF,CAAC,CAAC;IACL,CAAC;IAEO,kBAAkB,CAAC,MAAwB;QACjD,qEAAqE;QACrE,4EAA4E;QAC5E,MAAM,eAAe,GAAG,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC;;;;;4BAKvB,MAAM,CAAC,SAAS;;;;;;;;;kCASV,CAAC,CAAC,CAAC,EAAE,CAAC;QACpC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAyFQ,MAAM,CAAC,IAAI,CAAC,IAAI;wBACX,MAAM,CAAC,IAAI,CAAC,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI;0BAClC,MAAM,CAAC,IAAI,CAAC,UAAU;4BACpB,MAAM,CAAC,IAAI,CAAC,QAAQ,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI;4BACxC,MAAM,CAAC,IAAI,CAAC,QAAQ,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA6BxC,MAAM,CAAC,IAAI,CAAC,IAAI;;;;;;;;;;;;;gBAad,MAAM,CAAC,QAAQ,CAAC,YAAY;;;;;;;;yBAQnB,MAAM,CAAC,OAAO,CAAC,YAAY;;;eAGrC,MAAM,CAAC,SAAS,CAAC,YAAY,CAAC,MAAM,CAAC,GAAG;kBACrC,MAAM,CAAC,SAAS,CAAC,YAAY,CAAC,MAAM,CAAC,MAAM;;eAE9C,MAAM,CAAC,SAAS,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG;kBACvC,MAAM,CAAC,SAAS,CAAC,YAAY,CAAC,QAAQ,CAAC,MAAM;;;;;;;;iBAQ9C,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,QAAQ,CAAC,GAAG;oBACzC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,QAAQ,CAAC,MAAM;;iBAElD,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,MAAM,CAAC,GAAG;oBACvC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,MAAM,CAAC,MAAM;;;;;;;;;;iBAUhD,MAAM,CAAC,SAAS,CAAC,UAAU;;;;;;;;;;;;;;;;gBAgB5B,MAAM,CAAC,QAAQ,CAAC,UAAU;;;;;;;;;yBASjB,MAAM,CAAC,OAAO,CAAC,UAAU;;;;eAInC,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG;kBACnC,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,MAAM,CAAC,MAAM;;eAE5C,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,QAAQ,CAAC,GAAG;kBACrC,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,QAAQ,CAAC,MAAM;;;;;iBAK5C,MAAM,CAAC,WAAW;;;;;;;;;;;;;;;;;;;;;;iBAsBlB,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,QAAQ,CAAC,GAAG;oBACzC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,QAAQ,CAAC,MAAM;;iBAElD,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,MAAM,CAAC,GAAG;oBACvC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,MAAM,CAAC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAwCvD,MAAM,CAAC,OAAO,CAAC,OAAO;;;;;;;YAOpB,MAAM,CAAC,OAAO,CAAC,OAAO;;;;aAIrB,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG;gBAChC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM;;aAEzC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG;gBAClC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;YAyB5C,MAAM,CAAC,OAAO,CAAC,OAAO;;;;;;;;;;;;;;;;;;;;;;mCAsBC,MAAM,CAAC,SAAS;;;;;;;;uDAQI,MAAM,CAAC,SAAS;;;;;;;;mCAQpC,MAAM,CAAC,SAAS;;0BAEzB,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCxC,CAAC;IACA,CAAC;CACF;AApcD,4DAocC","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          timeout: 60\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# 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: ${config.clusterName}\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.js

@@ -50,6 +50,20 @@ class TempoConstruct extends constructs_1.Construct {
         return `replicas: ${config.replicas.tempo}
 tempo:
   retention: ${config.tempo.retention}
+  # Soften the liveness probe: a single-binary Tempo serving expensive trace
+  # searches can make /ready slow, and the chart default (timeout 5s,
+  # failureThreshold 3) then SIGKILLs it under load. Readiness stays at the
+  # chart default (sharp) so an overloaded instance is pulled from the Service
+  # without being killed.
+  livenessProbe:
+    httpGet:
+      path: /ready
+      port: 3200
+    initialDelaySeconds: 60
+    periodSeconds: 30
+    timeoutSeconds: 15
+    failureThreshold: 6
+    successThreshold: 1
   storage:
     trace:
       backend: s3
@@ -96,4 +110,4 @@ tempoQuery:
     }
 }
 exports.TempoConstruct = TempoConstruct;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVtcG8uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvY29uc3RydWN0cy90ZW1wby50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxpQ0FBa0M7QUFDbEMsMkNBQXVDO0FBU3ZDOzs7Ozs7OztHQVFHO0FBQ0gsTUFBYSxjQUFlLFNBQVEsc0JBQVM7SUFDM0MsWUFBWSxLQUFnQixFQUFFLEVBQVUsRUFBRSxLQUFpQjtRQUN6RCxLQUFLLENBQUMsS0FBSyxFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBRWpCLE1BQU0sRUFBRSxTQUFTLEVBQUUsTUFBTSxFQUFFLHVCQUF1QixFQUFFLEdBQUcsS0FBSyxDQUFDO1FBRTdELElBQUksaUJBQVMsQ0FBQyxJQUFJLEVBQUUsT0FBTyxFQUFFO1lBQzNCLFVBQVUsRUFBRSxtQkFBbUI7WUFDL0IsSUFBSSxFQUFFLFdBQVc7WUFDakIsUUFBUSxFQUFFO2dCQUNSLElBQUksRUFBRSxPQUFPO2dCQUNiLFNBQVMsRUFBRSxTQUFTO2dCQUNwQixNQUFNLEVBQUU7b0JBQ04sd0JBQXdCLEVBQUUsT0FBTztvQkFDakMsNkJBQTZCLEVBQUUsU0FBUztvQkFDeEMsOEJBQThCLEVBQUUsT0FBTztvQkFDdkMsMkJBQTJCLEVBQUUsWUFBWTtpQkFDMUM7Z0JBQ0QsV0FBVyxFQUFFO29CQUNYLDhCQUE4QixFQUFFLEdBQUc7aUJBQ3BDO2FBQ0Y7WUFDRCxJQUFJLEVBQUU7Z0JBQ0osSUFBSSxFQUFFLHVDQUF1QztnQkFDN0MsS0FBSyxFQUFFLE9BQU87Z0JBQ2QsT0FBTyxFQUFFLE1BQU0sQ0FBQyxRQUFRLENBQUMsS0FBSyxLQUFLLFFBQVEsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFDLEtBQUs7Z0JBQy9FLGVBQWUsRUFBRSxTQUFTO2dCQUMxQixhQUFhLEVBQUUsSUFBSSxDQUFDLGtCQUFrQixDQUFDLE1BQU0sRUFBRSx1QkFBdUIsQ0FBQzthQUN4RTtTQUNGLENBQUMsQ0FBQztJQUNMLENBQUM7SUFFTyxrQkFBa0IsQ0FBQyxNQUF3QixFQUFFLHVCQUErQjtRQUNsRixvRUFBb0U7UUFDcEUsNEVBQTRFO1FBQzVFLDRFQUE0RTtRQUM1RSw4RUFBOEU7UUFDOUUsNEVBQTRFO1FBQzVFLE9BQU8sYUFBYSxNQUFNLENBQUMsUUFBUSxDQUFDLEtBQUs7O2VBRTlCLE1BQU0sQ0FBQyxLQUFLLENBQUMsU0FBUzs7Ozs7a0JBS25CLE1BQU0sQ0FBQyxLQUFLLENBQUMsTUFBTTtvQkFDakIsTUFBTSxDQUFDLEVBQUUsQ0FBQyxrQkFBa0I7a0JBQzlCLE1BQU0sQ0FBQyxFQUFFLENBQUMsTUFBTTs7Ozs7Ozs7Ozs7Ozs7YUFjckIsTUFBTSxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsUUFBUSxDQUFDLEdBQUc7Z0JBQ2hDLE1BQU0sQ0FBQyxTQUFTLENBQUMsS0FBSyxDQUFDLFFBQVEsQ0FBQyxNQUFNOzthQUV6QyxNQUFNLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsR0FBRztnQkFDOUIsTUFBTSxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLE1BQU07Ozs7O2tCQUtsQyx1QkFBdUI7Ozs7O2tCQUt2Qix1QkFBdUI7Ozs7O1VBSy9CLE1BQU0sQ0FBQyxPQUFPLENBQUMsS0FBSzs7O0NBRzdCLENBQUM7SUFDQSxDQUFDO0NBQ0Y7QUFyRkQsd0NBcUZDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQXBpT2JqZWN0IH0gZnJvbSAnY2RrOHMnO1xuaW1wb3J0IHsgQ29uc3RydWN0IH0gZnJvbSAnY29uc3RydWN0cyc7XG5pbXBvcnQgeyBNb25pdG9yaW5nQ29uZmlnIH0gZnJvbSAnLi4vdHlwZXMnO1xuXG5leHBvcnQgaW50ZXJmYWNlIFRlbXBvUHJvcHMge1xuICBuYW1lc3BhY2U6IHN0cmluZztcbiAgY29uZmlnOiBNb25pdG9yaW5nQ29uZmlnO1xuICBzM0NyZWRlbnRpYWxzU2VjcmV0TmFtZTogc3RyaW5nO1xufVxuXG4vKipcbiAqIENyZWF0ZXMgdGhlIEdyYWZhbmEgVGVtcG8gKG1vbm9saXRoaWMpIEhlbG1DaGFydCBmb3IgdHJhY2Ugc3RvcmFnZSBvbiBTMy5cbiAqXG4gKiBTaW5nbGUtYmluYXJ5IFRlbXBvIGJhY2tlZCBieSBvYmplY3Qgc3RvcmFnZSwgZXhwb3NpbmcgYW4gT1RMUCByZWNlaXZlciB0aGF0XG4gKiB0aGUgQWxsb3kgdHJhY2VzIGdhdGV3YXkgZm9yd2FyZHMgdG8uIEJsb2NrIHJldGVudGlvbiBpcyBlbmZvcmNlZCBieSBUZW1wbydzXG4gKiBjb21wYWN0b3IgKGNvbmZpZy50ZW1wby5yZXRlbnRpb24pLlxuICpcbiAqIFN5bmMgV2F2ZTogMyAoYWR2YW5jZWQgc2VydmljZXMsIGFmdGVyIGNvcmUgc3RhY2spLlxuICovXG5leHBvcnQgY2xhc3MgVGVtcG9Db25zdHJ1Y3QgZXh0ZW5kcyBDb25zdHJ1Y3Qge1xuICBjb25zdHJ1Y3RvcihzY29wZTogQ29uc3RydWN0LCBpZDogc3RyaW5nLCBwcm9wczogVGVtcG9Qcm9wcykge1xuICAgIHN1cGVyKHNjb3BlLCBpZCk7XG5cbiAgICBjb25zdCB7IG5hbWVzcGFjZSwgY29uZmlnLCBzM0NyZWRlbnRpYWxzU2VjcmV0TmFtZSB9ID0gcHJvcHM7XG5cbiAgICBuZXcgQXBpT2JqZWN0KHRoaXMsICd0ZW1wbycsIHtcbiAgICAgIGFwaVZlcnNpb246ICdoZWxtLmNhdHRsZS5pby92MScsXG4gICAgICBraW5kOiAnSGVsbUNoYXJ0JyxcbiAgICAgIG1ldGFkYXRhOiB7XG4gICAgICAgIG5hbWU6ICd0ZW1wbycsXG4gICAgICAgIG5hbWVzcGFjZTogbmFtZXNwYWNlLFxuICAgICAgICBsYWJlbHM6IHtcbiAgICAgICAgICAnYXBwLmt1YmVybmV0ZXMuaW8vbmFtZSc6ICd0ZW1wbycsXG4gICAgICAgICAgJ2FwcC5rdWJlcm5ldGVzLmlvL2NvbXBvbmVudCc6ICd0cmFjaW5nJyxcbiAgICAgICAgICAnYXBwLmt1YmVybmV0ZXMuaW8vbWFuYWdlZC1ieSc6ICdjZGs4cycsXG4gICAgICAgICAgJ2FwcC5rdWJlcm5ldGVzLmlvL3BhcnQtb2YnOiAnbW9uaXRvcmluZycsXG4gICAgICAgIH0sXG4gICAgICAgIGFubm90YXRpb25zOiB7XG4gICAgICAgICAgJ2FyZ29jZC5hcmdvcHJvai5pby9zeW5jLXdhdmUnOiAnMycsXG4gICAgICAgIH0sXG4gICAgICB9LFxuICAgICAgc3BlYzoge1xuICAgICAgICByZXBvOiAnaHR0cHM6Ly9ncmFmYW5hLmdpdGh1Yi5pby9oZWxtLWNoYXJ0cycsXG4gICAgICAgIGNoYXJ0OiAndGVtcG8nLFxuICAgICAgICB2ZXJzaW9uOiBjb25maWcudmVyc2lvbnMudGVtcG8gPT09ICdsYXRlc3QnID8gdW5kZWZpbmVkIDogY29uZmlnLnZlcnNpb25zLnRlbXBvLFxuICAgICAgICB0YXJnZXROYW1lc3BhY2U6IG5hbWVzcGFjZSxcbiAgICAgICAgdmFsdWVzQ29udGVudDogdGhpcy5nZW5lcmF0ZUhlbG1WYWx1ZXMoY29uZmlnLCBzM0NyZWRlbnRpYWxzU2VjcmV0TmFtZSksXG4gICAgICB9LFxuICAgIH0pO1xuICB9XG5cbiAgcHJpdmF0ZSBnZW5lcmF0ZUhlbG1WYWx1ZXMoY29uZmlnOiBNb25pdG9yaW5nQ29uZmlnLCBzM0NyZWRlbnRpYWxzU2VjcmV0TmFtZTogc3RyaW5nKTogc3RyaW5nIHtcbiAgICAvLyBWYWx1ZXMgZm9sbG93IHRoZSBtb25vbGl0aGljIGdyYWZhbmEvdGVtcG8gY2hhcnQgc2NoZW1hOiBzdG9yYWdlLFxuICAgIC8vIHJlY2VpdmVycywgcmVzb3VyY2VzLCBleHRyYUVudiBsaXZlIHVuZGVyIGB0ZW1wbzpgOyByZXBsaWNhcy9wZXJzaXN0ZW5jZS9cbiAgICAvLyB0ZW1wb1F1ZXJ5IGFyZSB0b3AtbGV2ZWwuIFMzIGNyZWRlbnRpYWxzIGFyZSBOT1QgaW5saW5lZCBpbnRvIHRoZSBjb25maWc7XG4gICAgLy8gVGVtcG8ncyBTMyBjbGllbnQgcGlja3MgdXAgQVdTX0FDQ0VTU19LRVlfSUQvQVdTX1NFQ1JFVF9BQ0NFU1NfS0VZIGZyb20gdGhlXG4gICAgLy8gZW52aXJvbm1lbnQgKHNldCBiZWxvdyBmcm9tIHRoZSBFU08tc3luY2VkIHNlY3JldCkgdmlhIHRoZSBkZWZhdWx0IGNoYWluLlxuICAgIHJldHVybiBgcmVwbGljYXM6ICR7Y29uZmlnLnJlcGxpY2FzLnRlbXBvfVxudGVtcG86XG4gIHJldGVudGlvbjogJHtjb25maWcudGVtcG8ucmV0ZW50aW9ufVxuICBzdG9yYWdlOlxuICAgIHRyYWNlOlxuICAgICAgYmFja2VuZDogczNcbiAgICAgIHMzOlxuICAgICAgICBidWNrZXQ6ICR7Y29uZmlnLnRlbXBvLmJ1Y2tldH1cbiAgICAgICAgZW5kcG9pbnQ6ICR7Y29uZmlnLnMzLmVuZHBvaW50Tm9Qcm90b2NvbH1cbiAgICAgICAgcmVnaW9uOiAke2NvbmZpZy5zMy5yZWdpb259XG4gICAgICAgIGZvcmNlcGF0aHN0eWxlOiBmYWxzZVxuICAgICAgICBpbnNlY3VyZTogZmFsc2VcbiAgICAgIHdhbDpcbiAgICAgICAgcGF0aDogL3Zhci90ZW1wby93YWxcbiAgcmVjZWl2ZXJzOlxuICAgIG90bHA6XG4gICAgICBwcm90b2NvbHM6XG4gICAgICAgIGdycGM6XG4gICAgICAgICAgZW5kcG9pbnQ6IFwiMC4wLjAuMDo0MzE3XCJcbiAgICAgICAgaHR0cDpcbiAgICAgICAgICBlbmRwb2ludDogXCIwLjAuMC4wOjQzMThcIlxuICByZXNvdXJjZXM6XG4gICAgcmVxdWVzdHM6XG4gICAgICBjcHU6ICR7Y29uZmlnLnJlc291cmNlcy50ZW1wby5yZXF1ZXN0cy5jcHV9XG4gICAgICBtZW1vcnk6ICR7Y29uZmlnLnJlc291cmNlcy50ZW1wby5yZXF1ZXN0cy5tZW1vcnl9XG4gICAgbGltaXRzOlxuICAgICAgY3B1OiAke2NvbmZpZy5yZXNvdXJjZXMudGVtcG8ubGltaXRzLmNwdX1cbiAgICAgIG1lbW9yeTogJHtjb25maWcucmVzb3VyY2VzLnRlbXBvLmxpbWl0cy5tZW1vcnl9XG4gIGV4dHJhRW52OlxuICAgIC0gbmFtZTogQVdTX0FDQ0VTU19LRVlfSURcbiAgICAgIHZhbHVlRnJvbTpcbiAgICAgICAgc2VjcmV0S2V5UmVmOlxuICAgICAgICAgIG5hbWU6ICR7czNDcmVkZW50aWFsc1NlY3JldE5hbWV9XG4gICAgICAgICAga2V5OiBBV1NfQUNDRVNTX0tFWV9JRFxuICAgIC0gbmFtZTogQVdTX1NFQ1JFVF9BQ0NFU1NfS0VZXG4gICAgICB2YWx1ZUZyb206XG4gICAgICAgIHNlY3JldEtleVJlZjpcbiAgICAgICAgICBuYW1lOiAke3MzQ3JlZGVudGlhbHNTZWNyZXROYW1lfVxuICAgICAgICAgIGtleTogQVdTX1NFQ1JFVF9BQ0NFU1NfS0VZXG5wZXJzaXN0ZW5jZTpcbiAgZW5hYmxlZDogdHJ1ZVxuICBzdG9yYWdlQ2xhc3NOYW1lOiBsb25naG9yblxuICBzaXplOiAke2NvbmZpZy5zdG9yYWdlLnRlbXBvfVxudGVtcG9RdWVyeTpcbiAgZW5hYmxlZDogZmFsc2VcbmA7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/lib/constructs/traefik-monitor.d.ts

@@ -0,0 +1,20 @@
+import { Construct } from 'constructs';
+import { TraefikConfig } from '../types';
+export interface TraefikMonitorProps {
+    /** Namespace the monitoring stack lives in (where the PodMonitor/ConfigMap go). */
+    readonly monitoringNamespace: string;
+    /** Traefik config (namespace it runs in + dashboard toggle). */
+    readonly traefik: TraefikConfig;
+}
+/**
+ * Generic, opt-in monitor for a Traefik ingress controller.
+ *
+ * Uses a PodMonitor (not a ServiceMonitor): the k3s-bundled Traefik Service only
+ * exposes web/websecure; the `metrics` port is on the Pod, not the Service.
+ *
+ * Optionally ships the Traefik Grafana dashboard as a ConfigMap (grafana_dashboard
+ * label → sidecar auto-discovery). Enabled via config.traefik in MonitoringChart.
+ */
+export declare class TraefikMonitorConstruct extends Construct {
+    constructor(scope: Construct, id: string, props: TraefikMonitorProps);
+}

package/lib/constructs/traefik-monitor.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TraefikMonitorConstruct = void 0;
+const constructs_1 = require("constructs");
+const traefik_dashboard_1 = require("../dashboards/traefik-dashboard");
+const k8s_1 = require("../imports/k8s");
+const monitoring_coreos_com_1 = require("../imports/monitoring.coreos.com");
+/**
+ * Generic, opt-in monitor for a Traefik ingress controller.
+ *
+ * Uses a PodMonitor (not a ServiceMonitor): the k3s-bundled Traefik Service only
+ * exposes web/websecure; the `metrics` port is on the Pod, not the Service.
+ *
+ * Optionally ships the Traefik Grafana dashboard as a ConfigMap (grafana_dashboard
+ * label → sidecar auto-discovery). Enabled via config.traefik in MonitoringChart.
+ */
+class TraefikMonitorConstruct extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const { monitoringNamespace, traefik } = props;
+        new monitoring_coreos_com_1.PodMonitor(this, 'traefik-metrics', {
+            metadata: {
+                name: 'traefik-metrics',
+                namespace: monitoringNamespace,
+                labels: {
+                    'app.kubernetes.io/name': 'traefik',
+                    'app.kubernetes.io/component': 'ingress-controller',
+                    'app.kubernetes.io/managed-by': 'cdk8s',
+                    'app.kubernetes.io/part-of': 'monitoring',
+                    'release': 'kube-prometheus-stack',
+                },
+            },
+            spec: {
+                selector: { matchLabels: { 'app.kubernetes.io/name': 'traefik' } },
+                namespaceSelector: { matchNames: [traefik.namespace] },
+                podMetricsEndpoints: [
+                    { port: 'metrics', path: '/metrics', interval: '30s', scrapeTimeout: '10s' },
+                ],
+            },
+        });
+        if (traefik.dashboard) {
+            new k8s_1.KubeConfigMap(this, 'traefik-dashboard', {
+                metadata: {
+                    name: 'traefik-dashboard',
+                    namespace: monitoringNamespace,
+                    labels: {
+                        'grafana_dashboard': '1',
+                        'app.kubernetes.io/name': 'traefik',
+                        'app.kubernetes.io/component': 'dashboard',
+                        'app.kubernetes.io/managed-by': 'cdk8s',
+                        'app.kubernetes.io/part-of': 'monitoring',
+                    },
+                },
+                data: { 'traefik.json': JSON.stringify(traefik_dashboard_1.TRAEFIK_DASHBOARD) },
+            });
+        }
+    }
+}
+exports.TraefikMonitorConstruct = TraefikMonitorConstruct;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/dashboards/traefik-dashboard.d.ts

@@ -0,0 +1 @@
+export declare const TRAEFIK_DASHBOARD: Record<string, unknown>;