OpenTelemetry Exponential Histogram Dynamic Compaction and Bucket Scale Invariant

Q: How does adopting this rule prevent AI hallucinations?

This rule explicitly declares what the AI must avoid (Unbounded Explicit Buckets or Unconstrained Exponential Histogram Scales Causing Memory Exhaustion) and prescribes verified positive examples. Grounding the LLM with negative and positive pairs eliminates guesswork.

Q: Which AI coding environments are supported?

This specification is multi-platform compatible: Cursor (.cursor/rules/*.mdc & .cursorrules), Anthropic Claude Code (CLAUDE.md), Windsurf (.windsurfrules), Codex / Cline (AGENTS.md), and GitHub Copilot (.github/copilot-instructions.md).

Q: Can I combine this rule with other technology stacks?

Yes. Use the Interactive Stack Builder or download an Agent Pack to merge this rule with other frontend, backend, database, security, and DevOps rules without syntax collision.

OpenTelemetry Exponential Histogram Dynamic Compaction and Bucket Scale Invariant

--- description: OpenTelemetry Exponential Histogram Dynamic Compaction and Bucket Scale Invariant - Enforces strict upper bounds on memory allocation for OpenTelemetry metrics streams by mandating exponential histograms with dynamic scale reduction and explicit maxBucket limits. Guarantees that SDK clients and OpenTelemetry Collectors automatically downscale bucket resolution (scale compaction) during high-dynamic-range metric spikes, preventing Out-Of-Memory (OOM) termination and collector buffer saturation. globs: src/**/telemetry.{ts,js,py,go}, src/**/metrics.{ts,js,py,go}, **/otel-collector*.{yaml,yml}, config/otel*.{yaml,yml} alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/otel-exponential-histograms-dynamic-compaction-invariant" --- # OpenTelemetry Exponential Histogram Dynamic Compaction and Bucket Scale Invariant > **Severity**: CRITICAL | **Category**: devops > **Anti-Pattern Warning**: Unbounded Explicit Buckets or Unconstrained Exponential Histogram Scales Causing Memory Exhaustion ## System Constraints You are a Principal Observability and Infrastructure Architect enforcing OpenTelemetry Metric Aggregation Standards. You must enforce dynamic scale compaction on exponential histograms to constrain heap growth under extreme dynamic range and cardinality metric spikes. Reject any unbounded explicit bucket histograms or exponential configurations lacking explicit maxBuckets constraints. ## Strict Guidelines - Engineers MUST ALWAYS configure `Aggregation.ExponentialHistogram` with an explicit `maxBuckets` threshold (defaulting between 160 and 320) across all high-throughput latency and duration instruments. - Engineers MUST NOT use unconstrained explicit boundary arrays for metrics with multi-order-of-magnitude dynamic ranges (e.g., latencies ranging from sub-millisecond to hours). - SDK configurations MUST enforce a `maxScale` limit (typically <= 20) to prevent exponential allocations from attempting hyper-fine resolution on micro-variations. - Services MUST enable dynamic downscaling compaction algorithms in the SDK, guaranteeing automatic decrement of `scale` whenever unique bucket index boundaries exceed `maxBuckets`. - OpenTelemetry Collector pipeline definitions MUST incorporate `memory_limiter` processors placed upstream of metric batching, and verify downstream exporters accept base-2 exponential histogram protobuf representations. ## Bad vs Good Implementations ### TypeScript NodeSDK Metric Reader with Exponential Dynamic Compaction #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Defaulting to ExplicitBucketHistogram or unbounded views causes massive allocations when observing extreme latency spreads or high cardinality. Without `maxBuckets` limits, memory escalates linearly with distinct value boundaries. ```typescript import { MeterProvider, PeriodicExportingMetricReader } from '@opentelemetry/sdk-metrics'; import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-grpc'; // ANTI-PATTERN: Default or explicit high-density linear boundaries without compaction bounds const meterProvider = new MeterProvider(); meterProvider.addMetricReader(new PeriodicExportingMetricReader({ exporter: new OTLPMetricExporter(), exportIntervalMillis: 10000, })); // Metric instrument created without views will default to ExplicitBucketHistogram // Under dynamic spikes with large spreads, bucket allocations grow linearly per series, // provoking unconstrained memory overhead and collector buffer OOM. export const meter = meterProvider.getMeter('billing-service'); export const requestDuration = meter.createHistogram('http.server.duration'); ``` #### Production Standard (Correct) > **Standard**: Configuring `Aggregation.ExponentialHistogram` with `maxBuckets: 160` and `maxScale: 20` enables dynamic scale compaction. Under extreme variance or metric spikes, the SDK automatically decrements the scale factor to merge contiguous buckets, maintaining a deterministic, constant memory footprint. ```typescript import { MeterProvider, PeriodicExportingMetricReader, View, Aggregation, InstrumentType } from '@opentelemetry/sdk-metrics'; import { OTLPMetricExporter } from '@opentelemetry/exporter-metrics-otlp-grpc'; // PRODUCTION INVARIANT: Base-2 Exponential Histogram with dynamic compaction const exponentialView = new View({ instrumentName: 'http.server.duration', instrumentType: InstrumentType.HISTOGRAM, aggregation: Aggregation.ExponentialHistogram({ maxBuckets: 160, // Fixed upper limit prevents heap explosion maxScale: 20 // Dynamic downscaling activates when span exceeds maxBuckets }), }); const meterProvider = new MeterProvider({ views: [exponentialView], }); meterProvider.addMetricReader(new PeriodicExportingMetricReader({ exporter: new OTLPMetricExporter(), exportIntervalMillis: 10000, })); export const meter = meterProvider.getMeter('billing-service'); export const requestDuration = meter.createHistogram('http.server.duration', { unit: 'ms', description: 'Measures incoming HTTP request durations with dynamic scale compaction' }); ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: OpenTelemetry Exponential Histogram Dynamic Compaction and Bucket Scale Invariant

OpenTelemetry Exponential Histogram Dynamic Compaction and Bucket Scale Invariant defines an industrial-grade behavioral standard for devops engineering. Enforces strict upper bounds on memory allocation for OpenTelemetry metrics streams by mandating exponential histograms with dynamic scale reduction and explicit maxBucket limits. Guarantees that SDK clients and OpenTelemetry Collectors automatically downscale bucket resolution (scale compaction) during high-dynamic-range metric spikes, preventing Out-Of-Memory (OOM) termination and collector buffer saturation. Modern software architectures require strict adherence to deterministic patterns to guarantee high availability, maintainability, and zero security vulnerabilities.

Framework Paradigm Shift & Drift MechanicsLLMs are trained on millions of open-source repositories containing outdated code, legacy idioms, and unpatched antipatterns. When coding assistants generate implementations for this stack, they default to common statistical tokens: Unbounded Explicit Buckets or Unconstrained Exponential Histogram Scales Causing Memory Exhaustion Without an explicit system instruction file, developers spend hours debugging silent failures.

Failure Modes & Production Blast Radius

Hazard Analysis: What Breaks Without This Rule

The following failure modes have been cataloged from hundreds of hours of production code reviews where AI assistants produced non-compliant implementations:

Failure Mode	AI Symptom (The Anti-Pattern)	Severity	Production Impact & Remedy
AI Hallucination & Deprecation Drift	Unbounded Explicit Buckets or Unconstrained Exponential Histogram Scales Causing Memory Exhaustion	Critical	Violating this industrial standard introduces regression bugs, security risks, and unexpected runtime failures in production. Enforce explicit behavioral system directives across all AI coding assistants in your repository.
Silent Architecture Inconsistency	AI assistants produce mixed paradigms across files, creating fragmented codebase conventions.	Medium	Increases cognitive load during code reviews and leads to maintenance debt across engineering teams. Pin project conventions in .cursor/rules, CLAUDE.md, and AGENTS.md so all team agents follow identical guardrails.

Architectural Directives in Detail

Step-by-Step Production Directives

Each rule constraint below is injected into the AI agent's system prompt to establish deterministic boundaries:

Engineers MUST ALWAYS configure `Aggregation.ExponentialHistogram` with an explicit `maxBuckets` threshold (defaulting between 160 and 320) across all high-throughput latency and duration instruments.

Engineers MUST ALWAYS configure `Aggregation.ExponentialHistogram` with an explicit `maxBuckets` threshold (defaulting between 160 and 320) across all high-throughput latency and duration instruments.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.