oai-statsig-python-core 0.34.0rc4__tar.gz → 0.35.0__tar.gz

{oai_statsig_python_core-0.34.0rc4 → oai_statsig_python_core-0.35.0}/Cargo.lock

@@ -1853,7 +1853,7 @@ dependencies = [
 
 [[package]]
 name = "oai-statsig-grpc"
-version = "0.34.0-rc.4"
+version = "0.35.0"
 dependencies = [
  "async-trait",
  "chrono",
@@ -1869,7 +1869,7 @@ dependencies = [
 
 [[package]]
 name = "oai-statsig-rust"
-version = "0.34.0-rc.4"
+version = "0.35.0"
 dependencies = [
  "ahash",
  "arc-swap",
@@ -3102,7 +3102,7 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "statsig-node"
-version = "0.34.0-rc.4"
+version = "0.35.0"
 dependencies = [
  "async-trait",
  "napi",
@@ -3117,7 +3117,7 @@ dependencies = [
 
 [[package]]
 name = "statsig-pyo3"
-version = "0.34.0-rc.4"
+version = "0.35.0"
 dependencies = [
  "async-trait",
  "lazy_static",
@@ -3132,7 +3132,7 @@ dependencies = [
 
 [[package]]
 name = "statsig_ffi"
-version = "0.34.0-rc.4"
+version = "0.35.0"
 dependencies = [
  "async-trait",
  "cbindgen",

{oai_statsig_python_core-0.34.0rc4 → oai_statsig_python_core-0.35.0}/Cargo.toml

@@ -26,7 +26,7 @@ exclude = [
 [workspace.package]
 edition = "2021"
 license = "ISC"
-version = "0.34.0-rc.4"
+version = "0.35.0"
 homepage = "https://statsig.com/"
 authors = ["Statsig", "Daniel Loomb <daniel@statsig.com>"]
 readme = "README.md"

{oai_statsig_python_core-0.34.0rc4 → oai_statsig_python_core-0.35.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oai_statsig_python_core
-Version: 0.34.0rc4
+Version: 0.35.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
@@ -51,8 +51,8 @@ Read through the [Documentation](https://docs.statsig.com/server-core?ref=gh_ser
 
 `download_id_list_file_api` selects the preferred base URL for file downloads.
 Enable `fallback_to_statsig_api` to try the original file URL from the manifest
-after an overridden request exhausts its retries, provided that URL belongs to
-the trusted HTTPS OpenAI CDN origin:
+after an overridden request fails with a retryable network error, provided that
+URL belongs to the trusted HTTPS OpenAI CDN origin:
 
 ```rust
 let options = statsig_rust::StatsigOptions {
@@ -66,26 +66,33 @@ Fallback accepts only `https://statsigcdn.openai.com` with the default port or
 explicit `:443`. Fallback sends no request or SDK credentials to other manifest
 origins; the original request error is returned. Fallback does not follow redirects.
 Custom network providers must implement `send_without_redirects`; otherwise the
-fallback returns an error without sending a request. Fallback preserves the URL's
-path and query except for legacy `range` parameters. It sends `Range`,
-`statsig-id-list-file-size`, and `Accept-Encoding: identity` headers, preserving
-the file identity and byte offset for incremental updates. A `206` response must
-have a valid `Content-Range` matching the requested offset and cover the advertised
-file size. If the CDN returns a full `200` response, the SDK applies only the bytes
-after that offset. Stale or inconsistent responses use the remaining retry budget
-without publishing the refresh. Direct CDN downloads that do not use fallback
-retain the existing `range` query protocol.
+fallback returns an error without sending a request.
+
+All ID-list file downloads, including direct CDN, proxy, and fallback requests,
+preserve the URL's path and query except for legacy `range` parameters, which are
+removed. Every request sends `Range`, `statsig-id-list-file-size`, and
+`Accept-Encoding: identity` headers, preserving the file identity and byte offset
+for incremental updates. Partial responses require a valid `Content-Range`
+matching the requested offset and received body length. They may use `206` or,
+for compatibility, `200`. A `200` without `Content-Range` means the complete
+available file from byte zero; the SDK applies only bytes after the requested
+offset. Available bytes may be behind or ahead of the manifest: the SDK advances
+by bytes actually applied and keeps polling while below the advertised size.
+Responses that make no progress or have inconsistent ranges use the remaining
+retry budget without publishing the refresh. Partial bodies without
+`Content-Range` are unsupported; a malformed header is rejected even when the
+status is `200`.
 
 Set `fallback_to_statsig_api` to `Some(false)` or leave it unset to keep file
-downloads strictly on the selected destination. There is no second attempt when
+downloads strictly on the selected destination. There is no fallback attempt when
 the override resolves to the original URL, no override is set, or the request
 fails with an authentication rejection (401/403) or another non-retryable error.
 Response parsing failures do not trigger fallback. This uses the existing option
 across language bindings; wrappers that disable it continue to opt out.
 
-A successful proxy request makes no additional request. An eligible failure can
-add one request to the trusted CDN URL using the existing network timeout and retry
-policy. The next synchronization starts with the configured override again.
+A successful proxy request makes no additional request. Primary and fallback
+requests share the same per-file attempt budget (three attempts by default).
+The next synchronization starts with the configured override again.
 
 ## Read-only data stores
 

{oai_statsig_python_core-0.34.0rc4 → oai_statsig_python_core-0.35.0}/py_src/statsig_python_core/error_boundary.py

@@ -18,7 +18,11 @@ class ErrorBoundary:
 
                 def create_wrapped(method_name, orig_method):
                     def wrapped(*args, **kwargs):
-                        return ErrorBoundary._capture(method_name, lambda: orig_method(*args, **kwargs))
+                        try:
+                            return orig_method(*args, **kwargs)
+                        except Exception as error:
+                            ErrorBoundary._on_error(method_name, error)
+                            return None
 
                     wrapped._error_boundary_wrapped = True
                     return wrapped

{oai_statsig_python_core-0.34.0rc4/statsig-pyo3 → oai_statsig_python_core-0.35.0/statsig-grpc}/README.md

@@ -29,8 +29,8 @@ Read through the [Documentation](https://docs.statsig.com/server-core?ref=gh_ser
 
 `download_id_list_file_api` selects the preferred base URL for file downloads.
 Enable `fallback_to_statsig_api` to try the original file URL from the manifest
-after an overridden request exhausts its retries, provided that URL belongs to
-the trusted HTTPS OpenAI CDN origin:
+after an overridden request fails with a retryable network error, provided that
+URL belongs to the trusted HTTPS OpenAI CDN origin:
 
 ```rust
 let options = statsig_rust::StatsigOptions {
@@ -44,26 +44,33 @@ Fallback accepts only `https://statsigcdn.openai.com` with the default port or
 explicit `:443`. Fallback sends no request or SDK credentials to other manifest
 origins; the original request error is returned. Fallback does not follow redirects.
 Custom network providers must implement `send_without_redirects`; otherwise the
-fallback returns an error without sending a request. Fallback preserves the URL's
-path and query except for legacy `range` parameters. It sends `Range`,
-`statsig-id-list-file-size`, and `Accept-Encoding: identity` headers, preserving
-the file identity and byte offset for incremental updates. A `206` response must
-have a valid `Content-Range` matching the requested offset and cover the advertised
-file size. If the CDN returns a full `200` response, the SDK applies only the bytes
-after that offset. Stale or inconsistent responses use the remaining retry budget
-without publishing the refresh. Direct CDN downloads that do not use fallback
-retain the existing `range` query protocol.
+fallback returns an error without sending a request.
+
+All ID-list file downloads, including direct CDN, proxy, and fallback requests,
+preserve the URL's path and query except for legacy `range` parameters, which are
+removed. Every request sends `Range`, `statsig-id-list-file-size`, and
+`Accept-Encoding: identity` headers, preserving the file identity and byte offset
+for incremental updates. Partial responses require a valid `Content-Range`
+matching the requested offset and received body length. They may use `206` or,
+for compatibility, `200`. A `200` without `Content-Range` means the complete
+available file from byte zero; the SDK applies only bytes after the requested
+offset. Available bytes may be behind or ahead of the manifest: the SDK advances
+by bytes actually applied and keeps polling while below the advertised size.
+Responses that make no progress or have inconsistent ranges use the remaining
+retry budget without publishing the refresh. Partial bodies without
+`Content-Range` are unsupported; a malformed header is rejected even when the
+status is `200`.
 
 Set `fallback_to_statsig_api` to `Some(false)` or leave it unset to keep file
-downloads strictly on the selected destination. There is no second attempt when
+downloads strictly on the selected destination. There is no fallback attempt when
 the override resolves to the original URL, no override is set, or the request
 fails with an authentication rejection (401/403) or another non-retryable error.
 Response parsing failures do not trigger fallback. This uses the existing option
 across language bindings; wrappers that disable it continue to opt out.
 
-A successful proxy request makes no additional request. An eligible failure can
-add one request to the trusted CDN URL using the existing network timeout and retry
-policy. The next synchronization starts with the configured override again.
+A successful proxy request makes no additional request. Primary and fallback
+requests share the same per-file attempt budget (three attempts by default).
+The next synchronization starts with the configured override again.
 
 ## Read-only data stores
 

{oai_statsig_python_core-0.34.0rc4/statsig-grpc → oai_statsig_python_core-0.35.0/statsig-pyo3}/README.md

@@ -29,8 +29,8 @@ Read through the [Documentation](https://docs.statsig.com/server-core?ref=gh_ser
 
 `download_id_list_file_api` selects the preferred base URL for file downloads.
 Enable `fallback_to_statsig_api` to try the original file URL from the manifest
-after an overridden request exhausts its retries, provided that URL belongs to
-the trusted HTTPS OpenAI CDN origin:
+after an overridden request fails with a retryable network error, provided that
+URL belongs to the trusted HTTPS OpenAI CDN origin:
 
 ```rust
 let options = statsig_rust::StatsigOptions {
@@ -44,26 +44,33 @@ Fallback accepts only `https://statsigcdn.openai.com` with the default port or
 explicit `:443`. Fallback sends no request or SDK credentials to other manifest
 origins; the original request error is returned. Fallback does not follow redirects.
 Custom network providers must implement `send_without_redirects`; otherwise the
-fallback returns an error without sending a request. Fallback preserves the URL's
-path and query except for legacy `range` parameters. It sends `Range`,
-`statsig-id-list-file-size`, and `Accept-Encoding: identity` headers, preserving
-the file identity and byte offset for incremental updates. A `206` response must
-have a valid `Content-Range` matching the requested offset and cover the advertised
-file size. If the CDN returns a full `200` response, the SDK applies only the bytes
-after that offset. Stale or inconsistent responses use the remaining retry budget
-without publishing the refresh. Direct CDN downloads that do not use fallback
-retain the existing `range` query protocol.
+fallback returns an error without sending a request.
+
+All ID-list file downloads, including direct CDN, proxy, and fallback requests,
+preserve the URL's path and query except for legacy `range` parameters, which are
+removed. Every request sends `Range`, `statsig-id-list-file-size`, and
+`Accept-Encoding: identity` headers, preserving the file identity and byte offset
+for incremental updates. Partial responses require a valid `Content-Range`
+matching the requested offset and received body length. They may use `206` or,
+for compatibility, `200`. A `200` without `Content-Range` means the complete
+available file from byte zero; the SDK applies only bytes after the requested
+offset. Available bytes may be behind or ahead of the manifest: the SDK advances
+by bytes actually applied and keeps polling while below the advertised size.
+Responses that make no progress or have inconsistent ranges use the remaining
+retry budget without publishing the refresh. Partial bodies without
+`Content-Range` are unsupported; a malformed header is rejected even when the
+status is `200`.
 
 Set `fallback_to_statsig_api` to `Some(false)` or leave it unset to keep file
-downloads strictly on the selected destination. There is no second attempt when
+downloads strictly on the selected destination. There is no fallback attempt when
 the override resolves to the original URL, no override is set, or the request
 fails with an authentication rejection (401/403) or another non-retryable error.
 Response parsing failures do not trigger fallback. This uses the existing option
 across language bindings; wrappers that disable it continue to opt out.
 
-A successful proxy request makes no additional request. An eligible failure can
-add one request to the trusted CDN URL using the existing network timeout and retry
-policy. The next synchronization starts with the configured override again.
+A successful proxy request makes no additional request. Primary and fallback
+requests share the same per-file attempt budget (three attempts by default).
+The next synchronization starts with the configured override again.
 
 ## Read-only data stores
 

oai_statsig_python_core-0.35.0/statsig-pyo3/tests/test_error_boundary.py

@@ -0,0 +1,103 @@
+import pytest
+from statsig_python_core import Statsig, StatsigUser
+from statsig_python_core.error_boundary import ErrorBoundary
+
+
+def test_error_boundary_handles_wrong_types():
+    statsig = Statsig("secret-test-key")
+
+    result = statsig.check_gate(123, "gate_name")  # Invalid user type
+    assert result is None
+
+    user = StatsigUser("user_123")
+    result = statsig.check_gate(user, 123)  # Invalid gate name type
+    assert result is None
+
+    result = statsig.get_dynamic_config(123, "config_name")
+    assert result is None
+
+    result = statsig.get_experiment(user, 123)
+    assert result is None
+
+    statsig.log_event(123, "event_name")  # Should not raise
+    statsig.log_event(user, 123)  # Should not raise
+
+
+class _BoundaryTarget:
+    def __init__(self):
+        self.calls = []
+        self.result = object()
+        self.error = None
+
+    def first(self, *args, **kwargs):
+        self.calls.append(("first", args, kwargs))
+        if self.error is not None:
+            raise self.error
+        return self.result
+
+    def second(self, *args, **kwargs):
+        self.calls.append(("second", args, kwargs))
+        if self.error is not None:
+            raise self.error
+        return self.result
+
+
+@pytest.mark.parametrize("method_name", ["first", "second"])
+def test_error_boundary_forwards_arguments_and_return_identity(method_name):
+    target = _BoundaryTarget()
+    ErrorBoundary.wrap(target)
+    token = object()
+
+    result = getattr(target, method_name)(token, 17, flag=True)
+
+    assert result is target.result
+    assert target.calls == [(method_name, (token, 17), {"flag": True})]
+
+
+@pytest.mark.parametrize("method_name", ["first", "second"])
+def test_error_boundary_reports_the_failing_method(method_name, monkeypatch):
+    target = _BoundaryTarget()
+    error = RuntimeError("failed call")
+    target.error = error
+    failures = []
+    monkeypatch.setattr(
+        ErrorBoundary, "_on_error", lambda tag, caught: failures.append((tag, caught))
+    )
+    ErrorBoundary.wrap(target)
+
+    assert getattr(target, method_name)() is None
+    assert failures == [(method_name, error)]
+
+
+@pytest.mark.parametrize("method_name", ["first", "second"])
+def test_error_boundary_propagates_base_exceptions(method_name, monkeypatch):
+    class Abort(BaseException):
+        pass
+
+    target = _BoundaryTarget()
+    target.error = Abort("abort call")
+    failures = []
+    monkeypatch.setattr(
+        ErrorBoundary, "_on_error", lambda tag, caught: failures.append((tag, caught))
+    )
+    ErrorBoundary.wrap(target)
+
+    with pytest.raises(Abort) as caught:
+        getattr(target, method_name)()
+
+    assert caught.value is target.error
+    assert failures == []
+
+
+def test_error_boundary_wrapping_twice_is_idempotent():
+    target = _BoundaryTarget()
+    ErrorBoundary.wrap(target)
+    first = target.first
+    second = target.second
+
+    ErrorBoundary.wrap(target)
+
+    assert target.first is first
+    assert target.second is second
+    assert target.first() is target.result
+    assert target.calls == [("first", (), {})]

{oai_statsig_python_core-0.34.0rc4 → oai_statsig_python_core-0.35.0}/statsig-pyo3/tests/test_exposure_logging.py

@@ -6,6 +6,7 @@ from statsig_python_core import (
     BulkEvaluationOptions,
     Statsig,
     StatsigOptions,
+    StatsigRandomUserID,
     StatsigUser,
 )
 from mock_scrapi import MockScrapi, decode_log_event_request
@@ -143,6 +144,135 @@ def test_sdk_configs_attach_callsite_metadata_to_experiment_and_layer_exposures(
     )
 
 
+@pytest.mark.parametrize("api", ["ordinary", "context", "anonymous"])
+def test_layer_callsite_opt_in_tracks_refreshes_and_current_parameter_caller(
+    statsig_setup, monkeypatch, api
+):
+    statsig, mock_scrapi = statsig_setup
+    if api == "ordinary":
+        layer = statsig.get_layer(StatsigUser("refresh-user"), "layer_with_many_params")
+    elif api == "context":
+        layer = statsig.get_layer_with_context(
+            None, "layer_with_many_params", "refresh-user"
+        )
+    else:
+        layer = statsig.get_layer_anonymous(
+            "layer_with_many_params", StatsigRandomUserID("refresh", 16)
+        )
+    metadata = []
+    log_exposure = statsig._INTERNAL_log_layer_param_exposure
+
+    def record_exposure(exposure, param, callsite):
+        metadata.append(callsite)
+        return log_exposure(exposure, param, callsite)
+
+    monkeypatch.setattr(statsig, "_INTERNAL_log_layer_param_exposure", record_exposure)
+    layer.get_object("an_object", {})
+    assert metadata[-1] is None
+
+    key = "expo_callsite_logging_layer::layer_with_many_params"
+    statsig._internal_sdk_configs = {key: 1}
+
+    def first_caller():
+        return layer.get_string("a_string", "ERR")
+
+    def second_caller():
+        return layer.get_string("a_string", "ERR")
+
+    assert first_caller() != "ERR"
+    assert second_caller() != "ERR"
+    assert metadata[-2]["exposure_source_function"].endswith("first_caller")
+    assert metadata[-1]["exposure_source_function"].endswith("second_caller")
+    assert metadata[-2]["exposure_source_line"] != metadata[-1]["exposure_source_line"]
+
+    statsig._internal_sdk_configs.clear()
+    layer.get_array("an_array", [])
+    assert metadata[-1] is None
+    statsig.flush_events().wait()
+    events = [
+        event
+        for event in mock_scrapi.get_logged_events()
+        if event["eventName"] == "statsig::layer_exposure"
+    ]
+    assert len(events) == 3
+    string_event = next(
+        event for event in events if event["metadata"]["parameterName"] == "a_string"
+    )
+    assert string_event["metadata"]["exposure_source_function"].endswith("first_caller")
+
+
+def test_layer_parameter_reads_honor_live_private_metadata_overrides(
+    statsig_setup, monkeypatch
+):
+    statsig, mock_scrapi = statsig_setup
+    layer = statsig.get_layer(StatsigUser("override-user"), "layer_with_many_params")
+    original_metadata = statsig._get_layer_exposure_metadata
+    override = {
+        "exposure_source_file": "private-layer.py",
+        "exposure_source_function": "layer_override",
+        "exposure_source_line": 42,
+    }
+    names = []
+
+    def layer_metadata(name):
+        names.append(name)
+        return override
+
+    monkeypatch.setattr(statsig, "_get_layer_exposure_metadata", layer_metadata)
+    assert layer.get_string("a_string", "ERR") != "ERR"
+    assert names == ["layer_with_many_params"]
+
+    monkeypatch.setattr(statsig, "_get_layer_exposure_metadata", original_metadata)
+    config_keys = []
+
+    def config_enabled(key):
+        config_keys.append(key)
+        return True
+
+    monkeypatch.setattr(statsig, "_sdk_config_enabled", config_enabled)
+    monkeypatch.setattr(
+        statsig,
+        "_get_exposure_callsite_metadata",
+        lambda: dict(override, exposure_source_function="config_override"),
+    )
+    assert layer.get_object("an_object", {}) != {}
+    assert config_keys == ["expo_callsite_logging_layer::layer_with_many_params"]
+    statsig.flush_events().wait()
+    events = {
+        event["metadata"]["parameterName"]: event["metadata"]
+        for event in mock_scrapi.get_logged_events()
+        if event["eventName"] == "statsig::layer_exposure"
+    }
+    assert len(events) == 2
+    assert events["a_string"]["exposure_source_function"] == "layer_override"
+    assert events["an_object"]["exposure_source_function"] == "config_override"
+
+
+def test_layer_callsite_config_errors_still_return_value_and_log_exposure(
+    statsig_setup, capsys
+):
+    statsig, mock_scrapi = statsig_setup
+    layer = statsig.get_layer(
+        StatsigUser("broken-config-user"), "layer_with_many_params"
+    )
+
+    class BrokenConfigs(dict):
+        def get(self, key):
+            raise RuntimeError("broken callsite config")
+
+    statsig._internal_sdk_configs = BrokenConfigs()
+    assert layer.get_string("a_string", "ERR") != "ERR"
+    statsig.flush_events().wait()
+    assert "broken callsite config" in capsys.readouterr().out
+    events = [
+        event
+        for event in mock_scrapi.get_logged_events()
+        if event["eventName"] == "statsig::layer_exposure"
+    ]
+    assert len(events) == 1
+    assert "exposure_source_file" not in events[0]["metadata"]
+
+
 def test_sdk_configs_attach_callsite_metadata_to_manual_exposures(
     callsite_logging_setup,
 ):

{oai_statsig_python_core-0.34.0rc4 → oai_statsig_python_core-0.35.0}/statsig-rust/Cargo.toml

@@ -47,7 +47,7 @@ serde_json = { version = "1.0.151", features = [
 ] }
 serde_with = "3.23.0"
 sha2 = "0.11.0"
-oai-statsig-grpc = { path = "../statsig-grpc", version = "0.34.0-rc.4", optional = true }
+oai-statsig-grpc = { path = "../statsig-grpc", version = "0.35.0", optional = true }
 simple_logger = { version = "5.2.0" }
 tempfile = "3.27.0"
 tokio = { version = "1.53.1", features = ["full"] }
@@ -104,3 +104,13 @@ ordered_user_data_maps = ["dep:indexmap"]
 name = "fork_random"
 path = "tests/fork_random.rs"
 harness = false
+
+[[test]]
+name = "fork_lifecycle"
+path = "tests/fork_lifecycle.rs"
+harness = false
+
+[[test]]
+name = "fork_pid_change"
+path = "tests/fork_pid_change.rs"
+harness = false

{oai_statsig_python_core-0.34.0rc4 → oai_statsig_python_core-0.35.0}/statsig-rust/src/id_lists_adapter/id_list_cursor_tests.rs

@@ -159,6 +159,10 @@ async fn test_same_file_full_replay_updates_cursor_and_only_downloads_once() {
         .mock("GET", "/employees")
         .match_header("range", "bytes=0-")
         .with_status(206)
+        .with_header(
+            "content-range",
+            &format!("bytes 0-{}/{}", full_body.len() - 1, full_body.len()),
+        )
         .with_body(full_body)
         .expect(1)
         .create_async()
@@ -202,6 +206,15 @@ async fn test_same_file_full_replay_updates_cursor_and_only_downloads_once() {
         .mock("GET", "/employees")
         .match_header("range", format!("bytes={}-", full_body.len()).as_str())
         .with_status(206)
+        .with_header(
+            "content-range",
+            &format!(
+                "bytes {}-{}/{}",
+                full_body.len(),
+                metadata.size - 1,
+                metadata.size
+            ),
+        )
         .with_body(appended_body)
         .expect(1)
         .create_async()

{oai_statsig_python_core-0.34.0rc4 → oai_statsig_python_core-0.35.0}/statsig-rust/src/id_lists_adapter/id_list_download_concurrency_tests.rs

@@ -293,7 +293,7 @@ async fn id_list_concurrency_preserves_ranges_generations_unchanged_and_removal(
         ],
     );
     provider.manifest.lock().get_mut("grow").unwrap().size = 6;
-    provider.set("grow", Outcome::Body(b"+b\n".to_vec()));
+    provider.set("grow", Outcome::Body(b"+a\n+b\n".to_vec()));
     provider.set("replace", Outcome::Body(b"+b\n".to_vec()));
     let before = store.load_data();
     adapter.sync_id_lists().await.unwrap();
@@ -338,6 +338,7 @@ async fn id_list_concurrency_freezes_manifest_until_the_next_refresh() {
         .manifest
         .lock()
         .insert("a".into(), metadata("a", 8, 1));
+    provider.set("a", Outcome::Body(b"+old\n+a\n".to_vec()));
     let gate = provider.gate(&file_url("a"));
     let task = start(adapter.clone());
     until(|| provider.attempts("a") == 1).await;
@@ -356,6 +357,7 @@ async fn id_list_concurrency_freezes_manifest_until_the_next_refresh() {
     );
     assert!(store.load_data().id_lists["a"].ids.contains("old"));
 
+    provider.set("a", Outcome::Body(b"+a\n".to_vec()));
     gate.add_permits(1);
     adapter.sync_id_lists().await.unwrap();
     let second = provider.file_requests()[1].clone();

{oai_statsig_python_core-0.34.0rc4 → oai_statsig_python_core-0.35.0}/statsig-rust/src/id_lists_adapter/id_list_propagation.rs

@@ -103,29 +103,13 @@ impl IdListPropagationState {
     }
 }
 
-// Legacy downloads use this proof only for telemetry. Header-based CDN fallback
-// also validates the interval before applying the bytes as an incremental update.
-pub(super) fn downloaded_range(
-    status: Option<u16>,
-    content_range: Option<&str>,
-    requested_start: u64,
-    body_len: usize,
-    cdn_query_range: bool,
-) -> Option<Range<u64>> {
+// Validate the received interval before applying bytes or recording propagation.
+pub(super) fn downloaded_range(content_range: &str, body_len: usize) -> Option<Range<u64>> {
     let len = u64::try_from(body_len).ok()?;
-    if let Some(header) = content_range {
-        let (range, total) = header.strip_prefix("bytes ")?.split_once('/')?;
-        let (start, end) = range.split_once('-')?;
-        let start = start.parse::<u64>().ok()?;
-        let end = end.parse::<u64>().ok()?.checked_add(1)?;
-        let total = total.parse::<u64>().ok()?;
-        return (end <= total && end.checked_sub(start) == Some(len)).then_some(start..end);
-    }
-    // The default CDN implements ranges through a query parameter and returns HTTP 200.
-    // A normal HTTP server may ignore Range and return the entire file instead.
-    if status != Some(200) {
-        return None;
-    }
-    let start = if cdn_query_range { requested_start } else { 0 };
-    Some(start..start.checked_add(len)?)
+    let (range, total) = content_range.strip_prefix("bytes ")?.split_once('/')?;
+    let (start, end) = range.split_once('-')?;
+    let start = start.parse::<u64>().ok()?;
+    let end = end.parse::<u64>().ok()?.checked_add(1)?;
+    let total = total.parse::<u64>().ok()?;
+    (end <= total && end.checked_sub(start) == Some(len)).then_some(start..end)
 }