SigNoz/signoz · error · ResourceLimitError

resource bytes limit exceeded, try applying filters such as

Error message

resource bytes limit exceeded, try applying filters such as service.name, etc. to reduce the data size

What it means

A ClickHouse resource guard in SigNoz wraps ErrResourceBytesLimitExceeded: the query exceeded the allowed number of bytes read/scanned. The error suggests adding filters because unbounded scans over huge tables (signoz_traces / signoz_metrics) are the usual cause.

Source

Thrown at pkg/query-service/errors/clickhouse.go:7

package errors

import "errors"

var (
	// ErrResourceBytesLimitExceeded is returned when the resource bytes limit is exceeded
	ErrResourceBytesLimitExceeded = NewResourceLimitError(errors.New("resource bytes limit exceeded, try applying filters such as service.name, etc. to reduce the data size"))
	// ErrResourceTimeLimitExceeded is returned when the resource time limit is exceeded
	ErrResourceTimeLimitExceeded = NewResourceLimitError(errors.New("resource time limit exceeded, try applying filters such as service.name, etc. to reduce the data size"))
)

type ResourceLimitError struct {
	err error
}

func NewResourceLimitError(err error) error {
	return &ResourceLimitError{err: err}
}

func (e *ResourceLimitError) Error() string {
	return e.err.Error()
}

func (e *ResourceLimitError) Unwrap() error {
	return e.err

View on GitHub (pinned to 5069bf80b0)

Solutions

Add selective filters, primarily service.name, then operation name, and tighten the time range
Check/raise the ClickHouse max_bytes_to_scan or SigNoz resource limit setting if the query legitimately needs the scan
Pre-aggregate or use shorter time windows for large-range queries

Example fix

// before
GET /api/v1/traces?start=...&end=...
// after
GET /api/v1/traces?start=...&end=...&service.name=frontend&operation=HTTP%20POST%20/api

Defensive patterns

Strategy: fallback

Validate before calling

if service == "" {
    return errors.New("service.name filter required for this query")
}
resp, err := api.SearchTraces(ctx, filters.WithService(service).WithTimeRange(window))

Type guard

func IsResourceBytesLimit(err error) bool {
    var rle *errors.ResourceLimitError
    return errors.As(err, &rle) && errors.Is(err, errors.ErrResourceBytesLimitExceeded)
}

Try / catch

if err != nil {
    if IsResourceBytesLimit(err) {
        // degrade gracefully: shorter window or required filters
        return runReducedQuery(window/4)
    }
    return err
}

Prevention

Require service.name on wide search APIs by convention
Keep dashboards scoped to a service and bounded time range
Track bytes-scanned trends in system.query_log to catch growth early

When it happens

Trigger: Running a trace or metrics query without service.name or time filters over a large dataset, e.g. listing all spans cluster-wide, or search queries with very broad filter combinations that scan tens of GB.

Common situations: Default dashboards querying without service filters on high-volume clusters; exploratory searches in the traces UI with only wildcards; after traffic spikes that push table sizes past the configured byte limit.

Related errors

AI-assisted analysis of SigNoz/signoz@5069bf80b0 (2026-08-28). Data as JSON: /api/errors/f71d3936e8fff1e3. Report an issue: GitHub.