This is documentation for the next version of Grafana Alloy Documentation. For the latest stable release, go to the latest version.

Documentation Grafana Alloy Reference Components otelcol otelcol.connector.count

otelcol.connector.count

otelcol.connector.count accepts spans, span events, metrics, data points, and log records from other otelcol components and generates metrics that count the received telemetry data.

You can specify multiple otelcol.connector.count components by giving them different labels.

Usage

Alloy Copy

otelcol.connector.count "<LABEL>" {
  output {
    metrics = [...]
  }
}

Arguments

The otelcol.connector.count component doesn’t support any arguments. You can configure this component with blocks.

Blocks

You can use the following blocks with otelcol.connector.count:

The > symbol indicates deeper levels of nesting. For example, spans > attributes refers to an attributes block defined inside a spans block.

spans

The spans block configures a custom metric for counting spans.

You can specify multiple spans blocks to define different metrics.

If you don’t define any spans blocks, the connector emits a default metric named trace.span.count.

The conditions argument accepts a list of OTTL expressions that filter which spans to count. If any condition matches, the connector counts the span. If you don’t specify conditions, the connector counts all spans.

spanevents

The spanevents block configures a custom metric for counting span events.

You can specify multiple spanevents blocks to define different metrics.

If you don’t define any spanevents blocks, the connector emits a default metric named trace.span.event.count.

This block shares the same configuration structure as spans. Refer to the spans block documentation for the complete list of supported arguments and blocks.

metrics

The metrics block configures a custom metric for counting metrics.

You can specify multiple metrics blocks to define different metrics.

If you don’t define any metrics blocks, the connector emits a default metric named metric.count.

This block shares the same configuration structure as spans. Refer to the spans block documentation for the complete list of supported arguments and blocks.

datapoints

The datapoints block configures a custom metric for counting data points.

You can specify multiple datapoints blocks to define different metrics.

If you don’t define any datapoints blocks, the connector emits a default metric named metric.datapoint.count.

This block shares the same configuration structure as spans. Refer to the spans block documentation for the complete list of supported arguments and blocks.

logs

The logs block configures a custom metric for counting log records.

You can specify multiple logs blocks to define different metrics.

If you don’t define any logs blocks, the connector emits a default metric named log.record.count.

This block shares the same configuration structure as spans. Refer to the spans block documentation for the complete list of supported arguments and blocks.

attributes

The attributes block specifies an attribute to use for grouping counted telemetry data.

Each unique combination of attribute values generates a separate data point on the metric.

You can specify multiple attributes blocks within spans, spanevents, metrics, datapoints, or logs blocks to group by multiple attributes.

The following arguments are supported:

Attribute precedence: span/log/metric attributes > scope attributes > resource attributes.

output

debug_metrics

Exported fields

The following fields are exported and can be referenced by other components:

input accepts otelcol.Consumer data for traces, metrics, and logs.

he component counts all telemetry received through input according to the configured blocks and emits metrics to the components specified in output.

Component health

otelcol.connector.count is only reported as unhealthy if given an invalid configuration.

Debug information

otelcol.connector.count doesn’t expose any component-specific debug information.

Examples

Default configuration

Use the count connector with minimal configuration to count all telemetry data using default metric names.

Alloy Copy

otelcol.connector.count "default" {
  output {
    metrics = [otelcol.exporter.otlp.default.input]
  }
}

This configuration generates the following default metrics:

• trace.span.count - Count of all spans
• trace.span.event.count - Count of all span events
• metric.count - Count of all metrics
• metric.datapoint.count - Count of all data points
• log.record.count - Count of all log records

Custom metrics with conditions and attributes

Create custom count metrics with filtering conditions and group counts by specific attributes.

Alloy Copy

otelcol.connector.count "default" {
  // Count only HTTP GET spans
  spans {
    name        = "http_get_requests"
    description = "Number of HTTP GET requests"
    conditions  = [
      "attributes[\"http.method\"] == \"GET\"",
    ]
  }

  // Count spans grouped by service and environment
  spans {
    name        = "spans_by_service"
    description = "Spans per service and environment"
    attributes {
      key           = "service.name"
      default_value = "unknown"
    }
    attributes {
      key           = "env"
      default_value = "production"
    }
  }

  // Count error and fatal logs only
  logs {
    name        = "error_logs"
    description = "Error and fatal log records"
    conditions  = [
      "severity_number >= 17",
    ]
  }

  // Count logs by environment
  logs {
    name        = "logs_by_env"
    description = "Log records per environment"
    attributes {
      key = "env"
    }
  }

  output {
    metrics = [otelcol.exporter.otlp.default.input]
  }
}

Complete pipeline with Prometheus export

Count spans, logs, and metrics, then export to Prometheus using the delta to cumulative processor.

Alloy Copy

otelcol.receiver.otlp "default" {
  grpc {
    endpoint = "127.0.0.1:4317"
  }

  http {
    endpoint = "127.0.0.1:4318"
  }

  output {
    traces  = [otelcol.connector.count.default.input]
    metrics = [otelcol.connector.count.default.input]
    logs    = [otelcol.connector.count.default.input]
  }
}

otelcol.connector.count "default" {
  spans {
    name        = "traces_total"
    description = "Total number of spans received"
  }

  spans {
    name        = "http_get_spans"
    description = "HTTP GET requests"
    conditions  = [
      "attributes[\"http.method\"] == \"GET\"",
    ]
  }

  spans {
    name        = "spans_by_service"
    description = "Spans grouped by service"
    attributes {
      key           = "service.name"
      default_value = "unknown"
    }
  }

  logs {
    name        = "logs_total"
    description = "Total number of logs received"
  }

  logs {
    name        = "error_logs"
    description = "Error level logs"
    conditions  = [
      "severity_number >= 17",
    ]
  }

  metrics {
    name        = "metrics_total"
    description = "Total number of metrics received"
  }

  output {
    metrics = [otelcol.processor.deltatocumulative.default.input]
  }
}

// Convert delta metrics to cumulative for Prometheus compatibility
otelcol.processor.deltatocumulative "default" {
  output {
    metrics = [otelcol.exporter.prometheus.default.input]
  }
}

otelcol.exporter.prometheus "default" {
  forward_to                       = [prometheus.remote_write.default.receiver]
  add_metric_suffixes              = false
  resource_to_telemetry_conversion = true
}

prometheus.remote_write "default" {
  endpoint {
    url = "http://localhost:9090/api/v1/write"
  }
}

Technical details

otelcol.connector.count uses the count connector from OpenTelemetry Collector Contrib.

All generated metrics use the Sum data type with Delta aggregation temporality.

Compatible components

otelcol.connector.count can accept arguments from the following components:

• Components that export OpenTelemetry otelcol.Consumer

otelcol.connector.count has exports that can be consumed by the following components:

• Components that consume OpenTelemetry otelcol.Consumer