def report_run_failed(self, pipeline_run):
from dagster.core.events import DagsterEvent, DagsterEventType
from dagster.core.events.log import DagsterEventRecord
check.inst_param(pipeline_run, 'pipeline_run', PipelineRun)
message = "This pipeline run has been marked as failed from outside the execution context"
event_record = DagsterEventRecord(
message=message,
user_message=message,
level=logging.ERROR,
pipeline_name=pipeline_run.pipeline_name,
run_id=pipeline_run.run_id,
error_info=None,
timestamp=time.time(),
dagster_event=DagsterEvent(
event_type_value=DagsterEventType.PIPELINE_FAILURE.value,
pipeline_name=pipeline_run.pipeline_name,
message=message,
),
)
self.handle_new_event(event_record)
def test_event_log_storage_store_events_and_wipe(event_storage_factory_cm_fn):
with event_storage_factory_cm_fn() as storage:
assert len(storage.get_logs_for_run("foo")) == 0
storage.store_event(
DagsterEventRecord(
None,
"Message2",
"debug",
"",
"foo",
time.time(),
dagster_event=DagsterEvent(
DagsterEventType.ENGINE_EVENT.value,
"nonce",
event_specific_data=EngineEventData.in_process(999),
),
)
)
assert len(storage.get_logs_for_run("foo")) == 1
assert storage.get_stats_for_run("foo")
storage.wipe()
assert len(storage.get_logs_for_run("foo")) == 0
def build_process_start_event(run_id, pipeline_name):
check.str_param(pipeline_name, 'pipeline_name')
check.str_param(run_id, 'run_id')
message = 'About to start process for pipeline "{pipeline_name}" (run_id: {run_id}).'.format(
pipeline_name=pipeline_name, run_id=run_id
)
return DagsterEventRecord(
message=message,
user_message=message,
level=logging.INFO,
run_id=run_id,
timestamp=time.time(),
error_info=None,
pipeline_name=pipeline_name,
dagster_event=DagsterEvent(
message=message,
event_type_value=DagsterEventType.PIPELINE_PROCESS_START.value,
pipeline_name=pipeline_name,
event_specific_data=PipelineProcessStartData(pipeline_name, run_id),
),
)
def build_process_started_event(run_id, pipeline_name, process_id):
message = 'Started process {process_id} for pipeline {pipeline_name} run_id {run_id}'.format(
pipeline_name=pipeline_name, run_id=run_id, process_id=process_id)
return DagsterEventRecord(
message=message,
user_message=message,
level=logging.INFO,
run_id=run_id,
timestamp=time.time(),
error_info=None,
pipeline_name=pipeline_name,
dagster_event=DagsterEvent(
event_type_value=DagsterEventType.PIPELINE_PROCESS_STARTED.value,
pipeline_name=pipeline_name,
step_key=None,
solid_handle=None,
step_kind_value=None,
logging_tags=None,
event_specific_data=PipelineProcessStartedData(process_id),
),
)
def _event_record(run_id,
step_key,
timestamp,
event_type,
event_specific_data=None):
pipeline_name = "pipeline_name"
return DagsterEventRecord(
None,
"",
"debug",
"",
run_id,
timestamp,
step_key=step_key,
pipeline_name=pipeline_name,
dagster_event=DagsterEvent(
event_type.value,
pipeline_name,
step_key=step_key,
event_specific_data=event_specific_data,
),
)
def test_event_log_delete(event_storage_factory_cm_fn):
with event_storage_factory_cm_fn() as storage:
assert len(storage.get_logs_for_run('foo')) == 0
storage.store_event(
DagsterEventRecord(
None,
'Message2',
'debug',
'',
'foo',
time.time(),
dagster_event=DagsterEvent(
DagsterEventType.ENGINE_EVENT.value,
'nonce',
event_specific_data=EngineEventData.in_process(999),
),
)
)
assert len(storage.get_logs_for_run('foo')) == 1
assert storage.get_stats_for_run('foo')
storage.delete_events('foo')
assert len(storage.get_logs_for_run('foo')) == 0
def submit_run(self, pipeline_run, external_pipeline):
check.inst_param(pipeline_run, "pipeline_run", PipelineRun)
check.inst_param(external_pipeline, "external_pipeline", ExternalPipeline)
check.invariant(pipeline_run.status == PipelineRunStatus.NOT_STARTED)
enqueued_event = DagsterEvent(
event_type_value=DagsterEventType.PIPELINE_ENQUEUED.value,
pipeline_name=pipeline_run.pipeline_name,
)
event_record = DagsterEventRecord(
message="",
user_message="",
level=logging.INFO,
pipeline_name=pipeline_run.pipeline_name,
run_id=pipeline_run.run_id,
error_info=None,
timestamp=time.time(),
dagster_event=enqueued_event,
)
self._instance.handle_new_event(event_record)
return self._instance.get_run_by_id(pipeline_run.run_id)
def run_iteration(self):
in_progress = self._count_in_progress_runs()
max_runs_to_launch = self._max_concurrent_runs - in_progress
# Possibly under 0 if runs were launched without queuing
if max_runs_to_launch <= 0:
self._logger.info(
"{} runs are currently in progress. Maximum is {}, won't launch more.".format(
in_progress, self._max_concurrent_runs
)
)
return
queued_runs = self._get_queued_runs(limit=max_runs_to_launch)
if not queued_runs:
self._logger.info("Poll returned no queued runs.")
else:
self._logger.info("Retrieved {} queued runs to launch.".format(len(queued_runs)))
for run in queued_runs:
with external_pipeline_from_run(run) as external_pipeline:
enqueued_event = DagsterEvent(
event_type_value=DagsterEventType.PIPELINE_DEQUEUED.value,
pipeline_name=run.pipeline_name,
)
event_record = DagsterEventRecord(
message="",
user_message="",
level=logging.INFO,
pipeline_name=run.pipeline_name,
run_id=run.run_id,
error_info=None,
timestamp=time.time(),
dagster_event=enqueued_event,
)
self._instance.handle_new_event(event_record)
self._instance.launch_run(run.run_id, external_pipeline)
def construct_step_failure_event_and_handle(pipeline_run, step_key, err, instance):
step_failure_event = DagsterEvent(
event_type_value=DagsterEventType.STEP_FAILURE.value,
pipeline_name=pipeline_run.pipeline_name,
step_key=step_key,
event_specific_data=StepFailureData(
error=serializable_error_info_from_exc_info(sys.exc_info()),
user_failure_data=UserFailureData(label="K8sError"),
),
)
event_record = DagsterEventRecord(
message=str(err),
user_message=str(err),
level=logging.ERROR,
pipeline_name=pipeline_run.pipeline_name,
run_id=pipeline_run.run_id,
error_info=None,
step_key=step_key,
timestamp=time.time(),
dagster_event=step_failure_event,
)
instance.handle_new_event(event_record)
return step_failure_event