@intentius/chant-lexicon-otel 0.97.0 → 0.99.0

package/src/import/testdata/fixtures.ts

@@ -0,0 +1,274 @@
+/**
+ * Fixtures shared by the import round-trip tests (roundtrip.test.ts) and the
+ * type-check of the generated source (generated-types.e2e.test.ts).
+ */
+import { readdirSync, readFileSync, statSync } from "fs";
+import { join, resolve } from "path";
+import { build } from "@intentius/chant/build";
+import type { SerializerResult } from "@intentius/chant/serializer";
+import type { Declarable } from "@intentius/chant/declarable";
+import { otelSerializer } from "../../serializer";
+import { Pipeline, Service } from "../../pipeline";
+import * as c from "../../components";
+
+export const pkgDir = resolve(import.meta.dirname, "../../..");
+export const repoRoot = resolve(pkgDir, "../..");
+export const read = (...p: string[]) => readFileSync(join(import.meta.dirname, ...p), "utf-8");
+
+export function primary(out: string | SerializerResult | undefined): string {
+  if (out === undefined) return "";
+  return typeof out === "string" ? out : out.primary;
+}
+
+/** Each otel example's `chant build` output. */
+export async function exampleOutputs(): Promise<Array<[string, string]>> {
+  const examplesDir = join(pkgDir, "examples");
+  const out: Array<[string, string]> = [];
+  for (const name of readdirSync(examplesDir).sort()) {
+    const srcDir = join(examplesDir, name, "src");
+    try {
+      if (!statSync(srcDir).isDirectory()) continue;
+    } catch {
+      continue;
+    }
+    const result = await build(srcDir, [otelSerializer]);
+    if (result.errors.length > 0) throw new Error(`${name}: ${result.errors.map(String).join("; ")}`);
+    out.push([name, primary(result.outputs.get("otel"))]);
+  }
+  return out;
+}
+
+export const UPSTREAM_BUILTIN_ONLY = [
+  "kubernetes-filelog.yaml",
+  "logline-filter-in.yaml",
+  "logline-filter-out.yaml",
+  "secure-tracing.yaml",
+  "loadbalancing-backend.yaml",
+];
+
+/** One instance of every built-in, each using its typed fields, wired into pipelines the connectors accept. */
+export function everyBuiltin(): Declarable[] {
+  const otlp = new c.OtlpReceiver({
+    protocols: {
+      grpc: { endpoint: "0.0.0.0:4317", max_recv_msg_size_mib: 16, keepalive: { server_parameters: { time: "30s" } } },
+      http: { endpoint: "0.0.0.0:4318", cors: { allowed_origins: ["https://*.example.com"] }, traces_url_path: "/v1/traces" },
+    },
+  });
+  const prometheusIn = new c.PrometheusReceiver({
+    name: "self",
+    config: {
+      global: { scrape_interval: "30s" },
+      scrape_configs: [{ job_name: "collector", scrape_interval: "10s", static_configs: [{ targets: ["localhost:8888"], labels: { tier: "gw" } }] }],
+    },
+    trim_metric_suffixes: true,
+  });
+  const hostmetrics = new c.HostMetricsReceiver({
+    collection_interval: "30s",
+    root_path: "/hostfs",
+    scrapers: { cpu: {}, memory: {}, filesystem: { exclude_mount_points: { match_type: "regexp", mount_points: ["/dev/.*"] } } },
+  });
+  const filelog = new c.FileLogReceiver({
+    include: ["/var/log/pods/*/*/*.log"],
+    exclude: ["/var/log/pods/*/otel-collector/*.log"],
+    start_at: "end",
+    include_file_path: true,
+    storage: "file_storage",
+    operators: [{ type: "container", id: "container-parser" }],
+    retry_on_failure: { enabled: true, initial_interval: "1s" },
+  });
+  const cluster = new c.K8sClusterReceiver({
+    auth_type: "serviceAccount",
+    collection_interval: "30s",
+    node_conditions_to_report: ["Ready", "MemoryPressure"],
+    allocatable_types_to_report: ["cpu", "memory"],
+    metrics: { "k8s.pod.phase": { enabled: false } },
+  });
+  const kubelet = new c.KubeletStatsReceiver({
+    auth_type: "serviceAccount",
+    endpoint: "https://${env:K8S_NODE_NAME}:10250",
+    insecure_skip_verify: true,
+    metric_groups: ["node", "pod", "container"],
+    extra_metadata_labels: ["container.id"],
+  });
+
+  const batch = new c.BatchProcessor({ timeout: "5s", send_batch_size: 1024, send_batch_max_size: 2048, metadata_keys: ["tenant"] });
+  const memoryLimiter = new c.MemoryLimiterProcessor({ check_interval: "1s", limit_mib: 1024, spike_limit_mib: 256 });
+  const resource = new c.ResourceProcessor({
+    attributes: [
+      { key: "deployment.environment", value: "${env:DEPLOY_ENV}", action: "upsert" },
+      { key: "host.id", action: "delete" },
+    ],
+  });
+  const attributes = new c.AttributesProcessor({
+    name: "scrub",
+    actions: [
+      { key: "user.email", action: "hash" },
+      { key: "http.status_code", action: "convert", converted_type: "int" },
+    ],
+    include: { match_type: "strict", services: ["checkout"] },
+  });
+  const k8sattributes = new c.K8sAttributesProcessor({
+    auth_type: "serviceAccount",
+    passthrough: false,
+    filter: { node_from_env_var: "K8S_NODE_NAME" },
+    extract: { metadata: ["k8s.pod.name", "k8s.namespace.name"], labels: [{ tag_name: "app", key: "app.kubernetes.io/name", from: "pod" }] },
+    pod_association: [{ sources: [{ from: "resource_attribute", name: "k8s.pod.ip" }] }, { sources: [{ from: "connection" }] }],
+  });
+  const resourcedetection = new c.ResourceDetectionProcessor({
+    detectors: ["env", "system", "gcp"],
+    timeout: "2s",
+    override: false,
+    system: { hostname_sources: ["os"] },
+  });
+  const filter = new c.FilterProcessor({
+    name: "health",
+    error_mode: "ignore",
+    traces: { span: ['attributes["http.route"] == "/healthz"'] },
+    metrics: { datapoint: ['metric.name == "up" and value_int == 1'] },
+    logs: { log_record: ["severity_number < SEVERITY_NUMBER_INFO"] },
+  });
+  const transform = new c.TransformProcessor({
+    error_mode: "ignore",
+    trace_statements: [{ context: "span", conditions: ["kind == SPAN_KIND_SERVER"], statements: ['set(attributes["tier"], "edge")'] }],
+    metric_statements: ['delete_key(datapoint.attributes, "pod_ip")'],
+    log_statements: [{ context: "log", statements: ['set(severity_text, "WARN") where severity_number == 13'] }],
+  });
+  const redaction = new c.RedactionProcessor({
+    allow_all_keys: true,
+    blocked_key_patterns: ["^gen_ai\\.(prompt|completion)"],
+    blocked_values: ["4[0-9]{12}(?:[0-9]{3})?"],
+    hash_function: "sha3",
+    summary: "silent",
+  });
+  const tailSampling = new c.TailSamplingProcessor({
+    decision_wait: "10s",
+    num_traces: 50000,
+    sample_on_first_match: true,
+    policies: [
+      { name: "errors", type: "status_code", status_code: { status_codes: ["ERROR"] } },
+      { name: "slow", type: "latency", latency: { threshold_ms: 1000, upper_threshold_ms: 60000 } },
+      { name: "vip", type: "boolean_attribute", boolean_attribute: { key: "vip", value: true } },
+      { name: "sized", type: "span_count", span_count: { min_spans: 2, max_spans: 500 } },
+      { name: "both", type: "and", and: { and_sub_policy: [{ name: "a", type: "rate_limiting", rate_limiting: { spans_per_second: 100 } }, { name: "b", type: "always_sample" }] } },
+      { name: "rest", type: "probabilistic", probabilistic: { sampling_percentage: 5, hash_salt: "s" } },
+    ],
+  });
+  const probabilistic = new c.ProbabilisticSamplerProcessor({ sampling_percentage: 12.5, mode: "proportional", sampling_precision: 4 });
+
+  const otlpOut = new c.OtlpExporter({
+    name: "backend",
+    endpoint: "backend:4317",
+    compression: "zstd",
+    headers: { "x-api-key": "${env:BACKEND_KEY}" },
+    tls: { insecure: false, ca_file: "/etc/ca.pem", min_version: "1.3" },
+    balancer_name: "round_robin",
+    timeout: "10s",
+    retry_on_failure: { enabled: true, max_elapsed_time: "2m" },
+    sending_queue: { enabled: true, num_consumers: 4, queue_size: 2000, sizer: "requests" },
+  });
+  const otlphttp = new c.OtlpHttpExporter({ endpoint: "https://otlp.example.com", encoding: "json", logs_endpoint: "https://logs.example.com/v1/logs" });
+  const debug = new c.DebugExporter({ verbosity: "detailed", sampling_initial: 5, sampling_thereafter: 200 });
+  const prometheusOut = new c.PrometheusExporter({
+    endpoint: "0.0.0.0:8889",
+    namespace: "otel",
+    const_labels: { cluster: "prod" },
+    metric_expiration: "5m",
+    resource_to_telemetry_conversion: { enabled: true },
+  });
+  const googlecloud = new c.GoogleCloudExporter({
+    project: "my-project",
+    metric: { prefix: "custom.googleapis.com", resource_filters: [{ prefix: "k8s." }] },
+    trace: { attribute_mappings: [{ key: "http.route", replacement: "/http/route" }] },
+    log: { default_log_name: "otel" },
+  });
+  const loadbalancing = new c.LoadBalancingExporter({
+    routing_key: "service",
+    protocol: { otlp: { timeout: "1s", tls: { insecure: true } } },
+    resolver: { k8s: { service: "sampling.observability", ports: [4317], return_hostnames: true } },
+  });
+
+  const spanmetrics = new c.SpanMetricsConnector({
+    namespace: "span.metrics",
+    dimensions: [{ name: "http.route" }, { name: "env", default: "dev" }],
+    histogram: { unit: "s", exponential: { max_size: 160 } },
+    exemplars: { enabled: true, max_per_data_point: 5 },
+    metrics_flush_interval: "15s",
+    aggregation_temporality: "AGGREGATION_TEMPORALITY_DELTA",
+  });
+  const servicegraph = new c.ServiceGraphConnector({
+    latency_histogram_buckets: ["10ms", "100ms", "1s"],
+    dimensions: ["k8s.cluster.name"],
+    store: { ttl: "2s", max_items: 1000 },
+    virtual_node_peer_attributes: ["db.name"],
+  });
+  const routing = new c.RoutingConnector({
+    table: [{ context: "resource", condition: 'attributes["tenant"] == "acme"', pipelines: ["traces/acme"] }],
+    default_pipelines: ["traces/rest"],
+    error_mode: "ignore",
+  });
+  const forward = new c.ForwardConnector({});
+  const count = new c.CountConnector({
+    spans: { "span.count": { description: "Spans by service", attributes: [{ key: "service.name", default_value: "unknown" }] } },
+  });
+  const sum = new c.SumConnector({
+    spans: { "span.bytes": { source_attribute: "bytes", description: "Bytes by route", conditions: ['attributes["bytes"] != nil'] } },
+  });
+
+  const health = new c.HealthCheckExtension({ endpoint: "0.0.0.0:13133", path: "/health", response_body: { healthy: "ok" } });
+  const pprof = new c.PprofExtension({ endpoint: "localhost:1777", block_profile_fraction: 3 });
+  const zpages = new c.ZPagesExtension({ endpoint: "localhost:55679" });
+
+  return [
+    otlp,
+    prometheusIn,
+    hostmetrics,
+    filelog,
+    cluster,
+    kubelet,
+    batch,
+    memoryLimiter,
+    resource,
+    attributes,
+    k8sattributes,
+    resourcedetection,
+    filter,
+    transform,
+    redaction,
+    tailSampling,
+    probabilistic,
+    otlpOut,
+    otlphttp,
+    debug,
+    prometheusOut,
+    googlecloud,
+    loadbalancing,
+    spanmetrics,
+    servicegraph,
+    routing,
+    forward,
+    count,
+    sum,
+    health,
+    pprof,
+    zpages,
+    new Pipeline({
+      signal: "traces",
+      receivers: [otlp],
+      processors: [memoryLimiter, k8sattributes, resourcedetection, resource, attributes, filter, transform, redaction, probabilistic],
+      exporters: [spanmetrics, servicegraph, count, sum, forward, routing, loadbalancing],
+    }),
+    new Pipeline({ signal: "traces", name: "acme", receivers: [routing], processors: [tailSampling, batch], exporters: [otlpOut] }),
+    new Pipeline({ signal: "traces", name: "rest", receivers: [routing, forward], processors: [batch], exporters: [googlecloud, debug] }),
+    new Pipeline({
+      signal: "metrics",
+      receivers: [otlp, prometheusIn, hostmetrics, cluster, kubelet, spanmetrics, servicegraph, count, sum],
+      processors: [memoryLimiter, filter, batch],
+      exporters: [prometheusOut, otlphttp],
+    }),
+    new Pipeline({ signal: "logs", receivers: [otlp, filelog], processors: [memoryLimiter, redaction, batch], exporters: [otlphttp, debug] }),
+    new Service({
+      extensions: [health, zpages, pprof],
+      telemetry: { logs: { level: "warn", encoding: "json" }, metrics: { level: "normal" }, resource: { "service.name": "gw" } },
+    }),
+  ];
+}

package/src/import/testdata/gateway.yaml

@@ -0,0 +1,153 @@
+# A two-tier trace gateway in one file. The front tier spreads spans across
+# the sampling tier by trace id with the loadbalancing exporter; the sampling
+# tier keeps whole traces with tail_sampling and derives RED metrics from
+# every span with spanmetrics before sampling drops any.
+
+receivers:
+  otlp:
+    protocols:
+      grpc:
+        endpoint: 0.0.0.0:4317
+      http:
+        endpoint: 0.0.0.0:4318
+  otlp/sampling:
+    protocols:
+      grpc:
+        endpoint: 0.0.0.0:14317
+
+processors:
+  memory_limiter:
+    check_interval: 1s
+    limit_percentage: 75
+    spike_limit_percentage: 15
+  batch:
+    timeout: 5s
+    send_batch_size: 8192
+  tail_sampling:
+    decision_wait: 10s
+    num_traces: 100000
+    expected_new_traces_per_sec: 2000
+    decision_cache:
+      sampled_cache_size: 100000
+    policies:
+      - name: errors
+        type: status_code
+        status_code:
+          status_codes: [ERROR]
+      - name: slow
+        type: latency
+        latency:
+          threshold_ms: 1500
+      - name: checkout
+        type: string_attribute
+        string_attribute:
+          key: service.name
+          values: [checkout, payments]
+      - name: noisy-health
+        type: drop
+        drop:
+          drop_sub_policy:
+            - name: health-route
+              type: string_attribute
+              string_attribute:
+                key: http.route
+                values: [/healthz, /readyz]
+      - name: budget
+        type: composite
+        composite:
+          max_total_spans_per_second: 1000
+          policy_order: [errors-first, rest]
+          composite_sub_policy:
+            - name: errors-first
+              type: status_code
+              status_code:
+                status_codes: [ERROR]
+            - name: rest
+              type: always_sample
+          rate_allocation:
+            - policy: errors-first
+              percent: 60
+            - policy: rest
+              percent: 40
+
+exporters:
+  loadbalancing:
+    routing_key: traceID
+    protocol:
+      otlp:
+        timeout: 2s
+        tls:
+          insecure: true
+    resolver:
+      dns:
+        hostname: otel-sampling-headless.observability.svc.cluster.local
+        port: "14317"
+  otlp/tempo:
+    endpoint: tempo.observability:4317
+    headers:
+      authorization: "Bearer ${env:TEMPO_TOKEN}"
+    tls:
+      insecure: false
+      ca_file: /etc/tls/ca.pem
+    sending_queue:
+      enabled: true
+      queue_size: 10000
+    retry_on_failure:
+      enabled: true
+      max_elapsed_time: 5m
+  prometheus:
+    endpoint: "0.0.0.0:8889"
+    namespace: gateway
+    resource_to_telemetry_conversion:
+      enabled: true
+
+connectors:
+  spanmetrics:
+    namespace: traces.span.metrics
+    dimensions:
+      - name: http.route
+      - name: deployment.environment
+        default: "${env:DEPLOY_ENV}"
+    histogram:
+      explicit:
+        buckets: [10ms, 50ms, 100ms, 250ms, 1s, 5s]
+    exemplars:
+      enabled: true
+    metrics_flush_interval: 15s
+
+extensions:
+  health_check:
+    endpoint: 0.0.0.0:13133
+  pprof:
+    endpoint: localhost:1777
+  zpages: {}
+
+service:
+  extensions: [zpages, health_check]
+  telemetry:
+    logs:
+      level: info
+      encoding: json
+    metrics:
+      level: detailed
+      readers:
+        - pull:
+            exporter:
+              prometheus:
+                host: 0.0.0.0
+                port: 8888
+    resource:
+      service.name: otel-gateway
+  pipelines:
+    traces:
+      receivers: [otlp]
+      processors: [memory_limiter]
+      exporters: [loadbalancing]
+    traces/sampling:
+      receivers: [otlp/sampling]
+      processors: [memory_limiter, tail_sampling, batch]
+      exporters: [otlp/tempo, spanmetrics]
+    metrics/red:
+      receivers: [spanmetrics]
+      processors: [batch]
+      exporters: [prometheus]

package/src/import/testdata/upstream/couchbase.yaml

@@ -0,0 +1,150 @@
+# Vendored from opentelemetry-collector-contrib v0.130.0 (Apache-2.0), unchanged below this header:
+# https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/v0.130.0/examples/couchbase/otel-collector-config.yaml
+
+receivers:
+  prometheus/couchbase:
+    config:
+      scrape_configs:
+        - job_name: 'couchbase'
+          scrape_interval: 5s
+          static_configs:
+            - targets: ['couchbase:8091']
+          basic_auth:
+            username: 'otelu'
+            password: 'otelpassword'
+          metric_relabel_configs:
+            # Include only a few key metrics
+            - source_labels: [ __name__ ]
+              regex: "(kv_ops)|\
+                (kv_vb_curr_items)|\
+                (kv_num_vbuckets)|\
+                (kv_ep_cursor_memory_freed_bytes)|\
+                (kv_total_memory_used_bytes)|\
+                (kv_ep_num_value_ejects)|\
+                (kv_ep_mem_high_wat)|\
+                (kv_ep_mem_low_wat)|\
+                (kv_ep_tmp_oom_errors)|\
+                (kv_ep_oom_errors)"
+              action: keep
+
+processors:
+  filter/couchbase:
+    # Filter out prometheus scraping meta-metrics.
+    metrics:
+      exclude:
+        match_type: strict
+        metric_names:
+          - scrape_samples_post_metric_relabeling
+          - scrape_series_added
+          - scrape_duration_seconds
+          - scrape_samples_scraped
+          - up
+
+  metricstransform/couchbase:
+    transforms:
+      # Rename from prometheus metric name to OTel metric name.
+      # We cannot do this with metric_relabel_configs, as the prometheus receiver does not
+      # allow metric renames at this time.
+      - include: kv_ops
+        match_type: strict
+        action: update
+        new_name: "couchbase.bucket.operation.count"
+      - include: kv_vb_curr_items
+        match_type: strict
+        action: update
+        new_name: "couchbase.bucket.item.count"
+      - include: kv_num_vbuckets
+        match_type: strict
+        action: update
+        new_name: "couchbase.bucket.vbucket.count"
+      - include: kv_ep_cursor_memory_freed_bytes
+        match_type: strict
+        action: update
+        new_name: "couchbase.bucket.memory.usage.free"
+      - include: kv_total_memory_used_bytes
+        match_type: strict
+        action: update
+        new_name: "couchbase.bucket.memory.usage.used"
+      - include: kv_ep_num_value_ejects
+        match_type: strict
+        action: update
+        new_name: "couchbase.bucket.item.ejection.count"
+      - include: kv_ep_mem_high_wat
+        match_type: strict
+        action: update
+        new_name: "couchbase.bucket.memory.high_water_mark.limit"
+      - include: kv_ep_mem_low_wat
+        match_type: strict
+        action: update
+        new_name: "couchbase.bucket.memory.low_water_mark.limit"
+      - include: kv_ep_tmp_oom_errors
+        match_type: strict
+        action: update
+        new_name: "couchbase.bucket.error.oom.count.recoverable"
+      - include: kv_ep_oom_errors
+        match_type: strict
+        action: update
+        new_name: "couchbase.bucket.error.oom.count.unrecoverable"
+      # Combine couchbase.bucket.error.oom.count.x and couchbase.bucket.memory.usage.x
+      # metrics.
+      - include: '^couchbase\.bucket\.error\.oom\.count\.(?P<error_type>unrecoverable|recoverable)$$'
+        match_type: regexp
+        action: combine
+        new_name: "couchbase.bucket.error.oom.count"
+      - include: '^couchbase\.bucket\.memory\.usage\.(?P<state>free|used)$$'
+        match_type: regexp
+        action: combine
+        new_name: "couchbase.bucket.memory.usage"
+      # Aggregate "result" label on operation count to keep label sets consistent across the metric datapoints
+      - include: 'couchbase.bucket.operation.count'
+        match_type: strict
+        action: update
+        operations:
+          - action: aggregate_labels
+            label_set: ["bucket", "op"]
+            aggregation_type: sum
+
+  transform/couchbase:
+    metric_statements:
+    - context: datapoint
+      statements:
+        - convert_gauge_to_sum("cumulative", true) where metric.name == "couchbase.bucket.operation.count"
+        - set(metric.description, "Number of operations on the bucket.") where metric.name == "couchbase.bucket.operation.count"
+        - set(metric.unit, "{operations}") where metric.name == "couchbase.bucket.operation.count"
+
+        - convert_gauge_to_sum("cumulative", false) where metric.name == "couchbase.bucket.item.count"
+        - set(metric.description, "Number of items that belong to the bucket.") where metric.name == "couchbase.bucket.item.count"
+        - set(metric.unit, "{items}") where metric.name == "couchbase.bucket.item.count"
+
+        - convert_gauge_to_sum("cumulative", false) where metric.name == "couchbase.bucket.vbucket.count"
+        - set(metric.description, "Number of non-resident vBuckets.") where metric.name == "couchbase.bucket.vbucket.count"
+        - set(metric.unit, "{vbuckets}") where metric.name == "couchbase.bucket.vbucket.count"
+
+        - convert_gauge_to_sum("cumulative", false) where metric.name == "couchbase.bucket.memory.usage"
+        - set(metric.description, "Usage of total memory available to the bucket.") where metric.name == "couchbase.bucket.memory.usage"
+        - set(metric.unit, "By") where metric.name == "couchbase.bucket.memory.usage"
+
+        - convert_gauge_to_sum("cumulative", true) where metric.name == "couchbase.bucket.item.ejection.count"
+        - set(metric.description, "Number of item value ejections from memory to disk.") where metric.name == "couchbase.bucket.item.ejection.count"
+        - set(metric.unit, "{ejections}") where metric.name == "couchbase.bucket.item.ejection.count"
+
+        - convert_gauge_to_sum("cumulative", true) where metric.name == "couchbase.bucket.error.oom.count"
+        - set(metric.description, "Number of out of memory errors.") where metric.name == "couchbase.bucket.error.oom.count"
+        - set(metric.unit, "{errors}") where metric.name == "couchbase.bucket.error.oom.count"
+
+        - set(metric.description, "The memory usage at which items will be ejected.") where metric.name == "couchbase.bucket.memory.high_water_mark.limit"
+        - set(metric.unit, "By") where metric.name == "couchbase.bucket.memory.high_water_mark.limit"
+
+        - set(metric.description, "The memory usage at which ejections will stop that were previously triggered by a high water mark breach.") where metric.name == "couchbase.bucket.memory.low_water_mark.limit"
+        - set(metric.unit, "By") where metric.name == "couchbase.bucket.memory.low_water_mark.limit"
+
+exporters:
+  prometheus:
+    endpoint: "0.0.0.0:9123"
+
+service:
+  pipelines:
+    metrics/couchbase:
+      receivers: [prometheus/couchbase]
+      processors: [filter/couchbase, metricstransform/couchbase, transform/couchbase]
+      exporters: [prometheus]

package/src/import/testdata/upstream/fault-tolerant-logs.yaml

@@ -0,0 +1,27 @@
+# Vendored from opentelemetry-collector-contrib v0.130.0 (Apache-2.0), unchanged below this header:
+# https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/v0.130.0/examples/fault-tolerant-logs-collection/otel-col-config.yaml
+
+receivers:
+  filelog:
+    include: [/var/log/busybox/simple.log]
+    storage: file_storage/filelogreceiver
+
+extensions:
+  file_storage/filelogreceiver:
+    directory: /var/lib/otelcol/file_storage/receiver
+  file_storage/otlpoutput:
+    directory: /var/lib/otelcol/file_storage/output
+
+service:
+  extensions: [file_storage/filelogreceiver, file_storage/otlpoutput]
+  pipelines:
+    logs:
+      receivers: [filelog]
+      exporters: [otlp/custom]
+      processors: []
+
+exporters:
+  otlp/custom:
+    endpoint: http://0.0.0.0:4242
+    sending_queue:
+      storage: file_storage/otlpoutput

package/src/import/testdata/upstream/kubernetes-filelog.yaml

@@ -0,0 +1,86 @@
+# Vendored from opentelemetry-collector-contrib v0.130.0 (Apache-2.0), unchanged below this header:
+# https://github.com/open-telemetry/opentelemetry-collector-contrib/blob/v0.130.0/examples/kubernetes/otel-collector-config.yml
+
+receivers:
+  filelog:
+    include:
+      - /var/log/pods/*/*/*.log
+    exclude:
+      # Exclude logs from all containers named otel-collector
+      - /var/log/pods/*/otel-collector/*.log
+    start_at: end
+    include_file_path: true
+    include_file_name: false
+    operators:
+      # Find out which format is used by kubernetes
+      - type: router
+        id: get-format
+        routes:
+          - output: parser-docker
+            expr: 'body matches "^\\{"'
+          - output: parser-crio
+            expr: 'body matches "^[^ Z]+ "'
+          - output: parser-containerd
+            expr: 'body matches "^[^ Z]+Z"'
+      # Parse CRI-O format
+      - type: regex_parser
+        id: parser-crio
+        regex: '^(?P<time>[^ Z]+) (?P<stream>stdout|stderr) (?P<logtag>[^ ]*) ?(?P<log>.*)$'
+        output: extract_metadata_from_filepath
+        timestamp:
+          parse_from: attributes.time
+          layout_type: gotime
+          layout: '2006-01-02T15:04:05.999999999Z07:00'
+      # Parse CRI-Containerd format
+      - type: regex_parser
+        id: parser-containerd
+        regex: '^(?P<time>[^ ^Z]+Z) (?P<stream>stdout|stderr) (?P<logtag>[^ ]*) ?(?P<log>.*)$'
+        output: extract_metadata_from_filepath
+        timestamp:
+          parse_from: attributes.time
+          layout: '%Y-%m-%dT%H:%M:%S.%LZ'
+      # Parse Docker format
+      - type: json_parser
+        id: parser-docker
+        output: extract_metadata_from_filepath
+        timestamp:
+          parse_from: attributes.time
+          layout: '%Y-%m-%dT%H:%M:%S.%LZ'
+      # Extract metadata from file path
+      - type: regex_parser
+        id: extract_metadata_from_filepath
+        regex: '^.*\/(?P<namespace>[^_]+)_(?P<pod_name>[^_]+)_(?P<uid>[a-f0-9\-]{36})\/(?P<container_name>[^\._]+)\/(?P<restart_count>\d+)\.log$'
+        parse_from: attributes["log.file.path"]
+        cache:
+          size: 128  # default maximum amount of Pods per Node is 110
+      # Update body field after finishing all parsing
+      - type: move
+        from: attributes.log
+        to: body
+      # Rename attributes
+      - type: move
+        from: attributes.stream
+        to: attributes["log.iostream"]
+      - type: move
+        from: attributes.container_name
+        to: resource["k8s.container.name"]
+      - type: move
+        from: attributes.namespace
+        to: resource["k8s.namespace.name"]
+      - type: move
+        from: attributes.pod_name
+        to: resource["k8s.pod.name"]
+      - type: move
+        from: attributes.restart_count
+        to: resource["k8s.container.restart_count"]
+      - type: move
+        from: attributes.uid
+        to: resource["k8s.pod.uid"]
+exporters:
+  debug:
+    verbosity: detailed
+service:
+  pipelines:
+    logs:
+      receivers: [filelog]
+      exporters: [debug]