dagster-cloud 1.12.10__tar.gz → 1.12.12__tar.gz

{dagster_cloud-1.12.10 → dagster_cloud-1.12.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dagster-cloud
-Version: 1.12.10
+Version: 1.12.12
 Author-email: Elementl <support@elementl.com>
 License: Apache-2.0
 Project-URL: Homepage, https://dagster.io/cloud
@@ -22,19 +22,17 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Topic :: System :: Monitoring
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Operating System :: OS Independent
-Requires-Python: <3.14,>=3.9
+Requires-Python: <3.15,>=3.9
 Description-Content-Type: text/markdown
-Requires-Dist: dagster==1.12.10
-Requires-Dist: dagster-shared==1.12.10
-Requires-Dist: dagster-cloud-cli==1.12.10
-Requires-Dist: opentelemetry-api<2,>=1.27.0
-Requires-Dist: opentelemetry-sdk<2,>=1.27.0
-Requires-Dist: opentelemetry-exporter-otlp-proto-grpc<2,>=1.27.0
-Requires-Dist: opentelemetry-exporter-otlp-proto-http<2,>=1.27.0
+Requires-Dist: dagster==1.12.12
+Requires-Dist: dagster-shared==1.12.12
+Requires-Dist: dagster-cloud-cli==1.12.12
 Requires-Dist: pex<2.60.0,>=2.1.132
 Requires-Dist: questionary
 Requires-Dist: requests
@@ -53,24 +51,29 @@ Requires-Dist: pylint; extra == "tests"
 Requires-Dist: pytest; extra == "tests"
 Requires-Dist: types-PyYAML; extra == "tests"
 Requires-Dist: types-requests; extra == "tests"
-Requires-Dist: dagster-cloud-test-infra; extra == "tests"
 Requires-Dist: dbt-bigquery>=1.9.0; extra == "tests"
 Requires-Dist: dbt-core; extra == "tests"
 Requires-Dist: dbt-snowflake; extra == "tests"
 Requires-Dist: dbt-duckdb; extra == "tests"
 Requires-Dist: dagster-dbt; extra == "tests"
 Requires-Dist: dagster-k8s; extra == "tests"
+Requires-Dist: dagster-docker; extra == "tests"
 Requires-Dist: dagster-cloud-backend; extra == "tests"
+Requires-Dist: dagster-test; extra == "tests"
+Requires-Dist: dagster-cloud-test-infra; extra == "tests"
+Requires-Dist: dagster-cloud-dagit; extra == "tests"
+Requires-Dist: dagster-dg-cli; extra == "tests"
+Requires-Dist: syrupy; extra == "tests"
 Provides-Extra: insights
 Requires-Dist: pyarrow; extra == "insights"
 Provides-Extra: docker
 Requires-Dist: docker; extra == "docker"
-Requires-Dist: dagster-docker==0.28.10; extra == "docker"
+Requires-Dist: dagster-docker==0.28.12; extra == "docker"
 Provides-Extra: kubernetes
 Requires-Dist: kubernetes; extra == "kubernetes"
-Requires-Dist: dagster-k8s==0.28.10; extra == "kubernetes"
+Requires-Dist: dagster-k8s==0.28.12; extra == "kubernetes"
 Provides-Extra: ecs
-Requires-Dist: dagster-aws==0.28.10; extra == "ecs"
+Requires-Dist: dagster-aws==0.28.12; extra == "ecs"
 Requires-Dist: boto3; extra == "ecs"
 Provides-Extra: sandbox
 Requires-Dist: supervisor; extra == "sandbox"

{dagster_cloud-1.12.10 → dagster_cloud-1.12.12}/dagster_cloud/agent/dagster_cloud_agent.py

@@ -30,11 +30,8 @@ from dagster._utils.merger import merge_dicts
 from dagster._utils.typed_dict import init_optional_typeddict
 from dagster_cloud_cli.core.errors import DagsterCloudHTTPError, raise_http_error
 from dagster_cloud_cli.core.workspace import CodeLocationDeployData
+from dagster_shared.record import replace
 
-from dagster_cloud.agent.instrumentation.constants import DAGSTER_CLOUD_AGENT_METRIC_PREFIX
-from dagster_cloud.agent.instrumentation.run_launch import extract_run_attributes
-from dagster_cloud.agent.instrumentation.schedule import inspect_schedule_result
-from dagster_cloud.agent.instrumentation.sensor import inspect_sensor_result
 from dagster_cloud.agent.queries import (
     ADD_AGENT_HEARTBEATS_MUTATION,
     DEPLOYMENTS_QUERY,
@@ -58,7 +55,6 @@ from dagster_cloud.api.dagster_cloud_api import (
 )
 from dagster_cloud.batching import Batcher
 from dagster_cloud.instance import DagsterCloudAgentInstance
-from dagster_cloud.opentelemetry.observers.execution_observer import observe_execution
 from dagster_cloud.util import SERVER_HANDLE_TAG, compressed_namedtuple_upload_file, is_isolated_run
 from dagster_cloud.version import __version__
 from dagster_cloud.workspace.user_code_launcher import (
@@ -907,8 +903,9 @@ class DagsterCloudAgent:
                 user_code_launcher, deployment_name, cast("str", location_name)
             )
             serialized_snapshot_or_error = client.execution_plan_snapshot(
-                execution_plan_snapshot_args=request.request_args._replace(
-                    instance_ref=self._get_user_code_instance_ref(deployment_name)
+                execution_plan_snapshot_args=replace(
+                    request.request_args,
+                    instance_ref=self._get_user_code_instance_ref(deployment_name),
                 )
             )
             return DagsterCloudApiGrpcResponse(
@@ -974,64 +971,34 @@ class DagsterCloudAgent:
                 user_code_launcher, deployment_name, cast("str", location_name)
             )
 
-            args = request.request_args._replace(
-                instance_ref=self._get_user_code_instance_ref(deployment_name)
+            args = replace(
+                request.request_args,
+                instance_ref=self._get_user_code_instance_ref(deployment_name),
             )
 
-            schedule_attributes = {
-                "schedule": args.schedule_name,
-                "repository": args.repository_origin.repository_name,
-                "location": args.repository_origin.code_location_origin.location_name,
-                "deployment": deployment_name,
-            }
-
-            with observe_execution(
-                opentelemetry=self._instance.opentelemetry,
-                event_key=f"{DAGSTER_CLOUD_AGENT_METRIC_PREFIX}.schedule.evaluation",
-                short_description="schedule evaluation requests",
-                attributes=schedule_attributes,
-                result_evaluator_callback=inspect_schedule_result,
-            ) as observer:
-                serialized_schedule_data_or_error = client.external_schedule_execution(
-                    external_schedule_execution_args=args,
-                )
-                observer.evaluate_result(
-                    serialized_data_or_error=serialized_schedule_data_or_error,
-                )
-                return DagsterCloudApiGrpcResponse(
-                    serialized_response_or_error=serialized_schedule_data_or_error
-                )
+            serialized_schedule_data_or_error = client.external_schedule_execution(
+                external_schedule_execution_args=args,
+            )
+            return DagsterCloudApiGrpcResponse(
+                serialized_response_or_error=serialized_schedule_data_or_error
+            )
 
         elif api_name == DagsterCloudApi.GET_EXTERNAL_SENSOR_EXECUTION_DATA:
             client = self._get_grpc_client(
                 user_code_launcher, deployment_name, cast("str", location_name)
             )
 
-            args = request.request_args._replace(
-                instance_ref=self._get_user_code_instance_ref(deployment_name)
+            args = replace(
+                request.request_args,
+                instance_ref=self._get_user_code_instance_ref(deployment_name),
             )
 
-            sensor_attributes = {
-                "sensor": args.sensor_name,
-                "repository": args.repository_origin.repository_name,
-                "location": args.repository_origin.code_location_origin.location_name,
-                "deployment": deployment_name,
-            }
-
-            with observe_execution(
-                opentelemetry=self._instance.opentelemetry,
-                event_key=f"{DAGSTER_CLOUD_AGENT_METRIC_PREFIX}.sensor.evaluation",
-                short_description="sensor evaluation requests",
-                attributes=sensor_attributes,
-                result_evaluator_callback=inspect_sensor_result,
-            ) as observer:
-                serialized_sensor_data_or_error = client.external_sensor_execution(
-                    sensor_execution_args=args,
-                )
-                observer.evaluate_result(serialized_sensor_data_or_error)
-                return DagsterCloudApiGrpcResponse(
-                    serialized_response_or_error=serialized_sensor_data_or_error
-                )
+            serialized_sensor_data_or_error = client.external_sensor_execution(
+                sensor_execution_args=args,
+            )
+            return DagsterCloudApiGrpcResponse(
+                serialized_response_or_error=serialized_sensor_data_or_error
+            )
         elif api_name == DagsterCloudApi.GET_EXTERNAL_NOTEBOOK_DATA:
             client = self._get_grpc_client(
                 user_code_launcher, deployment_name, cast("str", location_name)
@@ -1062,42 +1029,32 @@ class DagsterCloudAgent:
                     ),
                 )
 
-                run_attributes = extract_run_attributes(deployment_name, run)
-                with observe_execution(
-                    opentelemetry=self._instance.opentelemetry,
-                    event_key=f"{DAGSTER_CLOUD_AGENT_METRIC_PREFIX}.run.launches",
-                    short_description="run execution requests",
-                    attributes=run_attributes,
-                ) as observer:
-                    launcher = scoped_instance.get_run_launcher_for_run(run)  # type: ignore  # (instance subclass)
+                launcher = scoped_instance.get_run_launcher_for_run(run)  # type: ignore  # (instance subclass)
 
-                    if is_isolated_run(run):
-                        launcher.launch_run(LaunchRunContext(dagster_run=run, workspace=None))
-                    else:
-                        scoped_instance.report_engine_event(
-                            f"Launching {run.run_id} without an isolated run environment.",
-                            run,
-                            cls=self.__class__,
-                        )
+                if is_isolated_run(run):
+                    launcher.launch_run(LaunchRunContext(dagster_run=run, workspace=None))
+                else:
+                    scoped_instance.report_engine_event(
+                        f"Launching {run.run_id} without an isolated run environment.",
+                        run,
+                        cls=self.__class__,
+                    )
 
-                        run_location_name = cast(
-                            "str",
-                            run.remote_job_origin.repository_origin.code_location_origin.location_name,
-                        )
+                    run_location_name = cast(
+                        "str",
+                        run.remote_job_origin.repository_origin.code_location_origin.location_name,
+                    )
 
-                        server = user_code_launcher.get_grpc_server(
-                            deployment_name, run_location_name
-                        )
+                    server = user_code_launcher.get_grpc_server(deployment_name, run_location_name)
 
-                        # Record the server handle that we launched it on to for run monitoring
-                        scoped_instance.add_run_tags(
-                            run.run_id, new_tags={SERVER_HANDLE_TAG: str(server.server_handle)}
-                        )
+                    # Record the server handle that we launched it on to for run monitoring
+                    scoped_instance.add_run_tags(
+                        run.run_id, new_tags={SERVER_HANDLE_TAG: str(server.server_handle)}
+                    )
 
-                        launcher.launch_run_from_grpc_client(
-                            scoped_instance, run, server.server_endpoint.create_client()
-                        )
-                    observer.evaluate_result(run=run)
+                    launcher.launch_run_from_grpc_client(
+                        scoped_instance, run, server.server_endpoint.create_client()
+                    )
 
                 return DagsterCloudApiSuccess()
         elif api_name == DagsterCloudApi.TERMINATE_RUN:

{dagster_cloud-1.12.10 → dagster_cloud-1.12.12}/dagster_cloud/instance/__init__.py

@@ -1,7 +1,7 @@
 import copy
 import socket
 import uuid
-from collections.abc import Mapping, Sequence
+from collections.abc import Sequence
 from contextlib import ExitStack
 from functools import lru_cache
 from typing import TYPE_CHECKING, Any, Optional, Union
@@ -34,11 +34,8 @@ from urllib3 import Retry
 
 from dagster_cloud.agent import AgentQueuesConfig
 from dagster_cloud.auth.constants import decode_agent_token
-from dagster_cloud.opentelemetry.config import opentelemetry_config_schema
-from dagster_cloud.opentelemetry.controller import OpenTelemetryController
 from dagster_cloud.storage.client import dagster_cloud_api_config
 from dagster_cloud.util import get_env_names_from_config, is_isolated_run
-from dagster_cloud.version import __version__
 
 if TYPE_CHECKING:
     from requests import Session
@@ -83,7 +80,6 @@ class DagsterCloudAgentInstance(DagsterCloudInstance):
         allowed_full_deployment_locations=None,
         allowed_branch_deployment_locations=None,
         agent_metrics=None,
-        opentelemetry=None,
         **kwargs,
     ):
         super().__init__(*args, **kwargs)
@@ -155,12 +151,6 @@ class DagsterCloudAgentInstance(DagsterCloudInstance):
             allowed_branch_deployment_locations
         )
 
-        self._opentelemetry_config: Optional[Mapping[str, Any]] = self._get_processed_config(
-            "opentelemetry", opentelemetry, opentelemetry_config_schema()
-        )
-
-        self._opentelemetry_controller: Optional[OpenTelemetryController] = None
-
         self._instance_uuid = str(uuid.uuid4())
 
     @property
@@ -582,9 +572,6 @@ instance_class:
                 is_required=False,
                 description="List of allowed location names for branch deployments",
             ),
-            "opentelemetry": Field(
-                opentelemetry_config_schema(), is_required=False, default_value={"enabled": False}
-            ),
         }
 
     @classmethod
@@ -667,9 +654,6 @@ instance_class:
 
     def dispose(self) -> None:
         super().dispose()
-        if self._opentelemetry_controller:
-            self._opentelemetry_controller.dispose()
-            self._opentelemetry_controller = None
         self._exit_stack.close()
 
     @property
@@ -690,17 +674,6 @@ instance_class:
         # potentially overridden interval in the serverless user code launcher
         return 30
 
-    @property
-    def opentelemetry(self) -> OpenTelemetryController:
-        if not self._opentelemetry_controller:
-            self._opentelemetry_controller = OpenTelemetryController(
-                instance_id=self.instance_uuid,
-                version=__version__,
-                config=self._opentelemetry_config,
-            )
-
-        return self._opentelemetry_controller
-
 
 @lru_cache(maxsize=100)  # Scales on order of active branch deployments
 def _cached_inject_deployment(

{dagster_cloud-1.12.10 → dagster_cloud-1.12.12}/dagster_cloud/pex/grpc/server/manager.py

@@ -16,7 +16,7 @@ from dagster._utils.error import SerializableErrorInfo, serializable_error_info_
 from dagster_cloud_cli.core.workspace import CodeLocationDeployData, PexMetadata
 from dagster_shared import seven
 from dagster_shared.ipc import open_ipc_subprocess
-from pydantic import BaseModel, Extra
+from pydantic import BaseModel
 
 from dagster_cloud.pex.grpc.server.registry import PexS3Registry
 from dagster_cloud.pex.grpc.types import PexServerHandle
@@ -25,7 +25,7 @@ from dagster_cloud.workspace.user_code_launcher.utils import get_grpc_server_env
 logger = logging.getLogger("dagster.multipex")
 
 
-class PexProcessEntry(BaseModel, frozen=True, extra=Extra.forbid, arbitrary_types_allowed=True):
+class PexProcessEntry(BaseModel, frozen=True, extra="forbid", arbitrary_types_allowed=True):
     pex_server_handle: PexServerHandle
     grpc_server_process: subprocess.Popen
     grpc_client: DagsterGrpcClient
@@ -33,7 +33,7 @@ class PexProcessEntry(BaseModel, frozen=True, extra=Extra.forbid, arbitrary_type
     heartbeat_thread: threading.Thread
 
 
-class PexErrorEntry(BaseModel, frozen=True, extra=Extra.forbid, arbitrary_types_allowed=True):
+class PexErrorEntry(BaseModel, frozen=True, extra="forbid", arbitrary_types_allowed=True):
     pex_server_handle: PexServerHandle
     error: SerializableErrorInfo
 

dagster_cloud-1.12.12/dagster_cloud/version.py

@@ -0,0 +1 @@
+__version__ = "1.12.12"

{dagster_cloud-1.12.10 → dagster_cloud-1.12.12}/dagster_cloud/workspace/docker/__init__.py

@@ -40,6 +40,7 @@ from dagster_cloud.workspace.user_code_launcher import (
 from dagster_cloud.workspace.user_code_launcher.user_code_launcher import UserCodeLauncherEntry
 from dagster_cloud.workspace.user_code_launcher.utils import (
     deterministic_label_for_location,
+    get_code_server_port,
     get_grpc_server_env,
 )
 
@@ -293,7 +294,7 @@ class DockerUserCodeLauncher(
 
         has_network = len(self._networks) > 0
         if has_network:
-            grpc_port = 4000
+            grpc_port = get_code_server_port()
             hostname = container_name
         else:
             grpc_port = find_free_port()

{dagster_cloud-1.12.10 → dagster_cloud-1.12.12}/dagster_cloud/workspace/ecs/client.py

@@ -17,7 +17,7 @@ from dagster_aws.ecs.utils import is_transient_task_stopped_reason, task_definit
 
 from dagster_cloud.workspace.ecs.service import Service
 
-DEFAULT_ECS_TIMEOUT = 300
+DEFAULT_ECS_TIMEOUT = 600
 DEFAULT_ECS_GRACE_PERIOD = 30
 
 STOPPED_TASK_GRACE_PERIOD = 30

{dagster_cloud-1.12.10 → dagster_cloud-1.12.12}/dagster_cloud/workspace/ecs/launcher.py

@@ -53,13 +53,13 @@ from dagster_cloud.workspace.user_code_launcher.user_code_launcher import (
 )
 from dagster_cloud.workspace.user_code_launcher.utils import (
     deterministic_label_for_location,
+    get_code_server_port,
     get_grpc_server_env,
 )
 
 EcsServerHandleType = Service
 
 CONTAINER_NAME = "dagster"
-PORT = 4000
 
 
 class EcsUserCodeLauncher(DagsterCloudUserCodeLauncher[EcsServerHandleType], ConfigurableClass):
@@ -405,7 +405,8 @@ class EcsUserCodeLauncher(DagsterCloudUserCodeLauncher[EcsServerHandleType], Con
 
         if metadata.pex_metadata:
             command = metadata.get_multipex_server_command(
-                PORT, metrics_enabled=self._instance.user_code_launcher.code_server_metrics_enabled
+                get_code_server_port(),
+                metrics_enabled=self._instance.user_code_launcher.code_server_metrics_enabled,
             )
             additional_env = metadata.get_multipex_server_env()
             tags = {
@@ -418,7 +419,10 @@ class EcsUserCodeLauncher(DagsterCloudUserCodeLauncher[EcsServerHandleType], Con
                 metrics_enabled=self._instance.user_code_launcher.code_server_metrics_enabled
             )
             additional_env = get_grpc_server_env(
-                metadata, PORT, location_name, self._instance.ref_for_deployment(deployment_name)
+                metadata,
+                get_code_server_port(),
+                location_name,
+                self._instance.ref_for_deployment(deployment_name),
             )
             tags = {
                 "dagster/grpc_server": "1",
@@ -524,7 +528,7 @@ class EcsUserCodeLauncher(DagsterCloudUserCodeLauncher[EcsServerHandleType], Con
 
         endpoint = ServerEndpoint(
             host=service.hostname,
-            port=PORT,
+            port=get_code_server_port(),
             socket=None,
         )
 

{dagster_cloud-1.12.10 → dagster_cloud-1.12.12}/dagster_cloud/workspace/kubernetes/launcher.py

@@ -34,7 +34,6 @@ from dagster_cloud.constants import RESERVED_ENV_VAR_NAMES
 from dagster_cloud.execution.cloud_run_launcher.k8s import CloudK8sRunLauncher
 from dagster_cloud.execution.monitoring import CloudContainerResourceLimits
 from dagster_cloud.workspace.kubernetes.utils import (
-    SERVICE_PORT,
     construct_code_location_deployment,
     construct_code_location_service,
     get_deployment_failure_debug_info,
@@ -49,7 +48,10 @@ from dagster_cloud.workspace.user_code_launcher import (
     ServerEndpoint,
     UserCodeLauncherEntry,
 )
-from dagster_cloud.workspace.user_code_launcher.utils import deterministic_label_for_location
+from dagster_cloud.workspace.user_code_launcher.utils import (
+    deterministic_label_for_location,
+    get_code_server_port,
+)
 
 DEFAULT_DEPLOYMENT_STARTUP_TIMEOUT = 300
 DEFAULT_IMAGE_PULL_GRACE_PERIOD = 30
@@ -506,7 +508,7 @@ class K8sUserCodeLauncher(DagsterCloudUserCodeLauncher[K8sHandle], ConfigurableC
 
         endpoint = ServerEndpoint(
             host=host,
-            port=SERVICE_PORT,
+            port=get_code_server_port(),
             socket=None,
         )
 

{dagster_cloud-1.12.10 → dagster_cloud-1.12.12}/dagster_cloud/workspace/kubernetes/utils.py

@@ -13,13 +13,13 @@ from kubernetes import client
 from dagster_cloud.instance import DagsterCloudAgentInstance
 from dagster_cloud.workspace.user_code_launcher.utils import (
     deterministic_label_for_location,
+    get_code_server_port,
     get_grpc_server_env,
     get_human_readable_label,
     unique_resource_name,
 )
 
 MANAGED_RESOURCES_LABEL = {"managed_by": "K8sUserCodeLauncher"}
-SERVICE_PORT = 4000
 
 
 def _get_dagster_k8s_labels(
@@ -106,7 +106,7 @@ def construct_code_location_service(
             },
             "spec": {
                 "selector": {"user-deployment": service_name},
-                "ports": [{"name": "grpc", "protocol": "TCP", "port": SERVICE_PORT}],
+                "ports": [{"name": "grpc", "protocol": "TCP", "port": get_code_server_port()}],
             },
         },
     )
@@ -123,7 +123,10 @@ def construct_code_location_deployment(
     server_timestamp: float,
 ):
     env = get_grpc_server_env(
-        metadata, SERVICE_PORT, location_name, instance.ref_for_deployment(deployment_name)
+        metadata,
+        get_code_server_port(),
+        location_name,
+        instance.ref_for_deployment(deployment_name),
     )
 
     user_defined_config = container_context.server_k8s_config