Kubernetes

The OpenTelemetry Collector Helm chart runs a Collector on every node. It sends pod logs, kubelet metrics, and your apps’ OTLP data to Squasher, and the Kubernetes tab of Infrastructure shows the pods. If you need only CPU and memory, a smaller Squasher Collector DaemonSet is also available.

Prerequisites

kubectl, with access to the cluster. Helm for the Helm chart, or Docker and a container registry for the Squasher Collector DaemonSet.
An ingest key in the environment as SQUASHER_API_KEY. See Create an ingest key.

Use the OpenTelemetry Collector Helm chart

This is the recommended setup. It sends pod logs, kubelet metrics, Kubernetes attributes, and your apps’ OTLP data. A second, optional release sends cluster metrics, such as container restarts, and Kubernetes events.

Store the key and the cluster name as a secret

Both releases read the ingest key and the cluster name from this secret. The cluster name is required: it must be the same for the node release and the cluster release, so that CPU and memory from each node join the restarts and pod state from the cluster release in one row.

kubectl create namespace monitoring
kubectl create secret generic squasher --namespace monitoring \
  --from-literal=api-key="$SQUASHER_API_KEY" \
  --from-literal=cluster-name=prod-us-east

Create the values file for each node

This release runs one Collector on each node.

values-squasher.yaml

mode: daemonset

image:
  repository: otel/opentelemetry-collector-k8s
  # Collector 0.144.0 introduced otlp_http and kept otlphttp as an alias.
  tag: 0.161.0

presets:
  logsCollection:
    enabled: true
  kubernetesAttributes:
    enabled: true
  kubeletMetrics:
    enabled: true

extraEnvs:
  - name: SQUASHER_API_KEY
    valueFrom:
      secretKeyRef:
        name: squasher
        key: api-key
  - name: K8S_CLUSTER_NAME
    valueFrom:
      secretKeyRef:
        name: squasher
        key: cluster-name

resources:
  requests:
    cpu: 100m
    memory: 128Mi
  limits:
    memory: 512Mi

config:
  processors:
    memory_limiter:
      check_interval: 5s
      limit_percentage: 80
      spike_limit_percentage: 25
    batch: {}
    resource/squasher:
      attributes:
        - { key: k8s.cluster.name, value: "${env:K8S_CLUSTER_NAME}", action: upsert }
        - { key: deployment.environment.name, value: production, action: insert }
  exporters:
    otlp_http/squasher:
      endpoint: https://ingest.squasher.ai
      compression: gzip
      headers:
        x-squasher-key: "${env:SQUASHER_API_KEY}"
  service:
    pipelines:
      logs:
        processors: [memory_limiter, resource/squasher, batch]
        exporters: [otlp_http/squasher]
      metrics:
        processors: [memory_limiter, resource/squasher, batch]
        exporters: [otlp_http/squasher]
      traces:
        processors: [memory_limiter, resource/squasher, batch]
        exporters: [otlp_http/squasher]

Install the chart

helm repo add open-telemetry https://open-telemetry.github.io/opentelemetry-helm-charts
helm repo update
helm install squasher-otel open-telemetry/opentelemetry-collector \
  --namespace monitoring -f values-squasher.yaml

Add cluster metrics and events (optional)

This second release runs exactly one replica, so that no series is sent twice. Use the same cluster name.

values-squasher-cluster.yaml

mode: deployment
replicaCount: 1

image:
  repository: otel/opentelemetry-collector-k8s

presets:
  clusterMetrics:
    enabled: true
  kubernetesEvents:
    enabled: true
  kubernetesAttributes:
    enabled: true

extraEnvs:
  - name: SQUASHER_API_KEY
    valueFrom:
      secretKeyRef:
        name: squasher
        key: api-key
  - name: K8S_CLUSTER_NAME
    valueFrom:
      secretKeyRef:
        name: squasher
        key: cluster-name

resources:
  requests:
    cpu: 50m
    memory: 128Mi
  limits:
    memory: 512Mi

config:
  processors:
    memory_limiter:
      check_interval: 5s
      limit_percentage: 80
      spike_limit_percentage: 25
    batch: {}
    resource/squasher:
      attributes:
        - { key: k8s.cluster.name, value: "${env:K8S_CLUSTER_NAME}", action: upsert }
        - { key: deployment.environment.name, value: production, action: insert }
  exporters:
    otlp_http/squasher:
      endpoint: https://ingest.squasher.ai
      compression: gzip
      headers:
        x-squasher-key: "${env:SQUASHER_API_KEY}"
  service:
    pipelines:
      logs:
        processors: [memory_limiter, resource/squasher, batch]
        exporters: [otlp_http/squasher]
      metrics:
        processors: [memory_limiter, resource/squasher, batch]
        exporters: [otlp_http/squasher]

helm install squasher-otel-cluster open-telemetry/opentelemetry-collector \
  --namespace monitoring -f values-squasher-cluster.yaml

Do not turn on cluster metrics in the first release, because every node then sends the same series.

Send app traces to the Collector

Point each app at the Collector on its own node:

deployment.yaml

env:
  - name: HOST_IP
    valueFrom:
      fieldRef:
        fieldPath: status.hostIP
  - name: OTEL_EXPORTER_OTLP_ENDPOINT
    value: "http://$(HOST_IP):4318"
  - name: OTEL_EXPORTER_OTLP_PROTOCOL
    value: http/protobuf
  - name: OTEL_SERVICE_NAME
    value: checkout-api

The Collector adds pod, namespace, and node attributes before it forwards the data.

What Squasher keeps

Data	Where it appears
Pod logs	Logs, with the pod, namespace, node, and container as attributes
Kubelet metrics	Infrastructure, Kubernetes tab: CPU and memory for each pod
`k8s.cluster.name`	The cluster name on the Kubernetes tab of Infrastructure
App spans and logs	Logs, Traces, and Issues

The Kubernetes tab also shows restarts from the k8s.container.restarts metric. The kubelet preset does not send it. The cluster release sends it, and it sends Kubernetes events.

Small footprint: Squasher Collector DaemonSet

If you need only CPU and memory, run the Squasher Collector as a DaemonSet instead. Each pod reads the kubelet Summary API of its own node through the API server proxy. It sends CPU usage and memory (usage, working_set, rss, available) for the node, each pod, and each container, with k8s.cluster.name, k8s.node.name, k8s.namespace.name, k8s.pod.name, k8s.pod.uid, and k8s.container.name. It also sends squasher.collector.scrape.up. It does not send logs, Kubernetes events, container restarts, workload owner names, or node network and filesystem metrics. For those, use the Helm chart above. Its service account needs get on nodes/proxy and nodes/stats.

Build an image

Squasher does not publish a container image. Put the Linux squasher-collector release binary for your node architecture in a directory, with this Dockerfile. It is the binary that the Linux install uses.

Dockerfile

FROM gcr.io/distroless/cc-debian12:nonroot
ARG BINARY=squasher-collector
COPY --chmod=0755 ${BINARY} /usr/local/bin/squasher-collector
USER 65532:65532
ENTRYPOINT ["/usr/local/bin/squasher-collector"]

docker build --build-arg BINARY=squasher-collector \
  -t registry.example.com/squasher-collector:0.1.1 .
docker push registry.example.com/squasher-collector:0.1.1

Store the key and the project ID as a secret

kubectl create namespace squasher
kubectl create secret generic squasher --namespace squasher \
  --from-literal=api-key="$SQUASHER_API_KEY" \
  --from-literal=project-id="$SQUASHER_PROJECT_ID"

Apply the DaemonSet

Set image to your image, and replace prod-us-east with the name of your cluster.

daemonset.yaml

apiVersion: v1
kind: ServiceAccount
metadata:
  name: squasher-collector
  namespace: squasher
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  name: squasher-collector
rules:
  # Read-only access to the kubelet Summary API through the API server proxy.
  - apiGroups: [""]
    resources: ["nodes/proxy", "nodes/stats"]
    verbs: ["get"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: squasher-collector
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: squasher-collector
subjects:
  - kind: ServiceAccount
    name: squasher-collector
    namespace: squasher
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: squasher-collector
  namespace: squasher
data:
  config.yaml: |
    receivers:
      kubelet_summary:
        collection_interval: 60s
        timeout: 10s
        node_name: "${env:K8S_NODE_NAME}"
        cluster_name: "${env:K8S_CLUSTER_NAME}"
    processors:
      batch: {}
      resource:
        attributes:
          - { key: service.name, value: "${env:SQUASHER_SERVICE_NAME}", action: upsert }
          - { key: deployment.environment.name, value: "${env:SQUASHER_ENVIRONMENT}", action: upsert }
          - { key: host.id, value: "${env:K8S_NODE_NAME}", action: upsert }
          - { key: host.name, value: "${env:K8S_NODE_NAME}", action: upsert }
          - { key: squasher.infrastructure.schema.version, value: "1", action: upsert }
    exporters:
      otlp_http/squasher:
        endpoint: "${env:SQUASHER_OTLP_ENDPOINT}"
        compression: gzip
        timeout: 10s
        headers:
          Authorization: "Bearer ${env:SQUASHER_API_KEY}"
          x-squasher-project-id: "${env:SQUASHER_PROJECT_ID}"
    service:
      pipelines:
        metrics:
          receivers: [kubelet_summary]
          processors: [resource, batch]
          exporters: [otlp_http/squasher]
---
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: squasher-collector
  namespace: squasher
  labels:
    app.kubernetes.io/name: squasher-collector
spec:
  selector:
    matchLabels:
      app.kubernetes.io/name: squasher-collector
  template:
    metadata:
      labels:
        app.kubernetes.io/name: squasher-collector
    spec:
      serviceAccountName: squasher-collector
      tolerations:
        - operator: Exists
      securityContext:
        runAsNonRoot: true
        runAsUser: 65532
        runAsGroup: 65532
        seccompProfile:
          type: RuntimeDefault
      containers:
        - name: collector
          image: registry.example.com/squasher-collector:0.1.1
          args: ["--config=file:/etc/squasher-collector/config.yaml"]
          env:
            - name: K8S_NODE_NAME
              valueFrom:
                fieldRef:
                  fieldPath: spec.nodeName
            - name: SQUASHER_COLLECTOR_ID
              valueFrom:
                fieldRef:
                  fieldPath: metadata.name
            - name: K8S_CLUSTER_NAME
              value: prod-us-east
            - name: SQUASHER_SERVICE_NAME
              value: prod-us-east
            - name: SQUASHER_ENVIRONMENT
              value: production
            - name: SQUASHER_COLLECTOR_TARGET
              value: kubernetes-daemonset
            - name: SQUASHER_OTLP_ENDPOINT
              value: https://ingest.squasher.ai
            - name: SQUASHER_API_KEY
              valueFrom:
                secretKeyRef:
                  name: squasher
                  key: api-key
            - name: SQUASHER_PROJECT_ID
              valueFrom:
                secretKeyRef:
                  name: squasher
                  key: project-id
          resources:
            requests:
              cpu: 10m
              memory: 16Mi
            limits:
              cpu: 100m
              memory: 64Mi
          securityContext:
            allowPrivilegeEscalation: false
            readOnlyRootFilesystem: true
            capabilities:
              drop: ["ALL"]
          volumeMounts:
            - name: config
              mountPath: /etc/squasher-collector
              readOnly: true
      volumes:
        - name: config
          configMap:
            name: squasher-collector

kubectl apply -f daemonset.yaml

Verify

Select Infrastructure in the sidebar in Squasher, then the Kubernetes tab. Your pods appear within a few collection intervals.
Send one span with ERROR status from an app, then select Issues in the sidebar.

Limits

Pod log lines have no level, so they create no issues. Send errors from your apps with OpenTelemetry or an SDK.
The Collector in this guide sends OTLP over HTTP. Squasher also accepts OTLP/gRPC at the Collector URL on port 443; see OpenTelemetry.

Get started

Guides

Prerequisites

Use the OpenTelemetry Collector Helm chart

Send app traces to the Collector

What Squasher keeps

Small footprint: Squasher Collector DaemonSet

Verify

Limits

Next steps

OpenTelemetry

Tail sampling

​Prerequisites

​Use the OpenTelemetry Collector Helm chart

​Send app traces to the Collector

​What Squasher keeps

​Small footprint: Squasher Collector DaemonSet

​Verify

​Limits

​Next steps

OpenTelemetry

Tail sampling

Prerequisites

Use the OpenTelemetry Collector Helm chart

Send app traces to the Collector

What Squasher keeps

Small footprint: Squasher Collector DaemonSet

Verify

Limits

Next steps