[release] v0.128.2

.entire/settings.json

@@ -1,6 +1,9 @@
 {
   "enabled": true,
   "telemetry": false,
+  "strategy_options": {
+    "push_sessions": false
+  },
   "checkpoints": {
     "primary": {
       "type": "git-refs"

api/AGENTS.md

@@ -74,10 +74,12 @@ Project membership and access:
 - `check_action_access` delegates to `AccessService.check_request`. Every process that
   checks access calls `bootstrap_access()` at startup (the API and both workers do).
 - No new code reads `workspace_members` or `project_members` to decide access.
-- No code creates or updates `workspaces` or `workspace_members` rows or writes
-  `projects.workspace_id` (workspace removal step 2). The API answers the organization id
-  where a workspace id was. Legacy workspace ids still map to their organization through
-  `db_manager` (`_WORKSPACE_REF_CTE`, `get_workspace`) until step 2b removes those reads.
+- No deployed code reads or writes `workspaces`, `workspace_members`,
+  `projects.workspace_id` or `meters.workspace_id`, and the runtime ORM maps none of them
+  (workspace removal step 2b; step 3 drops them). The API answers the organization id where
+  a workspace id was, and a legacy workspace id is an unknown id. Migrations that need
+  these objects use frozen models, never `oss.src.models.db_models`.
+  `unit/memberships/test_workspace_storage_unread.py` pins it.
 - A hot-path membership read is one SQL statement (`fetch_membership_row`,
   `list_membership_rows`). `integration/memberships/test_hot_path_query_counts_postgres.py`
   pins the counts.

api/ee/databases/postgres/migrations/core/data_migrations/applications_workflow.py

@@ -10,8 +10,13 @@
 from sqlalchemy import func, text
 from sqlalchemy.ext.asyncio import AsyncConnection, create_async_engine
 
-from oss.src.models.db_models import WorkspaceMemberDB as WorkspaceMemberDBE
-from oss.src.models.db_models import ProjectDB as ProjectDBE
+# Frozen legacy schema: the runtime models no longer map workspaces.
+from ee.databases.postgres.migrations.core.deprecated_models import (
+    DeprecatedWorkspaceMemberDB as WorkspaceMemberDBE,
+)
+from ee.databases.postgres.migrations.core.deprecated_models import (
+    DeprecatedProjectDB as ProjectDBE,
+)
 from oss.databases.postgres.migrations.core.deprecated_models import (
     AppDB,
     AppVariantDB,

api/ee/databases/postgres/migrations/core/data_migrations/default_environments.py

@@ -8,7 +8,10 @@
 from sqlalchemy.ext.asyncio import AsyncConnection, create_async_engine
 from sqlalchemy.future import select
 
-from oss.src.models.db_models import WorkspaceMemberDB as WorkspaceMemberDBE
+# Frozen legacy schema: the runtime models no longer map workspaces.
+from ee.databases.postgres.migrations.core.deprecated_models import (
+    DeprecatedWorkspaceMemberDB as WorkspaceMemberDBE,
+)
 from oss.src.core.environments.dtos import (
     EnvironmentCreate,
     EnvironmentRevisionCommit,
@@ -22,7 +25,9 @@
     EnvironmentVariantDBE,
 )
 from oss.src.dbs.postgres.git.dao import GitDAO
-from oss.src.models.db_models import ProjectDB as ProjectDBE
+from ee.databases.postgres.migrations.core.deprecated_models import (
+    DeprecatedProjectDB as ProjectDBE,
+)
 
 DEFAULT_BATCH_SIZE = 200
 DEFAULT_ENVIRONMENTS = ("development", "staging", "production")

api/ee/databases/postgres/migrations/core/data_migrations/demos.py

@@ -13,15 +13,19 @@
 from sqlalchemy.future import select
 
 from oss.src.models.db_models import (
-    ProjectDB,
     UserDB,
 )
 from oss.src.models.db_models import (
     OrganizationMemberDB,
-    WorkspaceMemberDB,
     ProjectMemberDB,
 )
 
+# Frozen legacy schema: the runtime models no longer map workspaces.
+from ee.databases.postgres.migrations.core.deprecated_models import (
+    DeprecatedProjectDB as ProjectDB,
+    DeprecatedWorkspaceMemberDB as WorkspaceMemberDB,
+)
+
 
 BATCH_SIZE = 100
 DEMOS = "AGENTA_DEMOS"

api/ee/databases/postgres/migrations/core/data_migrations/environments.py

@@ -11,7 +11,9 @@
 from sqlalchemy.future import select
 from sqlalchemy.ext.asyncio import AsyncConnection, create_async_engine
 
-from oss.src.models.db_models import ProjectDB as ProjectDBE
+from ee.databases.postgres.migrations.core.deprecated_models import (
+    DeprecatedProjectDB as ProjectDBE,
+)
 from oss.databases.postgres.migrations.core.deprecated_models import (
     AppDB,
     AppVariantDB,
@@ -36,7 +38,11 @@
     EnvironmentRevisionData,
 )
 from oss.src.core.shared.dtos import Reference
-from oss.src.models.db_models import WorkspaceMemberDB as WorkspaceMemberDBE
+
+# Frozen legacy schema: the runtime models no longer map workspaces.
+from ee.databases.postgres.migrations.core.deprecated_models import (
+    DeprecatedWorkspaceMemberDB as WorkspaceMemberDBE,
+)
 
 
 # Define constants

api/ee/databases/postgres/migrations/core/data_migrations/evaluators.py

@@ -9,8 +9,13 @@
 from sqlalchemy import func
 from sqlalchemy.ext.asyncio import AsyncConnection, create_async_engine
 
-from oss.src.models.db_models import WorkspaceMemberDB as WorkspaceMemberDBE
-from oss.src.models.db_models import ProjectDB as ProjectDBE
+# Frozen legacy schema: the runtime models no longer map workspaces.
+from ee.databases.postgres.migrations.core.deprecated_models import (
+    DeprecatedWorkspaceMemberDB as WorkspaceMemberDBE,
+)
+from ee.databases.postgres.migrations.core.deprecated_models import (
+    DeprecatedProjectDB as ProjectDBE,
+)
 from oss.databases.postgres.migrations.core.deprecated_models import EvaluatorConfigDB
 from oss.src.dbs.postgres.workflows.dbes import (
     WorkflowArtifactDBE,

api/ee/databases/postgres/migrations/core/data_migrations/testsets.py

@@ -11,8 +11,13 @@
 from sqlalchemy import func
 from sqlalchemy.ext.asyncio import AsyncConnection, create_async_engine
 
-from oss.src.models.db_models import WorkspaceMemberDB as WorkspaceMemberDBE
-from oss.src.models.db_models import ProjectDB as ProjectDBE
+# Frozen legacy schema: the runtime models no longer map workspaces.
+from ee.databases.postgres.migrations.core.deprecated_models import (
+    DeprecatedWorkspaceMemberDB as WorkspaceMemberDBE,
+)
+from ee.databases.postgres.migrations.core.deprecated_models import (
+    DeprecatedProjectDB as ProjectDBE,
+)
 from oss.src.dbs.postgres.testcases.dbes import (
     TestcaseBlobDBE,
 )

api/ee/databases/postgres/migrations/core_ee/versions/ee0000000009_refold_meters_without_workspace.py

@@ -0,0 +1,64 @@
+"""fold the meter rows that still carry a workspace (rerun of ee0000000007)
+
+Step 2b of workspace removal (design.md D7, meter-scope spec "Re-keying keeps every
+count"). During the step 2 rollout, pods of the release before it (step 1) still
+counted per-user `TRACES_RETRIEVED` under ids with a workspace part, after
+ee0000000007 had moved every such row. Step-2 code never read those rows as current
+and bumped them by their stored id. From this release on, code no longer reads
+`meters.workspace_id`, so this revision folds those rows into their step-2 ids first.
+
+It runs ee0000000007's `run` unchanged: the same refusals before any write, the same
+`meters:report` lock for the whole run, the same keyset walk in batches of 1000, one
+statement per batch that adds `value` and `synced` into the row with the new id, each
+batch in its own transaction with `lock_timeout = 2s` and `statement_timeout = 60s`.
+With no row to fold, it takes no lock and needs no Redis.
+
+Idempotent: a rerun finds no row with a workspace. One-way like ee0000000007:
+`downgrade()` does nothing; restore the pre-release dump of `meters` to undo it. Data
+only, so the migration gate reports no finding.
+
+Revision ID: ee0000000009
+Revises: ee0000000008
+Create Date: 2026-10-28 00:00:00.000000
+"""
+
+import importlib.util
+from pathlib import Path
+from typing import Sequence, Union
+
+from alembic import op
+from sqlalchemy import text
+
+revision: str = "ee0000000009"
+down_revision: Union[str, None] = "ee0000000008"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+_STEP_2_REVISION = "ee0000000007_rekey_meters_without_workspace.py"
+
+
+def _step_2_revision():
+    """ee0000000007, loaded from its file (revision files are not a package)."""
+
+    path = Path(__file__).with_name(_STEP_2_REVISION)
+    spec = importlib.util.spec_from_file_location("_ee0000000007", path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def upgrade() -> None:
+    with op.get_context().autocommit_block():
+        connection = op.get_bind()
+        connection.execute(text("SET lock_timeout = '2s'"))
+        connection.execute(text("SET statement_timeout = '60s'"))
+        try:
+            _step_2_revision().run(connection)
+        finally:
+            connection.execute(text("RESET lock_timeout"))
+            connection.execute(text("RESET statement_timeout"))
+
+
+def downgrade() -> None:
+    """One-way data change, as ee0000000007. Restore the pre-release dump of `meters`
+    to undo it."""

api/ee/src/dbs/postgres/meters/dao.py

@@ -336,9 +336,6 @@ async def fetch(
                 )
             ):
                 stmt = stmt.filter_by(organization_id=scope.organization_id)
-                # A row with a workspace is legacy (a step-1 pod wrote it during the
-                # rollout): never the current row; the next fold merges it.
-                stmt = stmt.filter(MeterDBE.workspace_id.is_(None))
                 stmt = stmt.filter_by(project_id=scope.project_id)
                 stmt = stmt.filter_by(user_id=scope.user_id)
 

api/ee/src/dbs/postgres/meters/dbes.py

@@ -36,7 +36,7 @@ class MeterDBE(Base, MeterDBA):
         ),
         # Org-rollup scan path used by /billing/usage (filter on org only) and
         # entitlements soft-check fallback (filter on the full prefix).
-        # Finer scope dimensions (workspace/project/user) are sparse and always
+        # Finer scope dimensions (project/user) are sparse and always
         # filtered alongside `organization_id`, so PG handles them in-memory
         # against the rows this index narrows down.
         Index(

api/ee/tests/pytest/integration/meters/test_meters_refold_postgres.py

@@ -0,0 +1,155 @@
+"""Revision `ee0000000009` (step 2b fold of meter rows that still carry a workspace).
+
+ee0000000007 moved every row with a workspace. During the step 2 rollout, step-1 pods
+could still write a per-user `TRACES_RETRIEVED` row under its old id (a straggler).
+ee0000000009 reruns the same walk, so the straggler is added into the re-keyed row and
+no row keeps a workspace before step 2b code stops reading the column.
+
+Each case seeds its own organization and limits the walk to it.
+"""
+
+import functools
+import importlib.util
+from pathlib import Path
+from types import SimpleNamespace
+from uuid import uuid4
+
+import pytest
+
+from oss.src.dbs.postgres.shared.engine import get_transactions_engine
+from oss.tests.pytest.utils.membership_seed import (
+    delete_seeded_organization,
+    seed_organization,
+)
+from ee.tests.pytest.integration.meters.test_meters_rekey_postgres import (
+    _FakeRedis,
+    _id,
+    _insert,
+    _meters,
+)
+
+
+pytestmark = pytest.mark.integration
+
+_VERSIONS = (
+    Path(__file__).resolve().parents[4]
+    / "databases/postgres/migrations/core_ee/versions"
+)
+
+
+@functools.lru_cache(maxsize=1)
+def _revision():
+    path = _VERSIONS / "ee0000000009_refold_meters_without_workspace.py"
+    spec = importlib.util.spec_from_file_location("_revision_ee009", path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def _run(organization_ids):
+    step_2 = _revision()._step_2_revision()
+
+    async def run():
+        engine = get_transactions_engine()._engine
+        async with engine.connect() as connection:
+            connection = await connection.execution_options(
+                isolation_level="AUTOCOMMIT"
+            )
+            return await connection.run_sync(
+                lambda sync: step_2.run(
+                    sync,
+                    organization_ids=organization_ids,
+                    lock=step_2.ReportLock(_FakeRedis()),
+                )
+            )
+
+    return run()
+
+
+@pytest.fixture
+async def org():
+    seeded = await seed_organization(members={"m": "editor"})
+    yield SimpleNamespace(
+        id=seeded.organization_id,
+        ws=seeded.workspace_ids[0],
+        prj=seeded.project_ids[0],
+        usr=seeded.user_ids["m"],
+    )
+    await delete_seeded_organization(seeded)
+
+
+def test_ee009_follows_ee008_and_reuses_ee007_run():
+    revision = _revision()
+    assert (revision.revision, revision.down_revision) == (
+        "ee0000000009",
+        "ee0000000008",
+    )
+    step_2 = revision._step_2_revision()
+    assert step_2.revision == "ee0000000007"
+    assert callable(step_2.run)
+
+
+async def test_ee009_folds_a_straggler_into_the_rekeyed_row(org):
+    # ee0000000007 already moved the row: it has the step-2 id and no workspace.
+    await _insert(org=org.id, wrk=None, prj=org.prj, usr=org.usr, value=40, synced=30)
+    # A step-1 pod counted three more reads under the old id after the move.
+    await _insert(org=org.id, wrk=org.ws, prj=org.prj, usr=org.usr, value=3, synced=1)
+    counts = await _run([org.id])
+    rows = await _meters(org.id)
+    new_id = _id(org=org.id, prj=org.prj, usr=org.usr)
+    assert list(rows) == [new_id]
+    assert (rows[new_id]["value"], rows[new_id]["synced"]) == (43, 31)
+    assert rows[new_id]["workspace_id"] is None
+    assert counts["rows"] == 1
+
+
+async def test_ee009_leaves_no_row_with_a_workspace_and_is_idempotent(org):
+    await _insert(org=org.id, wrk=None, prj=org.prj, usr=org.usr, value=4, synced=4)
+    await _insert(org=org.id, wrk=uuid4(), prj=org.prj, usr=org.usr, value=2, synced=0)
+    await _run([org.id])
+    after_first = await _meters(org.id)
+    assert all(row["workspace_id"] is None for row in after_first.values())
+    counts = await _run([org.id])
+    assert counts == {"batches": 0, "rows": 0, "inserted_or_folded": 0}
+    assert await _meters(org.id) == after_first
+
+
+async def test_ee009_without_stragglers_changes_nothing(org):
+    await _insert(org=org.id, wrk=None, prj=org.prj, usr=org.usr, value=9, synced=5)
+    before = await _meters(org.id)
+    counts = await _run([org.id])
+    assert counts["rows"] == 0
+    assert await _meters(org.id) == before
+
+
+def test_ee009_upgrade_runs_ee007_in_an_autocommit_block(monkeypatch):
+    revision = _revision()
+    calls = []
+
+    class _StepTwo:
+        @staticmethod
+        def run(bind, **kwargs):
+            calls.append(kwargs)
+
+    class _Context:
+        def autocommit_block(self):
+            import contextlib
+
+            return contextlib.nullcontext()
+
+    statements = []
+
+    class _Bind:
+        def execute(self, statement):
+            statements.append(str(statement))
+
+    monkeypatch.setattr(revision, "_step_2_revision", lambda: _StepTwo)
+    monkeypatch.setattr(revision.op, "get_context", lambda: _Context())
+    monkeypatch.setattr(revision.op, "get_bind", lambda: _Bind())
+    revision.upgrade()
+    assert calls == [{}]
+    assert statements[:2] == [
+        "SET lock_timeout = '2s'",
+        "SET statement_timeout = '60s'",
+    ]
+    assert statements[-2:] == ["RESET lock_timeout", "RESET statement_timeout"]

api/ee/tests/pytest/unit/accounts/test_account_tombstones.py

@@ -224,7 +224,7 @@ async def _cascade(uid):
         calls.append(("cascade", uid))
         return [ORG_A, ORG_B]
 
-    async def _batch(*, org_ids, workspace_ids, project_ids, user_ids):
+    async def _batch(*, org_ids, project_ids, user_ids):
         calls.append(("batch", list(user_ids)))
 
     monkeypatch.setattr(m, "is_ee", lambda: True)