frugal-sdk-python 0.6.0__tar.gz → 0.7.0__tar.gz

{frugal_sdk_python-0.6.0 → frugal_sdk_python-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: frugal-sdk-python
-Version: 0.6.0
+Version: 0.7.0
 Summary: Instrumentation for Cost-to-Code attribution.
 Project-URL: Homepage, https://frugal.co
 Author: Frugal AI Inc.
@@ -71,7 +71,13 @@ Console mode (`FRUGAL_METRICS_EXPORTER=console`) needs only `FRUGAL_PROJECT_ID`;
 
 ### Optional
 
-The export endpoint and authentication come only from `FRUGAL_`-prefixed variables, so the SDK never crosses wires with the host's own OTel pipeline: the generic `OTEL_EXPORTER_OTLP_ENDPOINT` and `OTEL_EXPORTER_OTLP_HEADERS` are never read. (The OTel exporter library still reads its own generic TLS, compression, timeout and temporality variables.)
+The export endpoint and authentication come only from `FRUGAL_`-prefixed variables, so the SDK never crosses wires with the host's own OTel pipeline: the generic `OTEL_EXPORTER_OTLP_ENDPOINT` and `OTEL_EXPORTER_OTLP_HEADERS` are never read. (The OTel exporter library still reads its own generic TLS, compression and timeout variables.)
+
+Export temporality is pinned by the SDK: Counter, Histogram and ObservableCounter instruments are exported as OTLP **delta**, everything else as cumulative. `OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE` is ignored, and every export carries the resource attribute `frugal.temporality="delta"`.
+
+Delta delivery is best-effort: the exporter retries transient failures (throttling, gateway errors, network errors). An interval whose export still fails after those retries (for example a long outage), or fails with a non-retryable error such as a rejected token, is dropped, not carried into the next export. A retry after a lost response can occasionally deliver an interval twice. Each run of failed exports surfaces once through the `error` debug callback.
+
+**Querying:** use `sum_over_time` / `rate_over_sum`, not `increase` / `rate`, and select `frugal.temporality="delta"`.
 
 | Variable                                 | Purpose                                                                                 |
 | ---------------------------------------- | --------------------------------------------------------------------------------------- |
@@ -328,6 +334,8 @@ enable_auto_shutdown()  # flush + shutdown via atexit, plus SIGTERM / SIGINT
 
 `enable_auto_shutdown` always registers an `atexit` hook and, when `handle_signals=True` (the default), installs SIGTERM/SIGINT handlers that flush+shutdown and then **chain to whatever handler was previously installed** (so your own handler still runs). Off the main thread, signal registration is unavailable and it falls back to atexit-only. It is **idempotent** — repeat calls register nothing extra.
 
+Exports are delta: each carries only its own interval, so a skipped final flush loses at most the last interval.
+
 It is **opt-in** because installing signal handlers is intrusive. If you run your own signal handling, do **not** call `enable_auto_shutdown(handle_signals=True)`; prefer calling `shutdown()` from inside your own handler instead.
 
 ## Verifying the setup
@@ -355,4 +363,4 @@ export FRUGAL_METRIC_EXPORT_INTERVAL_MS=5000
 python my_script.py
 ```
 
-The collector should receive metric records with `gen_ai.*` and `frugal.*` attributes every 5 seconds.
+The collector should receive metric records with `gen_ai.*` and `frugal.*` attributes on each 5-second export that follows at least one wrapped call. Counters and histograms are exported as delta, so an idle interval carries no counter or histogram points: make a call, then watch the next export.

{frugal_sdk_python-0.6.0 → frugal_sdk_python-0.7.0}/README.md

@@ -42,7 +42,13 @@ Console mode (`FRUGAL_METRICS_EXPORTER=console`) needs only `FRUGAL_PROJECT_ID`;
 
 ### Optional
 
-The export endpoint and authentication come only from `FRUGAL_`-prefixed variables, so the SDK never crosses wires with the host's own OTel pipeline: the generic `OTEL_EXPORTER_OTLP_ENDPOINT` and `OTEL_EXPORTER_OTLP_HEADERS` are never read. (The OTel exporter library still reads its own generic TLS, compression, timeout and temporality variables.)
+The export endpoint and authentication come only from `FRUGAL_`-prefixed variables, so the SDK never crosses wires with the host's own OTel pipeline: the generic `OTEL_EXPORTER_OTLP_ENDPOINT` and `OTEL_EXPORTER_OTLP_HEADERS` are never read. (The OTel exporter library still reads its own generic TLS, compression and timeout variables.)
+
+Export temporality is pinned by the SDK: Counter, Histogram and ObservableCounter instruments are exported as OTLP **delta**, everything else as cumulative. `OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE` is ignored, and every export carries the resource attribute `frugal.temporality="delta"`.
+
+Delta delivery is best-effort: the exporter retries transient failures (throttling, gateway errors, network errors). An interval whose export still fails after those retries (for example a long outage), or fails with a non-retryable error such as a rejected token, is dropped, not carried into the next export. A retry after a lost response can occasionally deliver an interval twice. Each run of failed exports surfaces once through the `error` debug callback.
+
+**Querying:** use `sum_over_time` / `rate_over_sum`, not `increase` / `rate`, and select `frugal.temporality="delta"`.
 
 | Variable                                 | Purpose                                                                                 |
 | ---------------------------------------- | --------------------------------------------------------------------------------------- |
@@ -299,6 +305,8 @@ enable_auto_shutdown()  # flush + shutdown via atexit, plus SIGTERM / SIGINT
 
 `enable_auto_shutdown` always registers an `atexit` hook and, when `handle_signals=True` (the default), installs SIGTERM/SIGINT handlers that flush+shutdown and then **chain to whatever handler was previously installed** (so your own handler still runs). Off the main thread, signal registration is unavailable and it falls back to atexit-only. It is **idempotent** — repeat calls register nothing extra.
 
+Exports are delta: each carries only its own interval, so a skipped final flush loses at most the last interval.
+
 It is **opt-in** because installing signal handlers is intrusive. If you run your own signal handling, do **not** call `enable_auto_shutdown(handle_signals=True)`; prefer calling `shutdown()` from inside your own handler instead.
 
 ## Verifying the setup
@@ -326,4 +334,4 @@ export FRUGAL_METRIC_EXPORT_INTERVAL_MS=5000
 python my_script.py
 ```
 
-The collector should receive metric records with `gen_ai.*` and `frugal.*` attributes every 5 seconds.
+The collector should receive metric records with `gen_ai.*` and `frugal.*` attributes on each 5-second export that follows at least one wrapped call. Counters and histograms are exported as delta, so an idle interval carries no counter or histogram points: make a call, then watch the next export.

{frugal_sdk_python-0.6.0 → frugal_sdk_python-0.7.0}/docs/metrics-reference.md

@@ -61,9 +61,9 @@ combining both would double-count tokens.
 To derive average turns per reporting agent invocation in MetricsQL, use:
 
 ```promql
-increase(frugal.gen_ai.agent.turns_sum[...])
+sum_over_time(frugal.gen_ai.agent.turns_sum{frugal.temporality="delta"}[...])
 /
-increase(frugal.gen_ai.agent.turns_count[...])
+sum_over_time(frugal.gen_ai.agent.turns_count{frugal.temporality="delta"}[...])
 ```
 
 The analyzer-sampled metrics are gated by `FRUGAL_PROMPT_ANALYSIS_SAMPLE_RATE`
@@ -165,6 +165,16 @@ Reading `duplicate_requests` correctly:
   otherwise double every `calls` series; keeping it separate keeps `calls`
   stable when detection is toggled.
 
+## Temporality
+
+Export temporality is pinned by the SDK: Counter, Histogram and ObservableCounter instruments are exported as OTLP **delta**, everything else as cumulative. `OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE` is ignored, and every export carries the resource attribute `frugal.temporality="delta"`.
+
+Delta delivery is best-effort: the exporter retries transient failures (throttling, gateway errors, network errors). An interval whose export still fails after those retries (for example a long outage), or fails with a non-retryable error such as a rejected token, is dropped, not carried into the next export. A retry after a lost response can occasionally deliver an interval twice. Each run of failed exports surfaces once through the `error` debug callback.
+
+**Querying:** use `sum_over_time` / `rate_over_sum`, not `increase` / `rate`, and select `frugal.temporality="delta"`.
+
+Each export carries only its own interval, so a process that exits without `shutdown()` (or `enable_auto_shutdown()`) loses at most its last interval.
+
 ## Attributes
 
 ### From the GenAI semantic convention
@@ -202,6 +212,7 @@ Reading `duplicate_requests` correctly:
 | ------------------------- | ---------------------------------------------------------- |
 | `frugal.customer_id`      | From `FRUGAL_CUSTOMER_ID` — present only when set           |
 | `frugal.project_id`       | From `FRUGAL_METRICS_PROJECT_ID`, else `FRUGAL_PROJECT_ID`  |
+| `frugal.temporality`      | Constant resource attribute `delta`, stamped on every export. Select it in queries to skip older cumulative samples that share the same series. |
 | `frugal.component`        | From each entry in `FRUGAL_COMPONENTS` — present only on the per-component series, absent on the base project series |
 | `frugal.caller_file`      | Source file repo-relative to `FRUGAL_REPO_ROOT`             |
 | `frugal.caller_function`  | Function/method name at the call site                       |

{frugal_sdk_python-0.6.0 → frugal_sdk_python-0.7.0}/docs/quickstart.md

@@ -21,7 +21,13 @@ Optional — the export endpoint and authentication come only from
 `FRUGAL_`-prefixed variables, so the SDK never crosses wires with the host's
 own OTel pipeline: the generic `OTEL_EXPORTER_OTLP_ENDPOINT` and
 `OTEL_EXPORTER_OTLP_HEADERS` are never read. (The OTel exporter library still
-reads its own generic TLS, compression, timeout and temporality variables.)
+reads its own generic TLS, compression and timeout variables.)
+
+Export temporality is pinned by the SDK: Counter, Histogram and ObservableCounter instruments are exported as OTLP **delta**, everything else as cumulative. `OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE` is ignored, and every export carries the resource attribute `frugal.temporality="delta"`.
+
+Delta delivery is best-effort: the exporter retries transient failures (throttling, gateway errors, network errors). An interval whose export still fails after those retries (for example a long outage), or fails with a non-retryable error such as a rejected token, is dropped, not carried into the next export. A retry after a lost response can occasionally deliver an interval twice. Each run of failed exports surfaces once through the `error` debug callback.
+
+**Querying:** use `sum_over_time` / `rate_over_sum`, not `increase` / `rate`, and select `frugal.temporality="delta"`.
 
 | Var                                   | Purpose                                                                                    |
 | ------------------------------------- | ------------------------------------------------------------------------------------------ |
@@ -541,5 +547,4 @@ export FRUGAL_METRIC_EXPORT_INTERVAL_MS=5000
 python my_script.py
 ```
 
-Every five seconds the collector should receive metric records with
-`gen_ai.*` and `frugal.*` attributes.
+The collector should receive metric records with `gen_ai.*` and `frugal.*` attributes on each 5-second export that follows at least one wrapped call. Counters and histograms are exported as delta, so an idle interval carries no counter or histogram points: make a call, then watch the next export.

{frugal_sdk_python-0.6.0 → frugal_sdk_python-0.7.0}/examples/test-env/mockllm/package.json

@@ -7,6 +7,6 @@
     "start": "node src/server.js"
   },
   "dependencies": {
-    "express": "^4.19.2"
+    "express": "^5.2.1"
   }
 }

{frugal_sdk_python-0.6.0 → frugal_sdk_python-0.7.0}/src/frugal_metrics/config.py

@@ -33,8 +33,10 @@ variables, so the SDK never crosses wires with the host's own OTel pipeline:
       else "Authorization: Bearer <key>" built verbatim from the API key.
 The generic OTEL_EXPORTER_OTLP_ENDPOINT / OTEL_EXPORTER_OTLP_HEADERS are never
 read; a deployment that relied on them must set the FRUGAL_ names instead. The
-OTel exporter library still reads its own generic TLS, compression, timeout
-and temporality variables.
+OTel exporter library still reads its own generic TLS, compression and timeout
+variables. Temporality is pinned in code (delta for counters and histograms,
+cumulative for the rest) and ignores
+OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE.
 """
 
 from __future__ import annotations

{frugal_sdk_python-0.6.0 → frugal_sdk_python-0.7.0}/src/frugal_metrics/otel.py

@@ -17,8 +17,17 @@ from typing import TYPE_CHECKING, Any
 from opentelemetry.exporter.otlp.proto.http.metric_exporter import (
     OTLPMetricExporter,
 )
-from opentelemetry.sdk.metrics import MeterProvider
+from opentelemetry.sdk.metrics import (
+    Counter,
+    Histogram,
+    MeterProvider,
+    ObservableCounter,
+    ObservableGauge,
+    ObservableUpDownCounter,
+    UpDownCounter,
+)
 from opentelemetry.sdk.metrics.export import (
+    AggregationTemporality,
     ConsoleMetricExporter,
     MetricExporter,
     MetricExportResult,
@@ -291,6 +300,33 @@ def _build_instruments(config: "Config") -> Instruments:
         raise
 
 
+# The one place export temporality is decided. Monotonic instruments are DELTA
+# (each export carries only its own interval, so many short-lived processes
+# sharing a label set add up exactly); everything else stays CUMULATIVE. An
+# explicit map covering every instrument class overrides the exporter's
+# env-derived defaults, so OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE
+# has nothing left to change.
+# Delta delivery is best-effort per interval: an export that still fails after
+# the OTLP exporter's own retries drops that interval rather than folding it
+# into the next export, and a retry after a lost response can deliver an
+# interval twice. _HealthCheckingExporter surfaces the failure run but
+# deliberately does not replay batches.
+_FRUGAL_PREFERRED_TEMPORALITY: dict[type, AggregationTemporality] = {
+    Counter: AggregationTemporality.DELTA,
+    Histogram: AggregationTemporality.DELTA,
+    ObservableCounter: AggregationTemporality.DELTA,
+    UpDownCounter: AggregationTemporality.CUMULATIVE,
+    ObservableUpDownCounter: AggregationTemporality.CUMULATIVE,
+    ObservableGauge: AggregationTemporality.CUMULATIVE,
+}
+try:
+    from opentelemetry.sdk.metrics import _Gauge  # type: ignore[attr-defined]
+
+    _FRUGAL_PREFERRED_TEMPORALITY[_Gauge] = AggregationTemporality.CUMULATIVE
+except ImportError:  # pragma: no cover - SDKs without the synchronous Gauge
+    pass
+
+
 def _instruments_for_reader(
     config: "Config", reader: PeriodicExportingMetricReader
 ) -> Instruments:
@@ -306,6 +342,7 @@ def _instruments_for_reader(
     resource_attrs: dict[str, str] = {
         "service.name": service_name,
         semconv.FRUGAL_PROJECT_ID: config.project_id,
+        semconv.FRUGAL_TEMPORALITY: semconv.TEMPORALITY_DELTA,
     }
     if config.customer_id:
         resource_attrs[semconv.FRUGAL_CUSTOMER_ID] = config.customer_id
@@ -460,7 +497,10 @@ def _build_exporter(config: "Config") -> MetricExporter:
         identity[semconv.FRUGAL_CUSTOMER_ID] = config.customer_id
 
     if config.exporter == "console":
-        return wrap_exporter_for_health(ConsoleMetricExporter(), identity=identity)
+        return wrap_exporter_for_health(
+            ConsoleMetricExporter(preferred_temporality=_FRUGAL_PREFERRED_TEMPORALITY),
+            identity=identity,
+        )
 
     if config.otlp_headers_from_api_key and config.otlp_headers:
         # Built from the API key: send verbatim, never split or decode it.
@@ -472,6 +512,7 @@ def _build_exporter(config: "Config") -> MetricExporter:
         OTLPMetricExporter(
             endpoint=config.otlp_endpoint,
             headers=headers or None,
+            preferred_temporality=_FRUGAL_PREFERRED_TEMPORALITY,
         ),
         identity=identity,
     )
@@ -509,20 +550,26 @@ class _HealthCheckingExporter(MetricExporter):
     """Wrap an exporter so persistent export failures surface as a single
     de-duped ``error`` debug callback.
 
-    The periodic reader retries silently forever; without this, a wrong
-    endpoint / bad token / down backend is invisible to the customer. We emit on
-    the FIRST failure after a success (0->1 edge) and re-arm on the next success,
-    so a flapping backend produces one alert per failure run, not one per export
-    tick. Every other attribute delegates to the inner exporter.
+    A failed export is not replayed: under delta temporality its interval is
+    lost and the periodic reader just moves on to the next tick, so without
+    this a wrong endpoint / bad token / down backend is invisible to the
+    customer. We emit on the FIRST failure after a success (0->1 edge) and
+    re-arm on the next success, so a flapping backend produces one alert per
+    failure run, not one per export tick. Export temporality is pinned to
+    _FRUGAL_PREFERRED_TEMPORALITY, ignoring the inner exporter's own map; every
+    other attribute delegates to the inner exporter.
     """
 
     def __init__(
         self, inner: MetricExporter, identity: dict[str, Any] | None = None
     ) -> None:
-        # Do NOT call super().__init__ — we delegate everything to the inner
-        # exporter, including the preferred temporality/aggregation it was built
-        # with. Accessing those goes through __getattr__.
+        # Do NOT call super().__init__ — every attribute except the pinned
+        # _preferred_temporality below (aggregation included) delegates to the
+        # inner exporter through __getattr__.
         self._inner = inner
+        # Pinned here too so the reader always sees the Frugal map, whatever
+        # exporter is wrapped.
+        self._preferred_temporality: dict[Any, Any] = _FRUGAL_PREFERRED_TEMPORALITY
         self._consecutive_failures = 0
         # Project/customer attributes for the internal_errors point the overflow
         # detector emits — instrument attrs don't exist on this path.
@@ -618,8 +665,9 @@ class _HealthCheckingExporter(MetricExporter):
         self._inner.shutdown(timeout_millis=timeout_millis, **kwargs)
 
     def __getattr__(self, name: str) -> Any:
-        # Delegate preferred_temporality / preferred_aggregation and any other
-        # attribute the SDK reads off the exporter to the inner instance.
+        # Delegate preferred_aggregation and any other attribute the SDK reads
+        # off the exporter to the inner instance (the temporality map is pinned
+        # in __init__).
         return getattr(self._inner, name)
 
 
@@ -628,6 +676,7 @@ def wrap_exporter_for_health(
 ) -> MetricExporter:
     """Wrap an exporter so persistent export failures emit one de-duped error,
     and so an OTel cardinality-overflow series is reported once per instrument.
+    Its export temporality is pinned to the Frugal map.
     """
     return _HealthCheckingExporter(exporter, identity=identity)
 

{frugal_sdk_python-0.6.0 → frugal_sdk_python-0.7.0}/src/frugal_metrics/semconv.py

@@ -68,6 +68,10 @@ METRIC_AGENT_TURNS = "frugal.gen_ai.agent.turns"
 # Frugal-namespaced attributes.
 FRUGAL_CUSTOMER_ID = "frugal.customer_id"
 FRUGAL_PROJECT_ID = "frugal.project_id"
+# Resource attribute, constant "delta": the SDK exports counters and histograms
+# with DELTA temporality, so queries select on it to skip older cumulative data.
+FRUGAL_TEMPORALITY = "frugal.temporality"
+TEMPORALITY_DELTA = "delta"
 FRUGAL_COMPONENT = "frugal.component"
 FRUGAL_CALLER_FILE = "frugal.caller_file"
 FRUGAL_CALLER_FUNCTION = "frugal.caller_function"

frugal_sdk_python-0.7.0/tests/test_otel_temporality.py

@@ -0,0 +1,171 @@
+"""Export temporality is pinned in code: DELTA for monotonic instruments."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import pytest
+from opentelemetry.sdk.metrics import (
+    Counter,
+    Histogram,
+    MeterProvider,
+    ObservableCounter,
+    ObservableGauge,
+    ObservableUpDownCounter,
+    UpDownCounter,
+)
+from opentelemetry.sdk.metrics import _Gauge  # type: ignore[attr-defined]
+from opentelemetry.sdk.metrics._internal import instrument
+from opentelemetry.sdk.metrics.export import (
+    AggregationTemporality,
+    InMemoryMetricReader,
+    MetricExporter,
+    MetricExportResult,
+    PeriodicExportingMetricReader,
+)
+
+from frugal_metrics import config as config_module
+from frugal_metrics import otel as otel_module
+from frugal_metrics import semconv
+
+DELTA = AggregationTemporality.DELTA
+CUMULATIVE = AggregationTemporality.CUMULATIVE
+
+_EXPECTED = {
+    Counter: DELTA,
+    Histogram: DELTA,
+    ObservableCounter: DELTA,
+    UpDownCounter: CUMULATIVE,
+    ObservableUpDownCounter: CUMULATIVE,
+    ObservableGauge: CUMULATIVE,
+    _Gauge: CUMULATIVE,
+}
+
+_ENV = "OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE"
+
+
+def _load() -> Any:
+    cfg = config_module.load_config()
+    assert cfg is not None
+    return cfg
+
+
+def test_selector_table_covers_every_instrument_kind():
+    assert otel_module._FRUGAL_PREFERRED_TEMPORALITY == _EXPECTED
+
+
+@pytest.mark.parametrize("mode", ["otlp", "console"])
+@pytest.mark.parametrize("env", [None, "cumulative", "delta", "lowmemory"])
+def test_production_exporter_reports_pinned_temporality(
+    required_env, monkeypatch, mode, env
+):
+    # env=None covers the default; the others prove the host's generic OTel
+    # variable cannot change the map (production-path + env-immunity).
+    if env is None:
+        monkeypatch.delenv(_ENV, raising=False)
+    else:
+        monkeypatch.setenv(_ENV, env)
+    if mode == "console":
+        monkeypatch.setenv("FRUGAL_METRICS_EXPORTER", "console")
+    exporter = otel_module._build_exporter(_load())
+    for kind, expected in _EXPECTED.items():
+        assert exporter._preferred_temporality[kind] == expected
+    # The inner exporter agrees with the wrapper.
+    for kind, expected in _EXPECTED.items():
+        assert exporter._inner._preferred_temporality[kind] == expected
+
+
+def test_reader_sees_pinned_map_over_a_cumulative_inner(monkeypatch):
+    monkeypatch.setenv(_ENV, "cumulative")
+    inner = _CapturingExporter(preferred_temporality=None)
+    wrapped = otel_module.wrap_exporter_for_health(inner)
+    reader = PeriodicExportingMetricReader(wrapped, export_interval_millis=3_600_000)
+    try:
+        # The reader keys its map by the private instrument base classes.
+        got = reader._instrument_class_temporality
+        assert got[instrument._Counter] == DELTA
+        assert got[instrument._Histogram] == DELTA
+        assert got[instrument._ObservableCounter] == DELTA
+        assert got[instrument._UpDownCounter] == CUMULATIVE
+        assert got[instrument._Gauge] == CUMULATIVE
+    finally:
+        reader.shutdown()
+
+
+class _CapturingExporter(MetricExporter):
+    def __init__(self, preferred_temporality: Any = None) -> None:
+        super().__init__(preferred_temporality=preferred_temporality)
+        self.batches: list[Any] = []
+
+    def export(self, metrics_data, timeout_millis=10_000, **kwargs):
+        self.batches.append(metrics_data)
+        return MetricExportResult.SUCCESS
+
+    def force_flush(self, timeout_millis=10_000) -> bool:
+        return True
+
+    def shutdown(self, timeout_millis=30_000, **kwargs) -> None:
+        pass
+
+
+def _metric(batch: Any, name: str) -> Any:
+    for rm in batch.resource_metrics:
+        for sm in rm.scope_metrics:
+            for m in sm.metrics:
+                if m.name == name:
+                    return m
+    return None
+
+
+def test_end_to_end_delta_exports(monkeypatch):
+    monkeypatch.setenv(_ENV, "cumulative")
+    inner = _CapturingExporter()
+    wrapped = otel_module.wrap_exporter_for_health(inner)
+    reader = PeriodicExportingMetricReader(wrapped, export_interval_millis=3_600_000)
+    provider = MeterProvider(metric_readers=[reader])
+    meter = provider.get_meter("t")
+    calls = meter.create_counter("t.calls")
+    turns = meter.create_histogram(
+        "t.turns",
+        explicit_bucket_boundaries_advisory=[1, 5, 10],
+    )
+    attrs = {"k": "v"}
+    try:
+        calls.add(2, attrs)
+        turns.record(3, attrs)
+        provider.force_flush()
+        calls.add(3, attrs)
+        turns.record(7, attrs)
+        provider.force_flush()
+        provider.force_flush()
+
+        # The idle third flush exports nothing: a delta stream with no
+        # measurements is dropped.
+        assert len(inner.batches) == 2
+        first, second = inner.batches
+        m = _metric(second, "t.calls")
+        assert m.data.aggregation_temporality == DELTA
+        assert m.data.data_points[0].value == 3
+        h = _metric(second, "t.turns")
+        assert h.data.aggregation_temporality == DELTA
+        point = h.data.data_points[0]
+        assert point.count == 1
+        assert point.sum == 7
+        assert list(point.bucket_counts) == [0, 0, 1, 0]
+        assert _metric(first, "t.calls").data.data_points[0].value == 2
+    finally:
+        provider.shutdown()
+
+
+def test_resource_carries_delta_attribute(required_env):
+    reader = InMemoryMetricReader()
+    instruments = otel_module._instruments_for_reader(_load(), reader)
+    try:
+        instruments.calls.add(1, {"k": "v"})
+        data = reader.get_metrics_data()
+        attrs = data.resource_metrics[0].resource.attributes
+        assert attrs[semconv.FRUGAL_TEMPORALITY] == "delta"
+        assert semconv.FRUGAL_TEMPORALITY == "frugal.temporality"
+        assert semconv.TEMPORALITY_DELTA == "delta"
+    finally:
+        instruments.meter_provider.shutdown()