dagster-cloud 1.8.2__py3-none-any.whl → 1.12.6__py3-none-any.whl

dagster_cloud/storage/event_logs/storage.py

@@ -1,28 +1,17 @@
 import json
 import os
 from collections import defaultdict
+from collections.abc import Iterable, Mapping, Sequence
+from contextlib import contextmanager
 from datetime import timezone
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Dict,
-    Iterable,
-    List,
-    Mapping,
-    Optional,
-    Sequence,
-    Set,
-    Tuple,
-    Union,
-    cast,
-)
+from typing import TYPE_CHECKING, AbstractSet, Any, Callable, Optional, Union, cast  # noqa: UP035
 from uuid import uuid4
 
 import dagster._check as check
-from dagster import AssetCheckKey, DagsterInvalidInvocationError
+from dagster import AssetCheckKey, DagsterInvalidInvocationError, PartitionsDefinition
 from dagster._core.assets import AssetDetails
 from dagster._core.definitions.events import AssetKey, ExpectationResult
+from dagster._core.definitions.freshness import FreshnessStateRecord
 from dagster._core.event_api import (
     AssetRecordsFilter,
     EventLogRecord,
@@ -34,6 +23,7 @@ from dagster._core.event_api import (
 from dagster._core.events import DagsterEvent, DagsterEventType
 from dagster._core.events.log import EventLogEntry
 from dagster._core.execution.stats import RunStepKeyStatsSnapshot, RunStepMarker, StepEventStatus
+from dagster._core.instance.config import PoolConfig, PoolGranularity
 from dagster._core.storage.asset_check_execution_record import (
     AssetCheckExecutionRecord,
     AssetCheckExecutionRecordStatus,
@@ -46,10 +36,11 @@ from dagster._core.storage.event_log.base import (
     EventLogConnection,
     EventLogStorage,
     PlannedMaterializationInfo,
+    PoolLimit,
 )
 from dagster._core.storage.partition_status_cache import AssetStatusCacheValue
+from dagster._core.types.pagination import PaginatedResults
 from dagster._serdes import ConfigurableClass, ConfigurableClassData, serialize_value
-from dagster._serdes.serdes import deserialize_value
 from dagster._time import datetime_from_timestamp
 from dagster._utils.concurrency import (
     ClaimedSlotInfo,
@@ -61,9 +52,11 @@ from dagster._utils.concurrency import (
 from dagster._utils.error import SerializableErrorInfo
 from dagster._utils.merger import merge_dicts
 from dagster_cloud_cli.core.errors import DagsterCloudAgentServerError
+from dagster_shared.serdes.serdes import deserialize_value
 from typing_extensions import Self
 
 from dagster_cloud.api.dagster_cloud_api import StoreEventBatchRequest
+from dagster_cloud.metrics.tracer import Tracer
 from dagster_cloud.storage.event_logs.utils import truncate_event
 from dagster_cloud.util import compressed_namedtuple_upload_file
 
@@ -71,7 +64,11 @@ if TYPE_CHECKING:
     from dagster_cloud.instance import DagsterCloudAgentInstance
 
 
-from .queries import (
+# Guard against out of order event insertion issues by default
+DEFAULT_RUN_SCOPED_EVENT_TAILER_OFFSET = 20000
+
+
+from dagster_cloud.storage.event_logs.queries import (
     ADD_DYNAMIC_PARTITIONS_MUTATION,
     CHECK_CONCURRENCY_CLAIM_QUERY,
     CLAIM_CONCURRENCY_SLOT_MUTATION,
@@ -79,6 +76,7 @@ from .queries import (
     DELETE_DYNAMIC_PARTITION_MUTATION,
     DELETE_EVENTS_MUTATION,
     ENABLE_SECONDARY_INDEX_MUTATION,
+    FETCH_FAILED_MATERIALIZATIONS_QUERY,
     FETCH_MATERIALIZATIONS_QUERY,
     FETCH_OBSERVATIONS_QUERY,
     FETCH_PLANNED_MATERIALIZATIONS,
@@ -87,6 +85,7 @@ from .queries import (
     GET_ALL_ASSET_KEYS_QUERY,
     GET_ASSET_CHECK_STATE_QUERY,
     GET_ASSET_RECORDS_QUERY,
+    GET_ASSET_STATUS_CACHE_VALUES,
     GET_CONCURRENCY_INFO_QUERY,
     GET_CONCURRENCY_KEYS_QUERY,
     GET_DYNAMIC_PARTITIONS_QUERY,
@@ -99,6 +98,10 @@ from .queries import (
     GET_LATEST_TAGS_BY_PARTITION,
     GET_MATERIALIZATION_COUNT_BY_PARTITION,
     GET_MATERIALIZED_PARTITIONS,
+    GET_MAXIMUM_RECORD_ID,
+    GET_PAGINATED_DYNAMIC_PARTITIONS_QUERY,
+    GET_POOL_CONFIG_QUERY,
+    GET_POOL_LIMITS_QUERY,
     GET_RECORDS_FOR_RUN_QUERY,
     GET_RUN_STATUS_CHANGE_EVENTS_QUERY,
     GET_STATS_FOR_RUN_QUERY,
@@ -116,12 +119,12 @@ from .queries import (
     UPGRADE_EVENT_LOG_STORAGE_MUTATION,
     WIPE_ASSET_CACHED_STATUS_DATA_MUTATION,
     WIPE_ASSET_MUTATION,
+    WIPE_ASSET_PARTITIONS_MUTATION,
     WIPE_EVENT_LOG_STORAGE_MUTATION,
 )
 
 
 def _input_for_event(event: EventLogEntry):
-    event = truncate_event(event)
     return {
         "errorInfo": _input_for_serializable_error_info(event.error_info),
         "level": event.level,
@@ -172,7 +175,7 @@ def _input_for_dagster_event(dagster_event: Optional[DagsterEvent]):
     }
 
 
-def _event_log_entry_from_graphql(graphene_event_log_entry: Dict) -> EventLogEntry:
+def _event_log_entry_from_graphql(graphene_event_log_entry: dict) -> EventLogEntry:
     check.dict_param(graphene_event_log_entry, "graphene_event_log_entry")
 
     return EventLogEntry(
@@ -202,7 +205,7 @@ def _event_log_entry_from_graphql(graphene_event_log_entry: Dict) -> EventLogEnt
 
 def _get_event_records_filter_input(
     event_records_filter,
-) -> Optional[Dict[str, Any]]:
+) -> Optional[dict[str, Any]]:
     check.opt_inst_param(event_records_filter, "event_records_filter", EventRecordsFilter)
 
     if event_records_filter is None:
@@ -254,7 +257,7 @@ def _get_event_records_filter_input(
 
 def _get_asset_records_filter_input(
     records_filter: Union[AssetKey, AssetRecordsFilter],
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     check.opt_inst_param(records_filter, "records_filter", (AssetKey, AssetRecordsFilter))
 
     if isinstance(records_filter, AssetKey):
@@ -282,7 +285,7 @@ def _get_asset_records_filter_input(
     }
 
 
-def _fetch_run_status_changes_filter_input(records_filter) -> Dict[str, Any]:
+def _fetch_run_status_changes_filter_input(records_filter) -> dict[str, Any]:
     check.inst_param(
         records_filter, "records_filter", (DagsterEventType, RunStatusChangeRecordsFilter)
     )
@@ -297,10 +300,11 @@ def _fetch_run_status_changes_filter_input(records_filter) -> Dict[str, Any]:
         "afterStorageId": records_filter.after_storage_id,
         "beforeStorageId": records_filter.before_storage_id,
         "storageIds": records_filter.storage_ids,
+        "jobNames": records_filter.job_names,
     }
 
 
-def _event_record_from_graphql(graphene_event_record: Dict) -> EventLogRecord:
+def _event_record_from_graphql(graphene_event_record: dict) -> EventLogRecord:
     check.dict_param(graphene_event_record, "graphene_event_record")
 
     return EventLogRecord(
@@ -309,7 +313,7 @@ def _event_record_from_graphql(graphene_event_record: Dict) -> EventLogRecord:
     )
 
 
-def _asset_entry_from_graphql(graphene_asset_entry: Dict) -> AssetEntry:
+def _asset_entry_from_graphql(graphene_asset_entry: dict) -> AssetEntry:
     check.dict_param(graphene_asset_entry, "graphene_asset_entry")
     return AssetEntry(
         asset_key=AssetKey(graphene_asset_entry["assetKey"]["path"]),
@@ -351,10 +355,14 @@ def _asset_entry_from_graphql(graphene_asset_entry: Dict) -> AssetEntry:
             if graphene_asset_entry["lastObservationRecord"]
             else None
         ),
+        last_planned_materialization_storage_id=graphene_asset_entry[
+            "lastPlannedMaterializationStorageId"
+        ],
+        last_planned_materialization_run_id=graphene_asset_entry["lastPlannedMaterializationRunId"],
     )
 
 
-def _asset_record_from_graphql(graphene_asset_record: Dict) -> AssetRecord:
+def _asset_record_from_graphql(graphene_asset_record: dict) -> AssetRecord:
     check.dict_param(graphene_asset_record, "graphene_asset_record")
     return AssetRecord(
         storage_id=graphene_asset_record["storageId"],
@@ -362,8 +370,9 @@ def _asset_record_from_graphql(graphene_asset_record: Dict) -> AssetRecord:
     )
 
 
-def _asset_check_execution_record_from_graphql(data: Dict):
+def _asset_check_execution_record_from_graphql(data: dict, key: AssetCheckKey):
     return AssetCheckExecutionRecord(
+        key=key,
         id=data["id"],
         run_id=data["runId"],
         status=AssetCheckExecutionRecordStatus(data["status"]),
@@ -373,25 +382,36 @@ def _asset_check_execution_record_from_graphql(data: Dict):
 
 
 def _asset_check_summary_record_from_graphql(
-    graphene_asset_check_summary_record: Dict,
+    graphene_asset_check_summary_record: dict,
 ) -> AssetCheckSummaryRecord:
     check.dict_param(graphene_asset_check_summary_record, "graphene_asset_check_summary_record")
+
+    asset_check_key = AssetCheckKey.from_graphql_input(
+        graphene_asset_check_summary_record["assetCheckKey"]
+    )
     return AssetCheckSummaryRecord(
-        asset_check_key=AssetCheckKey.from_graphql_input(
-            graphene_asset_check_summary_record["assetCheckKey"]
-        ),
+        asset_check_key=asset_check_key,
         last_check_execution_record=(
             _asset_check_execution_record_from_graphql(
-                graphene_asset_check_summary_record["lastCheckExecutionRecord"]
+                graphene_asset_check_summary_record["lastCheckExecutionRecord"],
+                asset_check_key,
             )
             if graphene_asset_check_summary_record["lastCheckExecutionRecord"]
             else None
         ),
+        last_completed_check_execution_record=(
+            _asset_check_execution_record_from_graphql(
+                graphene_asset_check_summary_record["lastCompletedCheckExecutionRecord"],
+                asset_check_key,
+            )
+            if graphene_asset_check_summary_record["lastCompletedCheckExecutionRecord"]
+            else None
+        ),
         last_run_id=graphene_asset_check_summary_record["lastRunId"],
     )
 
 
-def _event_records_result_from_graphql(graphene_event_records_result: Dict) -> EventRecordsResult:
+def _event_records_result_from_graphql(graphene_event_records_result: dict) -> EventRecordsResult:
     return EventRecordsResult(
         records=[
             _event_record_from_graphql(record)
@@ -402,19 +422,19 @@ def _event_records_result_from_graphql(graphene_event_records_result: Dict) -> E
     )
 
 
-def _claimed_slot_from_graphql(graphene_claimed_slot_dict: Dict) -> ClaimedSlotInfo:
+def _claimed_slot_from_graphql(graphene_claimed_slot_dict: dict) -> ClaimedSlotInfo:
     check.dict_param(graphene_claimed_slot_dict, "graphene_claimed_slot_dict")
     return ClaimedSlotInfo(
-        graphene_claimed_slot_dict["runId"],
-        graphene_claimed_slot_dict["stepKey"],
+        run_id=graphene_claimed_slot_dict["runId"],
+        step_key=graphene_claimed_slot_dict["stepKey"],
     )
 
 
-def _pending_step_from_graphql(graphene_pending_step: Dict) -> PendingStepInfo:
+def _pending_step_from_graphql(graphene_pending_step: dict) -> PendingStepInfo:
     check.dict_param(graphene_pending_step, "graphene_pending_step")
     return PendingStepInfo(
-        graphene_pending_step["runId"],
-        graphene_pending_step["stepKey"],
+        run_id=graphene_pending_step["runId"],
+        step_key=graphene_pending_step["stepKey"],
         enqueued_timestamp=datetime_from_timestamp(graphene_pending_step["enqueuedTimestamp"]),
         assigned_timestamp=(
             datetime_from_timestamp(graphene_pending_step["assignedTimestamp"])
@@ -432,6 +452,7 @@ class GraphQLEventLogStorage(EventLogStorage, ConfigurableClass):
         """
         self._inst_data = check.opt_inst_param(inst_data, "inst_data", ConfigurableClassData)
         self._override_graphql_client = override_graphql_client
+        self._tracer = Tracer()
 
     @property
     def inst_data(self):
@@ -450,14 +471,12 @@ class GraphQLEventLogStorage(EventLogStorage, ConfigurableClass):
         return (
             self._override_graphql_client
             if self._override_graphql_client
-            else self._instance.graphql_client
+            else self._instance.graphql_client  # pyright: ignore[reportAttributeAccessIssue]
         )
 
     @property
     def agent_instance(self) -> "DagsterCloudAgentInstance":
-        from dagster_cloud.instance import DagsterCloudAgentInstance
-
-        return cast(DagsterCloudAgentInstance, self._instance)
+        return cast("DagsterCloudAgentInstance", self._instance)
 
     def _execute_query(self, query, variables=None, headers=None, idempotent_mutation=False):
         return self._graphql_client.execute(
@@ -467,11 +486,15 @@ class GraphQLEventLogStorage(EventLogStorage, ConfigurableClass):
             idempotent_mutation=idempotent_mutation,
         )
 
+    def get_maximum_record_id(self) -> Optional[int]:
+        res = self._execute_query(GET_MAXIMUM_RECORD_ID)
+        return res["data"]["eventLogs"]["getMaximumRecordId"]
+
     def get_records_for_run(
         self,
         run_id: str,
         cursor: Optional[str] = None,
-        of_type: Optional[Union[DagsterEventType, Set[DagsterEventType]]] = None,
+        of_type: Optional[Union[DagsterEventType, set[DagsterEventType]]] = None,
         limit: Optional[int] = None,
         ascending: bool = True,
     ) -> EventLogConnection:
@@ -485,12 +508,12 @@ class GraphQLEventLogStorage(EventLogStorage, ConfigurableClass):
                 "runId": check.str_param(run_id, "run_id"),
                 "cursor": check.opt_str_param(cursor, "cursor"),
                 "ofType": (
-                    cast(DagsterEventType, of_type).value
+                    cast("DagsterEventType", of_type).value
                     if of_type and not is_of_type_set
                     else None
                 ),
                 "ofTypes": (
-                    [dagster_type.value for dagster_type in cast(set, of_type)]
+                    [dagster_type.value for dagster_type in cast("set", of_type)]
                     if of_type and is_of_type_set
                     else None
                 ),
@@ -524,8 +547,8 @@ class GraphQLEventLogStorage(EventLogStorage, ConfigurableClass):
         )
 
     def get_step_stats_for_run(  # pyright: ignore[reportIncompatibleMethodOverride], fix me!
-        self, run_id: str, step_keys: Optional[List[str]] = None
-    ) -> List[RunStepKeyStatsSnapshot]:
+        self, run_id: str, step_keys: Optional[list[str]] = None
+    ) -> list[RunStepKeyStatsSnapshot]:
         res = self._execute_query(
             GET_STEP_STATS_FOR_RUN_QUERY,
             variables={
@@ -579,24 +602,55 @@ class GraphQLEventLogStorage(EventLogStorage, ConfigurableClass):
                 files={"store_events.tmp": f},
             )
 
+    def _add_metric_header(self, headers: dict[str, str]):
+        if os.getenv("DISABLE_DAGSTER_CLOUD_STORE_EVENT_SEND_METRICS") is not None:
+            return
+
+        try:
+            span_metric = self._tracer.pop_serialized_span()
+            if span_metric:
+                headers["Dagster-Cloud-Metric"] = span_metric
+        except:
+            pass
+
+    @contextmanager
+    def _event_span(self, event: EventLogEntry):
+        if os.getenv("DISABLE_DAGSTER_CLOUD_STORE_EVENT_SEND_METRICS") is not None:
+            yield
+        else:
+            with self._tracer.start_span("store-event") as event_span:
+                event_span.set_attribute(
+                    "event_type",
+                    event.dagster_event.event_type_value
+                    if event.dagster_event is not None
+                    else "user",
+                )
+                event_span.set_attribute("run_id", event.run_id)
+                yield
+
     def store_event(self, event: EventLogEntry):
         check.inst_param(event, "event", EventLogEntry)
-        headers = {"Idempotency-Key": str(uuid4())}
+        headers = {"Idempotency-Key": str(uuid4()), "X-Event-Write": "true"}
 
-        if os.getenv("DAGSTER_CLOUD_STORE_EVENT_OVER_HTTP"):
-            self._store_events_http(headers, [event])
-        else:
-            self._execute_query(
-                STORE_EVENT_MUTATION,
-                variables={
-                    "eventRecord": _input_for_event(event),
-                },
-                headers=headers,
-            )
+        self._add_metric_header(headers)
+
+        event = truncate_event(event)
+
+        with self._event_span(event):
+            if os.getenv("DAGSTER_CLOUD_STORE_EVENT_OVER_HTTP"):
+                self._store_events_http(headers, [event])
+            else:
+                self._execute_query(
+                    STORE_EVENT_MUTATION,
+                    variables={
+                        "eventRecord": _input_for_event(event),
+                    },
+                    headers=headers,
+                )
 
     def store_event_batch(self, events: Sequence[EventLogEntry]):
         check.sequence_param(events, "events", of_type=EventLogEntry)
-        headers = {"Idempotency-Key": str(uuid4())}
+        headers = {"Idempotency-Key": str(uuid4()), "X-Event-Write": "true"}
 
         if os.getenv("DAGSTER_CLOUD_STORE_EVENT_OVER_HTTP"):
             self._store_events_http(headers, events)
@@ -683,6 +737,18 @@ class GraphQLEventLogStorage(EventLogStorage, ConfigurableClass):
     def asset_records_have_last_observation(self) -> bool:
         return True
 
+    @property
+    def supports_partition_subset_in_asset_materialization_planned_events(self) -> bool:
+        return True
+
+    @property
+    def asset_records_have_last_planned_and_failed_materializations(self) -> bool:
+        return True
+
+    @property
+    def can_store_asset_failure_events(self) -> bool:
+        return True
+
     def get_asset_check_summary_records(
         self, asset_check_keys: Sequence[AssetCheckKey]
     ) -> Mapping[AssetCheckKey, AssetCheckSummaryRecord]:
@@ -714,6 +780,11 @@ class GraphQLEventLogStorage(EventLogStorage, ConfigurableClass):
             for result in res["data"]["eventLogs"]["getAssetRecords"]
         ]
 
+    def get_freshness_state_records(
+        self, keys: Sequence[AssetKey]
+    ) -> Mapping[AssetKey, FreshnessStateRecord]:
+        raise NotImplementedError("Not callable from user cloud")
+
     def has_asset_key(self, asset_key: AssetKey):
         check.inst_param(asset_key, "asset_key", AssetKey)
 
@@ -770,7 +841,7 @@ class GraphQLEventLogStorage(EventLogStorage, ConfigurableClass):
         asset_key: AssetKey,
         before_cursor: Optional[int] = None,
         after_cursor: Optional[int] = None,
-    ) -> Set[str]:
+    ) -> set[str]:
         check.inst_param(asset_key, "asset_key", AssetKey)
         check.opt_int_param(before_cursor, "before_cursor")
         check.opt_int_param(after_cursor, "after_cursor")
@@ -805,7 +876,7 @@ class GraphQLEventLogStorage(EventLogStorage, ConfigurableClass):
             "getMaterializationCountByPartition"
         ]
 
-        materialization_count_by_partition: Dict[AssetKey, Dict[str, int]] = {
+        materialization_count_by_partition: dict[AssetKey, dict[str, int]] = {
             asset_key: {} for asset_key in asset_keys
         }
         for asset_count in materialization_count_result:
@@ -818,17 +889,21 @@ class GraphQLEventLogStorage(EventLogStorage, ConfigurableClass):
         return materialization_count_by_partition
 
     def get_latest_storage_id_by_partition(
-        self, asset_key: AssetKey, event_type: DagsterEventType
+        self,
+        asset_key: AssetKey,
+        event_type: DagsterEventType,
+        partitions: Optional[set[str]] = None,
     ) -> Mapping[str, int]:
         res = self._execute_query(
             GET_LATEST_STORAGE_ID_BY_PARTITION,
             variables={
                 "assetKey": asset_key.to_string(),
                 "eventType": event_type.value,
+                "partitions": list(partitions) if partitions else None,
             },
         )
         latest_storage_id_result = res["data"]["eventLogs"]["getLatestStorageIdByPartition"]
-        latest_storage_id_by_partition: Dict[str, int] = {}
+        latest_storage_id_by_partition: dict[str, int] = {}
 
         for graphene_latest_storage_id in latest_storage_id_result:
             latest_storage_id_by_partition[graphene_latest_storage_id["partition"]] = (
@@ -858,7 +933,7 @@ class GraphQLEventLogStorage(EventLogStorage, ConfigurableClass):
             },
         )
         latest_tags_by_partition_result = res["data"]["eventLogs"]["getLatestTagsByPartition"]
-        latest_tags_by_partition: Dict[str, Dict[str, str]] = defaultdict(dict)
+        latest_tags_by_partition: dict[str, dict[str, str]] = defaultdict(dict)
         for tag_by_partition in latest_tags_by_partition_result:
             latest_tags_by_partition[tag_by_partition["partition"]][tag_by_partition["key"]] = (
                 tag_by_partition["value"]
@@ -869,7 +944,7 @@ class GraphQLEventLogStorage(EventLogStorage, ConfigurableClass):
 
     def get_latest_asset_partition_materialization_attempts_without_materializations(
         self, asset_key: AssetKey, after_storage_id: Optional[int] = None
-    ) -> Mapping[str, Tuple[str, int]]:
+    ) -> Mapping[str, tuple[str, int]]:
         res = self._execute_query(
             GET_LATEST_ASSET_PARTITION_MATERIALIZATION_ATTEMPTS_WITHOUT_MATERIALIZATIONS,
             variables={
@@ -882,7 +957,7 @@ class GraphQLEventLogStorage(EventLogStorage, ConfigurableClass):
         ]
 
         # Translate list to tuple
-        return {key: tuple(val) for key, val in result.items()}  # type: ignore
+        return {key: tuple(val) for key, val in result.items()}
 
     def get_event_tags_for_asset(
         self,
@@ -917,6 +992,28 @@ class GraphQLEventLogStorage(EventLogStorage, ConfigurableClass):
         )
         return res["data"]["eventLogs"]["getDynamicPartitions"]
 
+    def get_paginated_dynamic_partitions(
+        self, partitions_def_name: str, limit: int, ascending: bool, cursor: Optional[str] = None
+    ) -> PaginatedResults[str]:
+        check.str_param(partitions_def_name, "partitions_def_name")
+        check.int_param(limit, "limit")
+        check.bool_param(ascending, "ascending")
+        check.opt_str_param(cursor, "cursor")
+        res = self._execute_query(
+            GET_PAGINATED_DYNAMIC_PARTITIONS_QUERY,
+            variables={
+                "partitionsDefName": partitions_def_name,
+                "limit": limit,
+                "ascending": ascending,
+                "cursor": cursor,
+            },
+        )
+        return PaginatedResults(
+            results=res["data"]["eventLogs"]["getPaginatedDynamicPartitions"]["results"],
+            cursor=res["data"]["eventLogs"]["getPaginatedDynamicPartitions"]["cursor"],
+            has_more=res["data"]["eventLogs"]["getPaginatedDynamicPartitions"]["hasMore"],
+        )
+
     def has_dynamic_partition(self, partitions_def_name: str, partition_key: str) -> bool:
         check.str_param(partitions_def_name, "partitions_def_name")
         check.str_param(partition_key, "partition_key")
@@ -959,11 +1056,16 @@ class GraphQLEventLogStorage(EventLogStorage, ConfigurableClass):
         )
         return res
 
-    def wipe_asset_partitions(self, asset_key: AssetKey, partition_keys: Sequence[str]) -> None:
+    def wipe_asset_partitions(self, asset_key: AssetKey, partition_keys: Sequence[str]):
         """Remove asset index history from event log for given asset partitions."""
-        raise NotImplementedError(
-            "Partitioned asset wipe is not supported yet for this event log storage."
+        res = self._execute_query(
+            WIPE_ASSET_PARTITIONS_MUTATION,
+            variables={
+                "assetKey": asset_key.to_string(),
+                "partitionKeys": partition_keys,
+            },
         )
+        return res
 
     @property
     def supports_global_concurrency_limits(self) -> bool:
@@ -1017,7 +1119,7 @@ class GraphQLEventLogStorage(EventLogStorage, ConfigurableClass):
             else:
                 raise DagsterCloudAgentServerError(res)
 
-    def get_concurrency_keys(self) -> Set[str]:
+    def get_concurrency_keys(self) -> set[str]:
         res = self._execute_query(GET_CONCURRENCY_KEYS_QUERY)
         return set(res["data"]["eventLogs"]["getConcurrencyKeys"])
 
@@ -1033,6 +1135,8 @@ class GraphQLEventLogStorage(EventLogStorage, ConfigurableClass):
             slot_count=info["slotCount"],
             claimed_slots=[_claimed_slot_from_graphql(slot) for slot in info["claimedSlots"]],
             pending_steps=[_pending_step_from_graphql(step) for step in info["pendingSteps"]],
+            limit=info["limit"],
+            using_default_limit=bool(info["usingDefaultLimit"]),
         )
 
     def claim_concurrency_slot(
@@ -1100,7 +1204,7 @@ class GraphQLEventLogStorage(EventLogStorage, ConfigurableClass):
             ),
         )
 
-    def get_concurrency_run_ids(self) -> Set[str]:
+    def get_concurrency_run_ids(self) -> set[str]:
         raise NotImplementedError("Not callable from user cloud")
 
     def free_concurrency_slots_for_run(self, run_id: str) -> None:
@@ -1127,6 +1231,7 @@ class GraphQLEventLogStorage(EventLogStorage, ConfigurableClass):
         check_key: AssetCheckKey,
         limit: int,
         cursor: Optional[int] = None,
+        status: Optional[AbstractSet[AssetCheckExecutionRecordStatus]] = None,
     ) -> Sequence[AssetCheckExecutionRecord]:
         raise NotImplementedError("Not callable from user cloud")
 
@@ -1153,6 +1258,26 @@ class GraphQLEventLogStorage(EventLogStorage, ConfigurableClass):
         )
         return _event_records_result_from_graphql(res["data"]["eventLogs"]["fetchMaterializations"])
 
+    def fetch_failed_materializations(
+        self,
+        records_filter: Union[AssetKey, AssetRecordsFilter],
+        limit: int,
+        cursor: Optional[str] = None,
+        ascending: bool = False,
+    ) -> EventRecordsResult:
+        res = self._execute_query(
+            FETCH_FAILED_MATERIALIZATIONS_QUERY,
+            variables={
+                "recordsFilter": _get_asset_records_filter_input(records_filter),
+                "limit": limit,
+                "cursor": cursor,
+                "ascending": ascending,
+            },
+        )
+        return _event_records_result_from_graphql(
+            res["data"]["eventLogs"]["fetchFailedMaterializations"]
+        )
+
     def fetch_observations(
         self,
         records_filter: Union[AssetKey, AssetRecordsFilter],
@@ -1191,6 +1316,10 @@ class GraphQLEventLogStorage(EventLogStorage, ConfigurableClass):
             res["data"]["eventLogs"]["fetchPlannedMaterializations"]
         )
 
+    @property
+    def supports_run_status_change_job_name_filter(self):
+        return True
+
     def fetch_run_status_changes(
         self,
         records_filter: Union[DagsterEventType, RunStatusChangeRecordsFilter],
@@ -1233,7 +1362,7 @@ class GraphQLEventLogStorage(EventLogStorage, ConfigurableClass):
 
     def get_updated_data_version_partitions(
         self, asset_key: AssetKey, partitions: Iterable[str], since_storage_id: int
-    ) -> Set[str]:
+    ) -> set[str]:
         res = self._execute_query(
             GET_UPDATED_DATA_VERSION_PARTITIONS,
             variables={
@@ -1244,3 +1373,67 @@ class GraphQLEventLogStorage(EventLogStorage, ConfigurableClass):
         )
         partitions = res["data"]["eventLogs"]["getUpdatedDataVersionPartitions"]
         return set(partitions)
+
+    @property
+    def handles_run_events_in_store_event(self) -> bool:
+        return True
+
+    def default_run_scoped_event_tailer_offset(self) -> int:
+        return DEFAULT_RUN_SCOPED_EVENT_TAILER_OFFSET
+
+    def get_asset_status_cache_values(
+        self,
+        partitions_defs_by_key: Iterable[tuple[AssetKey, Optional[PartitionsDefinition]]],
+        context,
+    ) -> Sequence[Optional[AssetStatusCacheValue]]:
+        asset_keys = [key for key, _ in partitions_defs_by_key]
+        res = self._execute_query(
+            GET_ASSET_STATUS_CACHE_VALUES,
+            variables={
+                "assetKeys": [asset_key.to_graphql_input() for asset_key in asset_keys],
+            },
+        )
+
+        return [
+            AssetStatusCacheValue(
+                latest_storage_id=value["latestStorageId"],
+                partitions_def_id=value["partitionsDefId"],
+                serialized_materialized_partition_subset=value[
+                    "serializedMaterializedPartitionSubset"
+                ],
+                serialized_failed_partition_subset=value["serializedFailedPartitionSubset"],
+                serialized_in_progress_partition_subset=value[
+                    "serializedInProgressPartitionSubset"
+                ],
+                earliest_in_progress_materialization_event_id=value[
+                    "earliestInProgressMaterializationEventId"
+                ],
+            )
+            if value
+            else None
+            for value in res["data"]["eventLogs"]["getAssetStatusCacheValues"]
+        ]
+
+    def get_pool_config(self):
+        res = self._execute_query(GET_POOL_CONFIG_QUERY)
+        pool_config = res["data"]["eventLogs"]["getPoolConfig"]
+        granularity_str = pool_config.get("poolGranularity")
+
+        return PoolConfig(
+            pool_granularity=PoolGranularity(granularity_str) if granularity_str else None,
+            default_pool_limit=pool_config.get("defaultPoolLimit"),
+            op_granularity_run_buffer=pool_config.get("opGranularityRunBuffer"),
+        )
+
+    def get_pool_limits(self) -> Sequence[PoolLimit]:
+        """Get the set of concurrency limited keys and limits."""
+        res = self._execute_query(GET_POOL_LIMITS_QUERY)
+        limits = res["data"]["eventLogs"]["getPoolLimits"]
+        return [
+            PoolLimit(
+                name=limit.get("name"),
+                limit=limit.get("limit"),
+                from_default=limit.get("fromDefault"),
+            )
+            for limit in limits
+        ]