Dagster offers several ways to run data pipelines without manual intervation, including traditional scheduling and event-based triggers. Automating your Dagster pipelines can boost efficiency and ensure that data is produced consistently and reliably.
Represents a skipped evaluation, where no runs are requested. May contain a message to indicate why no runs were requested.
A message displayed in the Dagster UI for why this evaluation resulted in no requested runs.
Optional[str]
Schedules are Dagster’s way to support traditional ways of automation, such as specifying a job should run at Mondays at 9:00AM. Jobs triggered by schedules can contain a subset of assets or ops.
Creates a schedule following the provided cron schedule and requests runs for the provided job.
The decorated function takes in a ScheduleEvaluationContext as its only
argument, and does one of the following:
Return a RunRequest object.
Return a list of RunRequest objects.
Return a SkipReason object, providing a descriptive message of why no runs were requested.
Return nothing (skipping without providing a reason)
Return a run config dictionary.
Yield a SkipReason or yield one ore more RunRequest objects.
Returns a ScheduleDefinition.
cron_schedule (Union[str, Sequence[str]]) – A valid cron string or sequence of cron strings
specifying when the schedule will run, e.g., 45 23 * * 6 for a schedule that runs
at 11:45 PM every Saturday. If a sequence is provided, then the schedule will run for
the union of all execution times for the provided cron strings, e.g.,
['45 23 * * 6', '30 9 * * 0'] for a schedule that runs at 11:45 PM every Saturday and
9:30 AM every Sunday.
name (Optional[str]) – The name of the schedule.
tags (Optional[Mapping[str, str]]) – A set of key-value tags that annotate the schedule and can be used for searching and filtering in the UI.
tags_fn (Optional[Callable[[ScheduleEvaluationContext], Optional[Dict[str, str]]]]) – A function
that generates tags to attach to the schedule’s runs. Takes a
ScheduleEvaluationContext and returns a dictionary of tags (string
key-value pairs). Note: Either tags or tags_fn may be set, but not both.
metadata (Optional[Mapping[str, Any]]) – A set of metadata entries that annotate the schedule. Values will be normalized to typed MetadataValue objects.
should_execute (Optional[Callable[[ScheduleEvaluationContext], bool]]) – A function that runs at
schedule execution time to determine whether a schedule should execute or skip. Takes a
ScheduleEvaluationContext and returns a boolean (True if the
schedule should execute). Defaults to a function that always returns True.
execution_timezone (Optional[str]) – Timezone in which the schedule should run.
Supported strings for timezones are the ones provided by the
IANA time zone database - e.g. "America/Los_Angeles".
description (Optional[str]) – A human-readable description of the schedule.
job (Optional[Union[GraphDefinition, JobDefinition, UnresolvedAssetJobDefinition]]) – The job that should execute when the schedule runs.
default_status (DefaultScheduleStatus) – If set to RUNNING, the schedule will immediately be active when starting Dagster. The default status can be overridden from the Dagster UI or via the GraphQL API.
required_resource_keys (Optional[Set[str]]) – The set of resource keys required by the schedule.
target (Optional[Union[CoercibleToAssetSelection, AssetsDefinition, JobDefinition, UnresolvedAssetJobDefinition]]) – The target that the schedule will execute.
It can take AssetSelection objects and anything coercible to it (e.g. str, Sequence[str], AssetKey, AssetsDefinition).
It can also accept JobDefinition (a function decorated with @job is an instance of JobDefinition) and UnresolvedAssetJobDefinition (the return value of define_asset_job()) objects.
This is an experimental parameter that will replace job and job_name.
Defines a schedule that targets a job.
name (Optional[str]) – The name of the schedule to create. Defaults to the job name plus
_schedule.
cron_schedule (Union[str, Sequence[str]]) – A valid cron string or sequence of cron strings
specifying when the schedule will run, e.g., 45 23 * * 6 for a schedule that runs
at 11:45 PM every Saturday. If a sequence is provided, then the schedule will run for
the union of all execution times for the provided cron strings, e.g.,
['45 23 * * 6', '30 9 * * 0] for a schedule that runs at 11:45 PM every Saturday and
9:30 AM every Sunday.
execution_fn (Callable[ScheduleEvaluationContext]) –
The core evaluation function for the schedule, which is run at an interval to determine whether a run should be launched or not. Takes a ScheduleEvaluationContext.
This function must return a generator, which must yield either a single SkipReason
or one or more RunRequest objects.
run_config (Optional[Union[RunConfig, Mapping]]) – The config that parameterizes this execution, as a dict.
run_config_fn (Optional[Callable[[ScheduleEvaluationContext], [Mapping]]]) – A function that
takes a ScheduleEvaluationContext object and returns the run configuration that
parameterizes this execution, as a dict. Note: Only one of the following may be set: You may set run_config, run_config_fn, or execution_fn.
tags (Optional[Mapping[str, str]]) – A set of key-value tags that annotate the schedule and can be used for searching and filtering in the UI. If no execution_fn is provided, then these will also be automatically attached to runs launched by the schedule.
tags_fn (Optional[Callable[[ScheduleEvaluationContext], Optional[Mapping[str, str]]]]) – A
function that generates tags to attach to the schedule’s runs. Takes a
ScheduleEvaluationContext and returns a dictionary of tags (string
key-value pairs). Note: Only one of the following may be set: tags, tags_fn, or execution_fn.
should_execute (Optional[Callable[[ScheduleEvaluationContext], bool]]) – A function that runs
at schedule execution time to determine whether a schedule should execute or skip. Takes
a ScheduleEvaluationContext and returns a boolean (True if the
schedule should execute). Defaults to a function that always returns True.
execution_timezone (Optional[str]) –
Timezone in which the schedule should run.
Supported strings for timezones are the ones provided by the
IANA time zone database - e.g. "America/Los_Angeles".
description (Optional[str]) – A human-readable description of the schedule.
job (Optional[Union[GraphDefinition, JobDefinition]]) – The job that should execute when this schedule runs.
default_status (DefaultScheduleStatus) – If set to RUNNING, the schedule will start as running. The default status can be overridden from the Dagster UI or via the GraphQL API.
required_resource_keys (Optional[Set[str]]) – The set of resource keys required by the schedule.
target (Optional[Union[CoercibleToAssetSelection, AssetsDefinition, JobDefinition, UnresolvedAssetJobDefinition]]) – The target that the schedule will execute.
It can take AssetSelection objects and anything coercible to it (e.g. str, Sequence[str], AssetKey, AssetsDefinition).
It can also accept JobDefinition (a function decorated with @job is an instance of JobDefinition) and UnresolvedAssetJobDefinition (the return value of define_asset_job()) objects.
This is an experimental parameter that will replace job and job_name.
metadata (Optional[Mapping[str, Any]]) – A set of metadata entries that annotate the schedule. Values will be normalized to typed MetadataValue objects. Not currently shown in the UI but available at runtime via ScheduleEvaluationContext.repository_def.get_schedule_def(<name>).metadata.
The cron schedule representing when this schedule will be evaluated.
Union[str, Sequence[str]]
The default status for this schedule when it is first loaded in a code location.
DefaultScheduleStatus
A description for this schedule.
Optional[str]
( deprecated ) This API will be removed in version 2.0.
Setting this property no longer has any effect..
Environment variables to export to the cron schedule.
Mapping[str, str]
The timezone in which this schedule will be evaluated.
Optional[str]
The job that is targeted by this schedule.
Union[JobDefinition, UnresolvedAssetJobDefinition]
The name of the job targeted by this schedule.
str
The metadata for this schedule.
Mapping[str, str]
The name of the schedule.
str
The set of keys for resources that must be provided to this schedule.
Set[str]
The tags for this schedule.
Mapping[str, str]
The context object available as the first argument to various functions defined on a dagster.ScheduleDefinition.
A ScheduleEvaluationContext object is passed as the first argument to run_config_fn, tags_fn,
and should_execute.
Users should not instantiate this object directly. To construct a ScheduleEvaluationContext for testing purposes, use dagster.build_schedule_context().
Example
from dagster import schedule, ScheduleEvaluationContext
@schedule
def the_schedule(context: ScheduleEvaluationContext):
...
The current DagsterInstance.
Mapping of resource key to resource definition to be made available during schedule execution.
The time in which the execution was scheduled to happen. May differ slightly from both the actual execution time and the time at which the run config is computed.
Builds schedule execution context using the provided parameters.
The instance provided to build_schedule_context must be persistent;
DagsterInstance.ephemeral() will result in an error.
instance (Optional[DagsterInstance]) – The Dagster instance configured to run the schedule.
scheduled_execution_time (datetime) – The time in which the execution was scheduled to happen. May differ slightly from both the actual execution time and the time at which the run config is computed.
Examples
context = build_schedule_context(instance)
Creates a schedule from a job that targets time window-partitioned or statically-partitioned assets. The job can also be multi-partitioned, as long as one of the partition dimensions is time-partitioned.
The schedule executes at the cadence specified by the time partitioning of the job or assets.
######################################
# Job that targets partitioned assets
######################################
from dagster import (
DailyPartitionsDefinition,
asset,
build_schedule_from_partitioned_job,
define_asset_job,
Definitions,
)
@asset(partitions_def=DailyPartitionsDefinition(start_date="2020-01-01"))
def asset1():
...
asset1_job = define_asset_job("asset1_job", selection=[asset1])
# The created schedule will fire daily
asset1_job_schedule = build_schedule_from_partitioned_job(asset1_job)
defs = Definitions(assets=[asset1], schedules=[asset1_job_schedule])
################
# Non-asset job
################
from dagster import DailyPartitionsDefinition, build_schedule_from_partitioned_job, jog
@job(partitions_def=DailyPartitionsDefinition(start_date="2020-01-01"))
def do_stuff_partitioned():
...
# The created schedule will fire daily
do_stuff_partitioned_schedule = build_schedule_from_partitioned_job(
do_stuff_partitioned,
)
defs = Definitions(schedules=[do_stuff_partitioned_schedule])
For partitioned schedules, controls the maximum number of past
partitions for each schedule that will be considered when looking for missing
runs . Generally this parameter will only come into play if the scheduler
falls behind or launches after experiencing downtime. This parameter will not be checked for
schedules without partition sets (for example, schedules created using the @schedule decorator) - only the most recent execution time will be considered for those schedules.
Note: No matter what this value is, the scheduler will never launch a run from a time
before the schedule was turned on, even if the schedule’s start_date is earlier. If
you want to launch runs for earlier partitions, launch a backfill.
Default Value: 5
For each schedule tick that raises an error, the number of times to retry the tick.
Default Value: 0
Default scheduler implementation that submits runs from the long-lived dagster-daemon
process. Periodically checks each running schedule for execution times that don’t yet
have runs and launches them.
Sensors are typically used to poll, listen, and respond to external events. For example, you could configure a sensor to run a job or materialize an asset in response to specific events.
Creates a sensor where the decorated function is used as the sensor’s evaluation function.
The decorated function may:
Return a RunRequest object.
Return a list of RunRequest objects.
Return a SkipReason object, providing a descriptive message of why no runs were requested.
Return nothing (skipping without providing a reason)
Yield a SkipReason or yield one or more RunRequest objects.
Takes a SensorEvaluationContext.
name (Optional[str]) – The name of the sensor. Defaults to the name of the decorated function.
minimum_interval_seconds (Optional[int]) – The minimum number of seconds that will elapse between sensor evaluations.
description (Optional[str]) – A human-readable description of the sensor.
job (Optional[Union[GraphDefinition, JobDefinition, UnresolvedAssetJobDefinition]]) – The job to be executed when the sensor fires.
jobs (Optional[Sequence[Union[GraphDefinition, JobDefinition, UnresolvedAssetJobDefinition]]]) – (experimental) A list of jobs to be executed when the sensor fires.
default_status (DefaultSensorStatus) – Whether the sensor starts as running or not. The default status can be overridden from the Dagster UI or via the GraphQL API.
asset_selection (Optional[Union[str, Sequence[str], Sequence[AssetKey], Sequence[Union[AssetsDefinition, SourceAsset]], AssetSelection]]) – (Experimental) an asset selection to launch a run for if the sensor condition is met. This can be provided instead of specifying a job.
tags (Optional[Mapping[str, str]]) – A set of key-value tags that annotate the sensor and can be used for searching and filtering in the UI.
metadata (Optional[Mapping[str, object]]) – A set of metadata entries that annotate the sensor. Values will be normalized to typed MetadataValue objects.
target (Optional[Union[CoercibleToAssetSelection, AssetsDefinition, JobDefinition, UnresolvedAssetJobDefinition]]) – The target that the sensor will execute.
It can take AssetSelection objects and anything coercible to it (e.g. str, Sequence[str], AssetKey, AssetsDefinition).
It can also accept JobDefinition (a function decorated with @job is an instance of JobDefinition) and UnresolvedAssetJobDefinition (the return value of define_asset_job()) objects.
This is an experimental parameter that will replace job, jobs, and asset_selection.
Define a sensor that initiates a set of runs based on some external state.
evaluation_fn (Callable[[SensorEvaluationContext]]) –
The core evaluation function for the
sensor, which is run at an interval to determine whether a run should be launched or
not. Takes a SensorEvaluationContext.
This function must return a generator, which must yield either a single SkipReason or one or more RunRequest objects.
name (Optional[str]) – The name of the sensor to create. Defaults to name of evaluation_fn
minimum_interval_seconds (Optional[int]) – The minimum number of seconds that will elapse between sensor evaluations.
description (Optional[str]) – A human-readable description of the sensor.
job (Optional[GraphDefinition, JobDefinition, UnresolvedAssetJob]) – The job to execute when this sensor fires.
jobs (Optional[Sequence[GraphDefinition, JobDefinition, UnresolvedAssetJob]]) – (experimental) A list of jobs to execute when this sensor fires.
default_status (DefaultSensorStatus) – Whether the sensor starts as running or not. The default status can be overridden from the Dagster UI or via the GraphQL API.
asset_selection (Optional[Union[str, Sequence[str], Sequence[AssetKey], Sequence[Union[AssetsDefinition, SourceAsset]], AssetSelection]]) – (Experimental) an asset selection to launch a run for if the sensor condition is met. This can be provided instead of specifying a job.
tags (Optional[Mapping[str, str]]) – A set of key-value tags that annotate the sensor and can be used for searching and filtering in the UI.
metadata (Optional[Mapping[str, object]]) – A set of metadata entries that annotate the sensor. Values will be normalized to typed MetadataValue objects. Not currently shown in the UI but available at runtime via SensorEvaluationContext.repository_def.get_sensor_def(<name>).metadata.
target (Optional[Union[CoercibleToAssetSelection, AssetsDefinition, JobDefinition, UnresolvedAssetJobDefinition]]) – The target that the sensor will execute.
It can take AssetSelection objects and anything coercible to it (e.g. str, Sequence[str], AssetKey, AssetsDefinition).
It can also accept JobDefinition (a function decorated with @job is an instance of JobDefinition) and UnresolvedAssetJobDefinition (the return value of define_asset_job()) objects.
This is an experimental parameter that will replace job, jobs, and asset_selection.
The default status for this sensor when it is first loaded in a code location.
DefaultSensorStatus
A description for this sensor.
Optional[str]
The job that is targeted by this schedule.
Union[GraphDefinition, JobDefinition, UnresolvedAssetJobDefinition]
The name of the job that is targeted by this sensor.
Optional[str]
A list of jobs that are targeted by this schedule.
List[Union[GraphDefinition, JobDefinition, UnresolvedAssetJobDefinition]]
The minimum number of seconds between sequential evaluations of this sensor.
Optional[int]
The name of this sensor.
str
The set of keys for resources that must be provided to this sensor.
Set[str]
The context object available as the argument to the evaluation function of a dagster.SensorDefinition.
Users should not instantiate this object directly. To construct a
SensorEvaluationContext for testing purposes, use dagster.
build_sensor_context().
The serialized instance configured to run the schedule
Optional[InstanceRef]
The cursor, passed back from the last sensor evaluation via the cursor attribute of SkipReason and RunRequest
Optional[str]
The last time that the sensor was evaluated (UTC).
float
DEPRECATED The run key of the RunRequest most recently created by this sensor. Use the preferred cursor attribute instead.
str
The log key to use for this sensor tick.
Optional[List[str]]
The name of the repository that the sensor belongs to.
Optional[str]
The repository or that the sensor belongs to. If needed by the sensor top-level resource definitions will be pulled from this repository. You can provide either this or definitions.
Optional[RepositoryDefinition]
The deserialized instance can also be passed in directly (primarily useful in testing contexts).
Optional[DagsterInstance]
Definitions object that the sensor is defined in. If needed by the sensor, top-level resource definitions will be pulled from these definitions. You can provide either this or repository_def.
Optional[Definitions]
A dict of resource keys to resource definitions to be made available during sensor execution.
Optional[Dict[str, Any]]
The last time that the sensor was started (UTC).
float
The code location that the sensor is in.
Optional[CodeLocationOrigin]
Example
from dagster import sensor, SensorEvaluationContext
@sensor
def the_sensor(context: SensorEvaluationContext):
...
Updates the cursor value for this sensor, which will be provided on the context for the next sensor evaluation.
This can be used to keep track of progress and avoid duplicate work across sensor evaluations.
cursor (Optional[str])
The cursor value for this sensor, which was set in an earlier sensor evaluation.
The current DagsterInstance.
Flag representing if this is the first tick since the sensor was started.
The run key supplied to the most recent RunRequest produced by this sensor.
Optional[str]
Timestamp representing the last time this sensor was started. Can be used in concert with last_tick_completion_time to determine if this is the first tick since the sensor was started.
Optional[float]
Timestamp representing the last time this sensor completed an evaluation.
Optional[float]
The RepositoryDefinition that this sensor resides in.
Optional[RepositoryDefinition]
The name of the repository that this sensor resides in.
Optional[str]
A mapping from resource key to instantiated resources for this sensor.
Resources
Builds sensor execution context using the provided parameters.
This function can be used to provide a context to the invocation of a sensor definition.If provided, the dagster instance must be persistent; DagsterInstance.ephemeral() will result in an error.
instance (Optional[DagsterInstance]) – The dagster instance configured to run the sensor.
cursor (Optional[str]) – A cursor value to provide to the evaluation of the sensor.
repository_name (Optional[str]) – The name of the repository that the sensor belongs to.
repository_def (Optional[RepositoryDefinition]) – The repository that the sensor belongs to. If needed by the sensor top-level resource definitions will be pulled from this repository. You can provide either this or definitions.
resources (Optional[Mapping[str, ResourceDefinition]]) – A set of resource definitions to provide to the sensor. If passed, these will override any resource definitions provided by the repository.
definitions (Optional[Definitions]) – Definitions object that the sensor is defined in. If needed by the sensor, top-level resource definitions will be pulled from these definitions. You can provide either this or repository_def.
last_sensor_start_time (Optional[float]) – The last time the sensor was started.
Examples
context = build_sensor_context()
my_sensor(context)
Creates an asset sensor where the decorated function is used as the asset sensor’s evaluation function.
If the asset has been materialized multiple times between since the last sensor tick, the evaluation function will only be invoked once, with the latest materialization.
The decorated function may:
Return a RunRequest object.
Return a list of RunRequest objects.
Return a SkipReason object, providing a descriptive message of why no runs were requested.
Return nothing (skipping without providing a reason)
Yield a SkipReason or yield one or more RunRequest objects.
Takes a SensorEvaluationContext and an EventLogEntry corresponding to an
AssetMaterialization event.
asset_key (AssetKey) – The asset_key this sensor monitors.
name (Optional[str]) – The name of the sensor. Defaults to the name of the decorated function.
minimum_interval_seconds (Optional[int]) – The minimum number of seconds that will elapse between sensor evaluations.
description (Optional[str]) – A human-readable description of the sensor.
job (Optional[Union[GraphDefinition, JobDefinition, UnresolvedAssetJobDefinition]]) – The job to be executed when the sensor fires.
jobs (Optional[Sequence[Union[GraphDefinition, JobDefinition, UnresolvedAssetJobDefinition]]]) – (experimental) A list of jobs to be executed when the sensor fires.
default_status (DefaultSensorStatus) – Whether the sensor starts as running or not. The default status can be overridden from the Dagster UI or via the GraphQL API.
tags (Optional[Mapping[str, str]]) – A set of key-value tags that annotate the sensor and can be used for searching and filtering in the UI. Values that are not already strings will be serialized as JSON.
metadata (Optional[Mapping[str, object]]) – A set of metadata entries that annotate the sensor. Values will be normalized to typed MetadataValue objects.
Example
from dagster import AssetKey, EventLogEntry, SensorEvaluationContext, asset_sensor
@asset_sensor(asset_key=AssetKey("my_table"), job=my_job)
def my_asset_sensor(context: SensorEvaluationContext, asset_event: EventLogEntry):
return RunRequest(
run_key=context.cursor,
run_config={
"ops": {
"read_materialization": {
"config": {
"asset_key": asset_event.dagster_event.asset_key.path,
}
}
}
},
)
Define an asset sensor that initiates a set of runs based on the materialization of a given asset.
If the asset has been materialized multiple times between since the last sensor tick, the evaluation function will only be invoked once, with the latest materialization.
name (str) – The name of the sensor to create.
asset_key (AssetKey) – The asset_key this sensor monitors.
asset_materialization_fn (Callable[[SensorEvaluationContext, EventLogEntry], Union[Iterator[Union[RunRequest, SkipReason]], RunRequest, SkipReason]]) –
The core
evaluation function for the sensor, which is run at an interval to determine whether a
run should be launched or not. Takes a SensorEvaluationContext and
an EventLogEntry corresponding to an AssetMaterialization event.
This function must return a generator, which must yield either a single SkipReason or one or more RunRequest objects.
minimum_interval_seconds (Optional[int]) – The minimum number of seconds that will elapse between sensor evaluations.
description (Optional[str]) – A human-readable description of the sensor.
job (Optional[Union[GraphDefinition, JobDefinition, UnresolvedAssetJobDefinition]]) – The job object to target with this sensor.
jobs (Optional[Sequence[Union[GraphDefinition, JobDefinition, UnresolvedAssetJobDefinition]]]) – (experimental) A list of jobs to be executed when the sensor fires.
tags (Optional[Mapping[str, str]]) – A set of key-value tags that annotate the sensor and can be used for searching and filtering in the UI.
metadata (Optional[Mapping[str, object]]) – A set of metadata entries that annotate the sensor. Values will be normalized to typed MetadataValue objects.
default_status (DefaultSensorStatus) – Whether the sensor starts as running or not. The default status can be overridden from the Dagster UI or via the GraphQL API.
Define a sensor that reacts to a given status of job execution, where the decorated function will be evaluated when a run is at the given status.
name (str) – The name of the sensor. Defaults to the name of the decorated function.
run_status (DagsterRunStatus) – The status of a run which will be monitored by the sensor.
run_status_sensor_fn (Callable[[RunStatusSensorContext], Union[SkipReason, DagsterRunReaction]]) – The core
evaluation function for the sensor. Takes a RunStatusSensorContext.
minimum_interval_seconds (Optional[int]) – The minimum number of seconds that will elapse between sensor evaluations.
description (Optional[str]) – A human-readable description of the sensor.
monitored_jobs (Optional[List[Union[JobDefinition, GraphDefinition, UnresolvedAssetJobDefinition, JobSelector, RepositorySelector, CodeLocationSelector]]]) – The jobs in the current repository that will be monitored by this sensor. Defaults to None, which means the alert will be sent when any job in the repository fails.
monitor_all_code_locations (bool) – If set to True, the sensor will monitor all runs in the Dagster deployment. If set to True, an error will be raised if you also specify monitored_jobs or job_selection. Defaults to False.
default_status (DefaultSensorStatus) – Whether the sensor starts as running or not. The default status can be overridden from the Dagster UI or via the GraphQL API.
request_job (Optional[Union[GraphDefinition, JobDefinition]]) – The job a RunRequest should execute if yielded from the sensor.
tags (Optional[Mapping[str, str]]) – A set of key-value tags that annotate the sensor and can be used for searching and filtering in the UI.
metadata (Optional[Mapping[str, object]]) – A set of metadata entries that annotate the sensor. Values will be normalized to typed MetadataValue objects.
request_jobs (Optional[Sequence[Union[GraphDefinition, JobDefinition]]]) – (experimental) A list of jobs to be executed if RunRequests are yielded from the sensor.
The context object available to a decorated function of run_status_sensor.
The event associated with the job run status.
The run of the job.
The current instance.
The logger for the current sensor evaluation.
The partition key of the relevant run.
Optional[str]
The name of the sensor.
The context object available to a decorated function of run_failure_sensor.
the name of the sensor.
str
the failed run.
The step failure event for each step in the run that failed.
Examples
error_strings_by_step_key = {
# includes the stack trace
event.step_key: event.event_specific_data.error.to_string()
for event in context.get_step_failure_events()
}
The run failure event.
If the run failed because of an error inside a step, get_step_failure_events will have more details on the step failure.
Builds run status sensor context from provided parameters.
This function can be used to provide the context argument when directly invoking a function decorated with @run_status_sensor or @run_failure_sensor, such as when writing unit tests.
sensor_name (str) – The name of the sensor the context is being constructed for.
dagster_event (DagsterEvent) – A DagsterEvent with the same event type as the one that triggers the run_status_sensor
dagster_instance (DagsterInstance) – The dagster instance configured for the context.
dagster_run (DagsterRun) – DagsterRun object from running a job
resources (Optional[Mapping[str, object]]) – A dictionary of resources to be made available to the sensor.
repository_def (Optional[RepositoryDefinition]) – ( experimental ) (This parameter may break in future versions, even between dot releases.) The repository that the sensor belongs to.
Examples
instance = DagsterInstance.ephemeral()
result = my_job.execute_in_process(instance=instance)
dagster_run = result.dagster_run
dagster_event = result.get_job_success_event() # or get_job_failure_event()
context = build_run_status_sensor_context(
sensor_name="run_status_sensor_to_invoke",
dagster_instance=instance,
dagster_run=dagster_run,
dagster_event=dagster_event,
)
run_status_sensor_to_invoke(context)
Creates a sensor that reacts to a given status of job execution, where the decorated function will be run when a job is at the given status.
Takes a RunStatusSensorContext.
run_status (DagsterRunStatus) – The status of run execution which will be monitored by the sensor.
name (Optional[str]) – The name of the sensor. Defaults to the name of the decorated function.
minimum_interval_seconds (Optional[int]) – The minimum number of seconds that will elapse between sensor evaluations.
description (Optional[str]) – A human-readable description of the sensor.
monitored_jobs (Optional[List[Union[JobDefinition, GraphDefinition, UnresolvedAssetJobDefinition, RepositorySelector, JobSelector, CodeLocationSelector]]]) – Jobs in the current code locations that will be monitored by this sensor. Defaults to None, which means the alert will be sent when any job in the code location matches the requested run_status. Jobs in external repositories can be monitored by using RepositorySelector or JobSelector.
monitor_all_code_locations (Optional[bool]) – If set to True, the sensor will monitor all runs in the Dagster deployment. If set to True, an error will be raised if you also specify monitored_jobs or job_selection. Defaults to False.
job_selection (Optional[List[Union[JobDefinition, GraphDefinition, RepositorySelector, JobSelector, CodeLocationSelector]]]) – ( deprecated ) (This parameter will be removed in version 2.0. Use monitored_jobs instead.) (deprecated in favor of monitored_jobs) Jobs in the current code location that will be monitored by this sensor. Defaults to None, which means the alert will be sent when any job in the code location matches the requested run_status.
default_status (DefaultSensorStatus) – Whether the sensor starts as running or not. The default status can be overridden from the Dagster UI or via the GraphQL API.
request_job (Optional[Union[GraphDefinition, JobDefinition, UnresolvedAssetJobDefinition]]) – The job that should be executed if a RunRequest is yielded from the sensor.
request_jobs (Optional[Sequence[Union[GraphDefinition, JobDefinition, UnresolvedAssetJobDefinition]]]) – (experimental) A list of jobs to be executed if RunRequests are yielded from the sensor.
monitor_all_repositories (Optional[bool]) – ( deprecated ) (This parameter will be removed in version 2.0. Use monitor_all_code_locations instead.) (deprecated in favor of monitor_all_code_locations) If set to True, the sensor will monitor all runs in the Dagster instance. If set to True, an error will be raised if you also specify monitored_jobs or job_selection. Defaults to False.
tags (Optional[Mapping[str, str]]) – A set of key-value tags that annotate the sensor and can be used for searching and filtering in the UI.
metadata (Optional[Mapping[str, object]]) – A set of metadata entries that annotate the sensor. Values will be normalized to typed MetadataValue objects.
Creates a sensor that reacts to job failure events, where the decorated function will be run when a run fails.
Takes a RunFailureSensorContext.
name (Optional[str]) – The name of the job failure sensor. Defaults to the name of the decorated function.
minimum_interval_seconds (Optional[int]) – The minimum number of seconds that will elapse between sensor evaluations.
description (Optional[str]) – A human-readable description of the sensor.
monitored_jobs (Optional[List[Union[JobDefinition, GraphDefinition, UnresolvedAssetJobDefinition, RepositorySelector, JobSelector, CodeLocationSelector]]]) – The jobs in the current repository that will be monitored by this failure sensor. Defaults to None, which means the alert will be sent when any job in the current repository fails.
monitor_all_code_locations (bool) – If set to True, the sensor will monitor all runs in the Dagster deployment. If set to True, an error will be raised if you also specify monitored_jobs or job_selection. Defaults to False.
job_selection (Optional[List[Union[JobDefinition, GraphDefinition, RepositorySelector, JobSelector, CodeLocationSelector]]]) – ( deprecated ) (This parameter will be removed in version 2.0. Use monitored_jobs instead.) (deprecated in favor of monitored_jobs) The jobs in the current repository that will be monitored by this failure sensor. Defaults to None, which means the alert will be sent when any job in the repository fails.
default_status (DefaultSensorStatus) – Whether the sensor starts as running or not. The default status can be overridden from the Dagster UI or via the GraphQL API.
request_job (Optional[Union[GraphDefinition, JobDefinition, UnresolvedAssetJob]]) – The job a RunRequest should execute if yielded from the sensor.
request_jobs (Optional[Sequence[Union[GraphDefinition, JobDefinition, UnresolvedAssetJob]]]) – (experimental) A list of jobs to be executed if RunRequests are yielded from the sensor.
monitor_all_repositories (bool) – ( deprecated ) (This parameter will be removed in version 2.0. Use monitor_all_code_locations instead.) (deprecated in favor of monitor_all_code_locations) If set to True, the sensor will monitor all runs in the Dagster instance. If set to True, an error will be raised if you also specify monitored_jobs or job_selection. Defaults to False.
tags (Optional[Mapping[str, str]]) – A set of key-value tags that annotate the sensor and can be used for searching and filtering in the UI.
metadata (Optional[Mapping[str, object]]) – A set of metadata entries that annotate the sensor. Values will be normalized to typed MetadataValue objects.
The result of a sensor evaluation.
A list of run requests to be executed.
Optional[Sequence[RunRequest]]
A skip message indicating why sensor evaluation was skipped.
Optional[Union[str, SkipReason]]
The cursor value for this sensor, which will be provided on the context for the next sensor evaluation.
Optional[str]
AddDynamicPartitionsRequest]]]): A list of dynamic partition requests to request dynamic partition addition and deletion. Run requests will be evaluated using the state of the partitions with these changes applied. We recommend limiting partition additions and deletions to a maximum of 25K partitions per sensor evaluation, as this is the maximum recommended partition limit per asset.
(Experimental) A list of materializations, observations, and asset check evaluations that the system will persist on your behalf at the end of sensor evaluation. These events will be not be associated with any particular run, but will be queryable and viewable in the asset catalog.
Optional[Sequence[Union[AssetObservation, AssetMaterialization, AssetCheckEvaluation]]]