oai-statsig-python-core 0.37.0rc1__tar.gz → 0.37.0rc2__tar.gz

{oai_statsig_python_core-0.37.0rc1 → oai_statsig_python_core-0.37.0rc2}/Cargo.lock

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

{oai_statsig_python_core-0.37.0rc1 → oai_statsig_python_core-0.37.0rc2}/Cargo.toml

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

{oai_statsig_python_core-0.37.0rc1 → oai_statsig_python_core-0.37.0rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oai_statsig_python_core
-Version: 0.37.0rc1
+Version: 0.37.0rc2
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{oai_statsig_python_core-0.37.0rc1 → oai_statsig_python_core-0.37.0rc2}/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.37.0-rc.1", optional = true }
+oai-statsig-grpc = { path = "../statsig-grpc", version = "0.37.0-rc.2", optional = true }
 simple_logger = { version = "5.2.0" }
 tempfile = "3.27.0"
 tokio = { version = "1.53.1", features = ["full"] }

{oai_statsig_python_core-0.37.0rc1 → oai_statsig_python_core-0.37.0rc2}/statsig-rust/src/interned_values/__tests__/interned_store_mmap_fetch_tests.rs

@@ -7,11 +7,9 @@ use crate::{
     interned_values::{
         InternedStore, MmapArtifactState, MmapPreloadOptions, MmapSyncCursor, MmapWriteOutcome,
         interned_store::{
-            LEGACY_MMAP_FORMAT_VERSION, acquire_mmap_write_lock_for_test,
-            legacy_mmap_v1_path_for_sdk_key, mmap_lock_path_for_sdk_key,
+            acquire_mmap_write_lock_for_test, mmap_lock_path_for_sdk_key,
             mmap_manifest_path_for_sdk_key, mmap_v2_path_for_sdk_key, validate_mmap_v2_for_test,
             write_mmap_manifest_for_test, write_mmap_v2_for_test,
-            write_mmap_v2_only_manifest_for_test,
         },
         mmap_data_v2::{ArchivedMmapDataV2, MmapDataV2},
     },
@@ -68,7 +66,6 @@ const MMAP_CONCURRENT_SAME_KEY: &str = "interned-store-concurrent-same-key";
 const EVAL_PROJ_JSON: &str = include_str!("../../../tests/data/eval_proj_dcs.json");
 const EVAL_PROJ_PROTO: &[u8] = include_bytes!("../../../tests/data/eval_proj_dcs.pb.br");
 const BIG_NUMBER_JSON: &str = include_str!("../../../tests/data/big_number_dcs.json");
-const LEGACY_V1_TEST_BYTES: &[u8] = b"legacy v1 artifact";
 const DOWNLOAD_PATH_PREFIX: &str = "/v1/dynamic_config_value/";
 
 fn config_json_with_cursor(lcut: u64, checksum: Option<&str>) -> String {
@@ -182,8 +179,6 @@ fn query_params(request: &Request) -> HashMap<String, String> {
 #[tokio::test]
 async fn fetch_and_write_mmap_uses_header_auth_and_authoritative_storage_key() {
     let server = MockServer::start().await;
-    let v1_path = legacy_mmap_v1_path_for_sdk_key(MMAP_FETCH_SDK_KEY);
-    let _ = fs::remove_file(&v1_path);
     Mock::given(method("GET"))
         .and(path("/v2/download_config_specs"))
         .and(header("statsig-api-key", MMAP_FETCH_SDK_KEY))
@@ -208,7 +203,6 @@ async fn fetch_and_write_mmap_uses_header_auth_and_authoritative_storage_key() {
         "{}_v2_interned_store.mmap",
         hashing::djb2(MMAP_FETCH_SDK_KEY)
     );
-    assert!(!v1_path.exists());
     assert_eq!(
         v2_path.file_name().and_then(|name| name.to_str()),
         Some(expected_v2_filename.as_str())
@@ -1033,7 +1027,7 @@ rusty_fork_test! {
 
 #[cfg(unix)]
 #[tokio::test]
-async fn fetch_and_write_mmap_replaces_v2_and_leaves_v1_untouched() {
+async fn fetch_and_write_mmap_atomically_replaces_v2() {
     let server = MockServer::start().await;
     Mock::given(method("GET"))
         .and(path("/v2/download_config_specs"))
@@ -1045,12 +1039,9 @@ async fn fetch_and_write_mmap_replaces_v2_and_leaves_v1_untouched() {
         .mount(&server)
         .await;
 
-    let v1_path = legacy_mmap_v1_path_for_sdk_key(MMAP_REPLACE_SDK_KEY);
     let v2_path = mmap_v2_path_for_sdk_key(MMAP_REPLACE_SDK_KEY);
-    fs::create_dir_all(v1_path.parent().unwrap()).unwrap();
-    fs::write(&v1_path, b"previous v1 artifact").unwrap();
+    fs::create_dir_all(v2_path.parent().unwrap()).unwrap();
     fs::write(&v2_path, b"previous v2 artifact").unwrap();
-    let mut previous_v1_artifact = File::open(&v1_path).unwrap();
     let mut previous_v2_artifact = File::open(&v2_path).unwrap();
 
     InternedStore::fetch_and_write_mmap_with_specs_url(
@@ -1060,18 +1051,12 @@ async fn fetch_and_write_mmap_replaces_v2_and_leaves_v1_untouched() {
     .await
     .unwrap();
 
-    let mut previous_v1_contents = Vec::new();
-    previous_v1_artifact
-        .read_to_end(&mut previous_v1_contents)
-        .unwrap();
-    assert_eq!(previous_v1_contents, b"previous v1 artifact");
     let mut previous_v2_contents = Vec::new();
     previous_v2_artifact
         .read_to_end(&mut previous_v2_contents)
         .unwrap();
     assert_eq!(previous_v2_contents, b"previous v2 artifact");
 
-    assert_eq!(fs::read(&v1_path).unwrap(), b"previous v1 artifact");
     let published_v2 = fs::read(&v2_path).unwrap();
     assert_ne!(published_v2, b"previous v2 artifact");
     rkyv::access::<ArchivedMmapDataV2, rkyv::rancor::Error>(&published_v2).unwrap();
@@ -1187,10 +1172,6 @@ async fn uid_10001_can_preload_artifact_written_by_uid_1000() {
 
 #[test]
 fn mmap_paths_are_scoped_by_sdk_key() {
-    assert_ne!(
-        legacy_mmap_v1_path_for_sdk_key(MMAP_FETCH_SDK_KEY),
-        legacy_mmap_v1_path_for_sdk_key(OTHER_MMAP_FETCH_SDK_KEY)
-    );
     assert_ne!(
         mmap_v2_path_for_sdk_key(MMAP_FETCH_SDK_KEY),
         mmap_v2_path_for_sdk_key(OTHER_MMAP_FETCH_SDK_KEY)
@@ -1206,9 +1187,14 @@ fn mmap_paths_are_scoped_by_sdk_key() {
 }
 
 #[test]
-fn inspect_mmap_artifact_reports_missing_and_legacy_v1() {
-    let sdk_key = "interned-store-inspect-legacy-v1";
+fn inspect_mmap_artifact_ignores_retired_v1_artifacts() {
+    let sdk_key = "interned-store-inspect-retired-v1";
     remove_mmap_artifacts(sdk_key);
+    let retired_path = std::env::temp_dir()
+        .join("statsig-interned-store")
+        .join(format!("{}_v1_interned_store.mmap", hashing::djb2(sdk_key)));
+    fs::create_dir_all(retired_path.parent().unwrap()).unwrap();
+    fs::write(&retired_path, b"retired artifact is ignored").unwrap();
 
     let missing = InternedStore::inspect_mmap_artifact(sdk_key).unwrap();
     assert_eq!(missing.state, MmapArtifactState::Missing);
@@ -1219,21 +1205,8 @@ fn inspect_mmap_artifact_reports_missing_and_legacy_v1() {
     assert_eq!(missing.manifest_bytes, None);
     assert_eq!(missing.total_linked_bytes, 0);
     assert_eq!(missing.linked_file_count, 0);
-
-    let v1_path = legacy_mmap_v1_path_for_sdk_key(sdk_key);
-    fs::create_dir_all(v1_path.parent().unwrap()).unwrap();
-    fs::write(&v1_path, LEGACY_V1_TEST_BYTES).unwrap();
-
-    let legacy = InternedStore::inspect_mmap_artifact(sdk_key).unwrap();
-    assert_eq!(legacy.state, MmapArtifactState::LegacyV1);
-    assert_eq!(legacy.state.as_str(), "legacy_v1");
-    assert_eq!(legacy.format_version, Some(LEGACY_MMAP_FORMAT_VERSION));
-    assert_eq!(legacy.v1_bytes, Some(LEGACY_V1_TEST_BYTES.len() as u64));
-    assert_eq!(legacy.v2_bytes, None);
-    assert_eq!(legacy.manifest_bytes, None);
-    assert_eq!(legacy.total_linked_bytes, LEGACY_V1_TEST_BYTES.len() as u64);
-    assert_eq!(legacy.linked_file_count, 1);
-    assert!(legacy.newest_linked_modified_unix_seconds.is_some());
+    assert_eq!(missing.newest_linked_modified_unix_seconds, None);
+    fs::remove_file(retired_path).unwrap();
 }
 
 #[test]
@@ -1244,7 +1217,7 @@ fn inspect_mmap_artifact_reports_committed_and_incomplete_v2() {
     let manifest_path = mmap_manifest_path_for_sdk_key(sdk_key);
     fs::create_dir_all(v2_path.parent().unwrap()).unwrap();
     write_mmap_v2_for_test(EVAL_PROJ_JSON.as_bytes(), &v2_path).unwrap();
-    write_mmap_v2_only_manifest_for_test(&manifest_path, &v2_path).unwrap();
+    write_mmap_manifest_for_test(&manifest_path, &v2_path).unwrap();
 
     let committed = InternedStore::inspect_mmap_artifact(sdk_key).unwrap();
     let v2_bytes = fs::metadata(&v2_path).unwrap().len();
@@ -1283,39 +1256,25 @@ fn inspect_mmap_artifact_reports_committed_and_incomplete_v2() {
 }
 
 #[test]
-fn inspect_mmap_artifact_reports_v1_fallback_after_identity_failure() {
-    let sdk_key = "interned-store-inspect-v1-fallback";
+fn inspect_mmap_artifact_reports_invalid_manifest() {
+    let sdk_key = "interned-store-inspect-invalid-manifest";
     remove_mmap_artifacts(sdk_key);
-    let v1_path = legacy_mmap_v1_path_for_sdk_key(sdk_key);
     let v2_path = mmap_v2_path_for_sdk_key(sdk_key);
     let manifest_path = mmap_manifest_path_for_sdk_key(sdk_key);
-    fs::create_dir_all(v1_path.parent().unwrap()).unwrap();
-    fs::write(&v1_path, LEGACY_V1_TEST_BYTES).unwrap();
+    fs::create_dir_all(v2_path.parent().unwrap()).unwrap();
     write_mmap_v2_for_test(EVAL_PROJ_JSON.as_bytes(), &v2_path).unwrap();
-    write_mmap_manifest_for_test(&manifest_path, &v1_path, &v2_path).unwrap();
-
-    let replacement = tempfile::NamedTempFile::new_in(v2_path.parent().unwrap()).unwrap();
-    fs::write(replacement.path(), b"replacement v2 generation").unwrap();
-    replacement.persist(&v2_path).unwrap();
-
-    let fallback = InternedStore::inspect_mmap_artifact(sdk_key).unwrap();
-    assert_eq!(fallback.state, MmapArtifactState::FallbackV1);
-    assert_eq!(fallback.state.as_str(), "fallback_v1");
-    assert_eq!(fallback.format_version, Some(LEGACY_MMAP_FORMAT_VERSION));
-    assert_eq!(fallback.v1_bytes, Some(LEGACY_V1_TEST_BYTES.len() as u64));
-    assert_eq!(
-        fallback.v2_bytes,
-        Some(b"replacement v2 generation".len() as u64)
-    );
-    assert!(fallback.manifest_bytes.is_some());
-    assert_eq!(fallback.linked_file_count, 3);
+    fs::write(&manifest_path, b"invalid manifest").unwrap();
 
-    fs::remove_file(v1_path).unwrap();
     let invalid = InternedStore::inspect_mmap_artifact(sdk_key).unwrap();
     assert_eq!(invalid.state, MmapArtifactState::Invalid);
     assert_eq!(invalid.state.as_str(), "invalid");
     assert_eq!(invalid.format_version, None);
     assert_eq!(invalid.v1_bytes, None);
+    assert_eq!(invalid.v2_bytes, Some(fs::metadata(v2_path).unwrap().len()));
+    assert_eq!(
+        invalid.manifest_bytes,
+        Some(b"invalid manifest".len() as u64)
+    );
     assert_eq!(invalid.linked_file_count, 2);
 }
 
@@ -1353,7 +1312,6 @@ fn sdk_key_write_lock_rejects_a_second_file_handle() {
 
 fn remove_mmap_artifacts(sdk_key: &str) {
     for path in [
-        legacy_mmap_v1_path_for_sdk_key(sdk_key),
         mmap_v2_path_for_sdk_key(sdk_key),
         mmap_manifest_path_for_sdk_key(sdk_key),
         mmap_lock_path_for_sdk_key(sdk_key),
@@ -1366,15 +1324,13 @@ fn remove_mmap_artifacts(sdk_key: &str) {
 #[test]
 fn committed_v2_validation_keeps_the_validated_file_handle() {
     let sdk_key = "interned-store-open-handle";
-    let v1_path = legacy_mmap_v1_path_for_sdk_key(sdk_key);
     let v2_path = mmap_v2_path_for_sdk_key(sdk_key);
     let manifest_path = mmap_manifest_path_for_sdk_key(sdk_key);
-    fs::create_dir_all(v1_path.parent().unwrap()).unwrap();
-    fs::write(&v1_path, b"paired v1 generation").unwrap();
+    fs::create_dir_all(v2_path.parent().unwrap()).unwrap();
     write_mmap_v2_for_test(EVAL_PROJ_JSON.as_bytes(), &v2_path).unwrap();
-    write_mmap_manifest_for_test(&manifest_path, &v1_path, &v2_path).unwrap();
+    write_mmap_manifest_for_test(&manifest_path, &v2_path).unwrap();
 
-    let validated = open_committed_mmap_v2_for_test(&manifest_path, &v1_path, &v2_path)
+    let validated = open_committed_mmap_v2_for_test(&manifest_path, &v2_path)
         .unwrap()
         .unwrap();
     let replacement = tempfile::NamedTempFile::new_in(v2_path.parent().unwrap()).unwrap();
@@ -1388,15 +1344,18 @@ fn committed_v2_validation_keeps_the_validated_file_handle() {
 
 rusty_fork_test! {
     #[test]
-    fn preload_mmap_prefers_v2_when_both_artifacts_exist() {
-        let sdk_key = "interned-store-prefer-v2";
-        let v1_path = legacy_mmap_v1_path_for_sdk_key(sdk_key);
+    fn preload_mmap_ignores_retired_manifest_metadata() {
+        let sdk_key = "interned-store-retired-manifest-metadata";
         let v2_path = mmap_v2_path_for_sdk_key(sdk_key);
         let manifest_path = mmap_manifest_path_for_sdk_key(sdk_key);
-        fs::create_dir_all(v1_path.parent().unwrap()).unwrap();
-        fs::write(&v1_path, b"malformed v1 that must not be read").unwrap();
+        fs::create_dir_all(v2_path.parent().unwrap()).unwrap();
         write_mmap_v2_for_test(EVAL_PROJ_JSON.as_bytes(), &v2_path).unwrap();
-        write_mmap_manifest_for_test(&manifest_path, &v1_path, &v2_path).unwrap();
+        write_mmap_manifest_for_test(&manifest_path, &v2_path).unwrap();
+        let mut manifest: serde_json::Value =
+            serde_json::from_slice(&fs::read(&manifest_path).unwrap()).unwrap();
+        // Old paired manifests remain readable without a V1 artifact.
+        manifest["v1"] = manifest["v2"].clone();
+        fs::write(&manifest_path, serde_json::to_vec(&manifest).unwrap()).unwrap();
 
         InternedStore::preload_mmap(sdk_key).unwrap();
         let specs: SpecsResponseFull = serde_json::from_str(EVAL_PROJ_JSON).unwrap();
@@ -1406,15 +1365,13 @@ rusty_fork_test! {
     }
 
     #[test]
-    fn preload_mmap_accepts_v2_only_manifest_without_v1() {
+    fn preload_mmap_accepts_committed_v2_manifest() {
         let sdk_key = "interned-store-v2-only-manifest";
-        let v1_path = legacy_mmap_v1_path_for_sdk_key(sdk_key);
         let v2_path = mmap_v2_path_for_sdk_key(sdk_key);
         let manifest_path = mmap_manifest_path_for_sdk_key(sdk_key);
         fs::create_dir_all(v2_path.parent().unwrap()).unwrap();
-        let _ = fs::remove_file(v1_path);
         write_mmap_v2_for_test(EVAL_PROJ_JSON.as_bytes(), &v2_path).unwrap();
-        write_mmap_v2_only_manifest_for_test(&manifest_path, &v2_path).unwrap();
+        write_mmap_manifest_for_test(&manifest_path, &v2_path).unwrap();
 
         let report = InternedStore::preload_mmap_with_options(
             sdk_key,
@@ -1430,20 +1387,16 @@ rusty_fork_test! {
     }
 
     #[test]
-    fn preload_mmap_multi_rejects_a_legacy_only_required_key() {
-        let required_key = "interned-store-multi-legacy-only-required";
+    fn preload_mmap_multi_rejects_a_missing_required_key() {
+        let required_key = "interned-store-multi-missing-required";
         let optional_key = "interned-store-multi-committed-optional";
         remove_mmap_artifacts(required_key);
         remove_mmap_artifacts(optional_key);
 
-        let required_v1_path = legacy_mmap_v1_path_for_sdk_key(required_key);
-        fs::create_dir_all(required_v1_path.parent().unwrap()).unwrap();
-        fs::write(&required_v1_path, b"legacy artifact must not be preloaded").unwrap();
-
         let optional_v2_path = mmap_v2_path_for_sdk_key(optional_key);
         let optional_manifest_path = mmap_manifest_path_for_sdk_key(optional_key);
         write_mmap_v2_for_test(EVAL_PROJ_JSON.as_bytes(), &optional_v2_path).unwrap();
-        write_mmap_v2_only_manifest_for_test(&optional_manifest_path, &optional_v2_path)
+        write_mmap_manifest_for_test(&optional_manifest_path, &optional_v2_path)
             .unwrap();
 
         assert!(matches!(
@@ -1461,7 +1414,7 @@ rusty_fork_test! {
         let manifest_path = mmap_manifest_path_for_sdk_key(required_key);
         fs::create_dir_all(v2_path.parent().unwrap()).unwrap();
         write_mmap_v2_for_test(EVAL_PROJ_JSON.as_bytes(), &v2_path).unwrap();
-        write_mmap_v2_only_manifest_for_test(&manifest_path, &v2_path).unwrap();
+        write_mmap_manifest_for_test(&manifest_path, &v2_path).unwrap();
         let _ = fs::remove_file(mmap_manifest_path_for_sdk_key(optional_key));
 
         let report =
@@ -1475,15 +1428,13 @@ rusty_fork_test! {
     }
 
     #[test]
-    fn preload_mmap_retries_during_v2_only_refresh() {
+    fn preload_mmap_retries_during_refresh() {
         let sdk_key = "interned-store-v2-only-refresh";
-        let v1_path = legacy_mmap_v1_path_for_sdk_key(sdk_key);
         let v2_path = mmap_v2_path_for_sdk_key(sdk_key);
         let manifest_path = mmap_manifest_path_for_sdk_key(sdk_key);
-        fs::create_dir_all(v1_path.parent().unwrap()).unwrap();
-        fs::write(&v1_path, b"stale v1 generation").unwrap();
+        fs::create_dir_all(v2_path.parent().unwrap()).unwrap();
         write_mmap_v2_for_test(EVAL_PROJ_JSON.as_bytes(), &v2_path).unwrap();
-        write_mmap_v2_only_manifest_for_test(&manifest_path, &v2_path).unwrap();
+        write_mmap_manifest_for_test(&manifest_path, &v2_path).unwrap();
 
         let replacement = tempfile::NamedTempFile::new_in(v2_path.parent().unwrap()).unwrap();
         fs::write(replacement.path(), b"next v2 generation").unwrap();
@@ -1496,26 +1447,6 @@ rusty_fork_test! {
         ));
     }
 
-    #[test]
-    fn preload_mmap_rejects_v2_when_paired_v1_was_replaced() {
-        let sdk_key = "interned-store-v1-only-refresh";
-        let v1_path = legacy_mmap_v1_path_for_sdk_key(sdk_key);
-        let v2_path = mmap_v2_path_for_sdk_key(sdk_key);
-        let manifest_path = mmap_manifest_path_for_sdk_key(sdk_key);
-        fs::create_dir_all(v1_path.parent().unwrap()).unwrap();
-        fs::write(&v1_path, b"old v1 generation").unwrap();
-        write_mmap_v2_for_test(EVAL_PROJ_JSON.as_bytes(), &v2_path).unwrap();
-        write_mmap_manifest_for_test(&manifest_path, &v1_path, &v2_path).unwrap();
-
-        fs::write(&v1_path, b"replacement v1 generation").unwrap();
-
-        assert!(matches!(
-            InternedStore::preload_mmap(sdk_key),
-            Err(StatsigErr::InvalidOperation(message))
-                if message == "No committed interned mmap V2 artifact was found"
-        ));
-    }
-
     #[cfg(target_os = "linux")]
     #[test]
     fn mmap_reader_memory_snapshot_tracks_deleted_loaded_generation() {
@@ -1525,7 +1456,7 @@ rusty_fork_test! {
         let manifest_path = mmap_manifest_path_for_sdk_key(sdk_key);
         fs::create_dir_all(v2_path.parent().unwrap()).unwrap();
         write_mmap_v2_for_test(EVAL_PROJ_JSON.as_bytes(), &v2_path).unwrap();
-        write_mmap_v2_only_manifest_for_test(&manifest_path, &v2_path).unwrap();
+        write_mmap_manifest_for_test(&manifest_path, &v2_path).unwrap();
         let expected_mapped_bytes = fs::metadata(&v2_path).unwrap().len();
 
         InternedStore::preload_mmap(sdk_key).unwrap();
@@ -1560,7 +1491,7 @@ rusty_fork_test! {
         let manifest_path = mmap_manifest_path_for_sdk_key(sdk_key);
         fs::create_dir_all(v2_path.parent().unwrap()).unwrap();
         fs::write(&v2_path, b"malformed v2").unwrap();
-        write_mmap_v2_only_manifest_for_test(&manifest_path, &v2_path).unwrap();
+        write_mmap_manifest_for_test(&manifest_path, &v2_path).unwrap();
 
         assert!(matches!(
             InternedStore::preload_mmap(sdk_key),
@@ -1576,7 +1507,7 @@ fn preload_mmap_rejects_malformed_archive() {
     let manifest_path = mmap_manifest_path_for_sdk_key(sdk_key);
     fs::create_dir_all(path.parent().unwrap()).unwrap();
     fs::write(&path, b"not an rkyv archive").unwrap();
-    write_mmap_v2_only_manifest_for_test(&manifest_path, &path).unwrap();
+    write_mmap_manifest_for_test(&manifest_path, &path).unwrap();
 
     assert!(matches!(
         InternedStore::preload_mmap(sdk_key),
@@ -1597,7 +1528,7 @@ fn preload_mmap_rejects_unsupported_format_version() {
     };
     let archived = rkyv::to_bytes::<rkyv::rancor::Error>(&mmap_data).unwrap();
     fs::write(&path, archived).unwrap();
-    write_mmap_v2_only_manifest_for_test(&manifest_path, &path).unwrap();
+    write_mmap_manifest_for_test(&manifest_path, &path).unwrap();
 
     assert!(matches!(
         InternedStore::preload_mmap(sdk_key),

{oai_statsig_python_core-0.37.0rc1 → oai_statsig_python_core-0.37.0rc2}/statsig-rust/src/interned_values/interned_store/mmap_artifact.rs

@@ -3,7 +3,7 @@ use std::{fs::Metadata, path::Path, time::UNIX_EPOCH};
 use crate::StatsigErr;
 
 use super::{
-    InternedStore, LEGACY_MMAP_FORMAT_VERSION, legacy_mmap_v1_path_for_sdk_key,
+    InternedStore,
     mmap_manifest::{MmapV2Publication, inspect_mmap_v2_publication},
     mmap_manifest_path_for_sdk_key, mmap_v2_path_for_sdk_key,
 };
@@ -11,24 +11,24 @@ use super::{
 /// Describes the interned mmap artifacts linked at the SDK-owned location.
 ///
 /// This intentionally omits the SDK key, filesystem path, and platform-specific
-/// file identity used to validate publication. V1 states are informational;
-/// the V2-only reader rejects them.
+/// file identity used to validate publication.
 #[non_exhaustive]
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum MmapArtifactState {
-    /// No V1 artifact or V2 publication is linked at the SDK-owned location.
+    /// No V2 publication is linked at the SDK-owned location.
     Missing,
-    /// A legacy V1 artifact is linked and no V2 publication was observed.
+    /// Retained for source compatibility. Artifact inspection no longer returns
+    /// this state because V1 artifacts are unsupported.
     LegacyV1,
-    /// A V2 publication failed manifest identity validation while a legacy V1
-    /// artifact remains linked.
+    /// Retained for source compatibility. Artifact inspection no longer returns
+    /// this state because V1 artifacts are unsupported.
     FallbackV1,
     /// The V2 artifact and manifest identities match.
     CommittedV2,
-    /// A V2-only artifact and manifest do not form a committed identity, so
-    /// readers must retry rather than fall back.
+    /// The V2 artifact and manifest do not form a committed identity, so
+    /// readers must retry.
     IncompleteV2,
-    /// V2 publication validation failed and no V1 fallback is linked.
+    /// V2 publication validation failed.
     Invalid,
 }
 
@@ -48,21 +48,22 @@ impl MmapArtifactState {
 
 /// Safe metadata for an SDK-owned interned mmap artifact.
 ///
-/// Byte counts cover only currently linked V1, V2, and manifest files. They do
+/// Byte counts cover only currently linked V2 and manifest files. They do
 /// not include unlinked generations that remain mapped by readers or transient
 /// writer files. State and format reflect a reader-selectable publication
 /// observed during inspection. Linked file sizes and modification times are
 /// best-effort and may span a concurrent atomic publication. Filesystem
 /// capacity is best-effort and is omitted on unsupported platforms or when the
-/// backing filesystem cannot be inspected. A reported V1 format is not
-/// selectable by the V2-only reader.
+/// backing filesystem cannot be inspected.
 #[non_exhaustive]
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct MmapArtifactSnapshot {
     pub state: MmapArtifactState,
-    /// Format of the linked legacy or committed artifact. Unavailable or
+    /// Format of the committed artifact. Unavailable or
     /// invalid artifacts report `None`.
     pub format_version: Option<u32>,
+    /// Retained for source compatibility. Always `None`; V1 artifacts are no
+    /// longer inspected or included in linked file totals.
     pub v1_bytes: Option<u64>,
     pub v2_bytes: Option<u64>,
     pub manifest_bytes: Option<u64>,
@@ -80,22 +81,15 @@ impl InternedStore {
     ///
     /// V2 state uses the same committed-manifest identity validation as
     /// `preload_mmap`. The snapshot is informational and does not map or parse
-    /// either archived config payload.
+    /// the archived config payload.
     pub fn inspect_mmap_artifact(sdk_key: &str) -> Result<MmapArtifactSnapshot, StatsigErr> {
-        let v1_path = legacy_mmap_v1_path_for_sdk_key(sdk_key);
         let v2_path = mmap_v2_path_for_sdk_key(sdk_key);
         let manifest_path = mmap_manifest_path_for_sdk_key(sdk_key);
 
-        let publication = inspect_mmap_v2_publication(&manifest_path, &v1_path, &v2_path)?;
-        let v1_metadata = metadata_if_linked(&v1_path)?;
+        let publication = inspect_mmap_v2_publication(&manifest_path, &v2_path)?;
         let manifest_metadata = metadata_if_linked(&manifest_path)?;
 
         let (state, format_version, committed_v2_metadata) = match publication {
-            MmapV2Publication::Absent if v1_metadata.is_some() => (
-                MmapArtifactState::LegacyV1,
-                Some(LEGACY_MMAP_FORMAT_VERSION),
-                None,
-            ),
             MmapV2Publication::Absent => (MmapArtifactState::Missing, None, None),
             MmapV2Publication::Committed(file) => {
                 let metadata = file
@@ -108,11 +102,6 @@ impl InternedStore {
                 )
             }
             MmapV2Publication::Incomplete => (MmapArtifactState::IncompleteV2, None, None),
-            MmapV2Publication::Invalid(_) if v1_metadata.is_some() => (
-                MmapArtifactState::FallbackV1,
-                Some(LEGACY_MMAP_FORMAT_VERSION),
-                None,
-            ),
             MmapV2Publication::Invalid(_) => (MmapArtifactState::Invalid, None, None),
         };
 
@@ -120,26 +109,22 @@ impl InternedStore {
             Some(metadata) => Some(metadata),
             None => metadata_if_linked(&v2_path)?,
         };
-        let v1_bytes = v1_metadata.as_ref().map(Metadata::len);
         let v2_bytes = v2_metadata.as_ref().map(Metadata::len);
         let manifest_bytes = manifest_metadata.as_ref().map(Metadata::len);
-        let total_linked_bytes = [v1_bytes, v2_bytes, manifest_bytes]
+        let total_linked_bytes = [v2_bytes, manifest_bytes]
             .into_iter()
             .flatten()
             .fold(0_u64, u64::saturating_add);
-        let linked_file_count = [v1_bytes, v2_bytes, manifest_bytes]
+        let linked_file_count = [v2_bytes, manifest_bytes]
             .into_iter()
             .filter(Option::is_some)
             .count() as u64;
-        let newest_linked_modified_unix_seconds = [
-            v1_metadata.as_ref(),
-            v2_metadata.as_ref(),
-            manifest_metadata.as_ref(),
-        ]
-        .into_iter()
-        .flatten()
-        .filter_map(modified_unix_seconds)
-        .max();
+        let newest_linked_modified_unix_seconds =
+            [v2_metadata.as_ref(), manifest_metadata.as_ref()]
+                .into_iter()
+                .flatten()
+                .filter_map(modified_unix_seconds)
+                .max();
         let (filesystem_capacity_bytes, filesystem_available_bytes) = manifest_path
             .parent()
             .map(filesystem_space)
@@ -148,7 +133,7 @@ impl InternedStore {
         Ok(MmapArtifactSnapshot {
             state,
             format_version,
-            v1_bytes,
+            v1_bytes: None,
             v2_bytes,
             manifest_bytes,
             total_linked_bytes,