@rivetkit/engine 1.0.0 → 2.2.1-pr.4600.b74ff3b

package/packages/gasoline/src/history/event.rs

@@ -41,26 +41,21 @@ impl Deref for Event {
 #[derive(Debug)]
 pub enum EventData {
 	Activity(ActivityEvent),
-	Signal(SignalEvent),
 	SignalSend(SignalSendEvent),
 	MessageSend(MessageSendEvent),
 	SubWorkflow(SubWorkflowEvent),
 	Loop(LoopEvent),
 	Sleep(SleepEvent),
 	Removed(RemovedEvent),
-	VersionCheck,
+	VersionCheck(VersionCheckEvent),
 	Branch,
-
-	/// NOTE: Strictly used as a placeholder for backfilling. When using this, the coordinate of the `Event`
-	/// must still be valid.
-	Empty,
+	Signals(SignalsEvent),
 }
 
 impl std::fmt::Display for EventData {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		match &self {
 			EventData::Activity(activity) => write!(f, "activity {:?}", activity.name),
-			EventData::Signal(signal) => write!(f, "signal {:?}", signal.name),
 			EventData::SignalSend(signal_send) => write!(f, "signal send {:?}", signal_send.name),
 			EventData::MessageSend(message_send) => {
 				write!(f, "message send {:?}", message_send.name)
@@ -77,9 +72,15 @@ impl std::fmt::Display for EventData {
 					write!(f, "removed {}", removed.event_type)
 				}
 			}
-			EventData::VersionCheck => write!(f, "version check"),
+			EventData::VersionCheck(_) => write!(f, "version check"),
 			EventData::Branch => write!(f, "branch"),
-			EventData::Empty => write!(f, "empty"),
+			EventData::Signals(signals) => {
+				let mut unique_names = signals.names.clone();
+				unique_names.sort();
+				unique_names.dedup();
+
+				write!(f, "signals {:?}", unique_names.join(", "))
+			}
 		}
 	}
 }
@@ -87,6 +88,7 @@ impl std::fmt::Display for EventData {
 #[derive(Hash, Debug, Clone, Copy, PartialEq, Eq, FromRepr)]
 pub enum EventType {
 	Activity = 0,
+	/// Deprecated.
 	Signal = 1,
 	SignalSend = 2,
 	MessageSend = 3,
@@ -96,6 +98,7 @@ pub enum EventType {
 	Branch = 7,
 	Removed = 8,
 	VersionCheck = 9,
+	Signals = 10,
 }
 
 impl std::fmt::Display for EventType {
@@ -111,6 +114,7 @@ impl std::fmt::Display for EventType {
 			EventType::Removed => write!(f, "removed event"),
 			EventType::VersionCheck => write!(f, "version check"),
 			EventType::Branch => write!(f, "branch"),
+			EventType::Signals => write!(f, "signals"),
 		}
 	}
 }
@@ -135,12 +139,6 @@ impl ActivityEvent {
 	}
 }
 
-#[derive(Debug)]
-pub struct SignalEvent {
-	pub name: String,
-	pub body: Box<serde_json::value::RawValue>,
-}
-
 #[derive(Debug)]
 pub struct SignalSendEvent {
 	pub signal_id: Id,
@@ -208,3 +206,14 @@ pub struct RemovedEvent {
 	pub event_type: EventType,
 	pub name: Option<String>,
 }
+
+#[derive(Debug)]
+pub struct VersionCheckEvent {
+	pub inner_version: usize,
+}
+
+#[derive(Debug)]
+pub struct SignalsEvent {
+	pub names: Vec<String>,
+	pub bodies: Vec<Box<serde_json::value::RawValue>>,
+}

package/packages/gasoline/src/listen.rs

@@ -3,22 +3,10 @@ use async_trait::async_trait;
 use crate::{ctx::ListenCtx, error::WorkflowResult};
 
 /// A trait which allows listening for signals from the workflows database. This is used by
-/// `WorkflowCtx::listen` and `WorkflowCtx::query_signal`. If you need a listener with state, use
-/// `CustomListener`.
+/// `WorkflowCtx::listen` and `WorkflowCtx::query_signal`.
 #[async_trait]
 pub trait Listen: Sized {
 	/// This function may be polled by the `WorkflowCtx`.
-	async fn listen(ctx: &mut ListenCtx) -> WorkflowResult<Self>;
+	async fn listen(ctx: &mut ListenCtx, limit: usize) -> WorkflowResult<Vec<Self>>;
 	fn parse(name: &str, body: &serde_json::value::RawValue) -> WorkflowResult<Self>;
 }
-
-/// A trait which allows listening for signals with a custom state. This is used by
-/// `WorkflowCtx::custom_listener`.
-#[async_trait]
-pub trait CustomListener: Sized {
-	type Output;
-
-	/// This function may be polled by the `WorkflowCtx`.
-	async fn listen(&self, ctx: &mut ListenCtx) -> WorkflowResult<Self::Output>;
-	fn parse(name: &str, body: &serde_json::value::RawValue) -> WorkflowResult<Self::Output>;
-}

package/packages/gasoline/src/message.rs

@@ -96,7 +96,7 @@ where
 pub(crate) struct PubsubMessageWrapper<'a> {
 	pub(crate) ray_id: Id,
 	pub(crate) req_id: Id,
-	pub(crate) tags: serde_json::Value,
+	pub(crate) topic: String,
 	pub(crate) ts: i64,
 	#[serde(borrow)]
 	pub(crate) body: &'a serde_json::value::RawValue,

package/packages/gasoline/src/metrics.rs

@@ -1,156 +1,273 @@
-use rivet_metrics::{
-	BUCKETS,
-	otel::{global::*, metrics::*},
-};
+use rivet_metrics::{BUCKETS, MICRO_BUCKETS, REGISTRY, prometheus::*};
 
 lazy_static::lazy_static! {
-	static ref METER: Meter = meter("rivet-gasoline");
-	/// Expected attributes: "worker_id"
-	pub static ref WORKER_LAST_PING: Gauge<u64> = METER.u64_gauge("rivet_gasoline_worker_last_ping")
-		.with_description("Last ping of a worker as a unix ts.")
-		.build();
-	/// Expected attributes: "worker_id"
-	pub static ref LAST_PULL_WORKFLOWS_DURATION: Gauge<f64> = METER.f64_gauge("rivet_gasoline_last_pull_workflows_duration")
-		.with_description("Last duration of pulling workflow data.")
-		.build();
-	/// Expected attributes: "worker_id"
-	pub static ref LAST_PULL_WORKFLOWS_HISTORY_DURATION: Gauge<u64> = METER.u64_gauge("rivet_gasoline_last_pull_workflows_history_duration")
-		.with_description("Last duration of pulling workflow histories.")
-		.build();
-	/// Expected attributes: "worker_id"
-	pub static ref LAST_PULL_WORKFLOWS_FULL_DURATION: Gauge<f64> = METER.f64_gauge("rivet_gasoline_last_pull_workflows_full_duration")
-		.with_description("Last duration of pulling workflow data and history.")
-		.build();
-	/// Expected attributes: "worker_id"
-	pub static ref PULL_WORKFLOWS_DURATION: Histogram<f64> = METER.f64_histogram("rivet_gasoline_pull_workflows_duration")
-		.with_description("Duration of pulling workflow data.")
-		.with_boundaries(BUCKETS.to_vec())
-		.build();
-	/// Expected attributes: "worker_id"
-	pub static ref PULL_WORKFLOWS_HISTORY_DURATION: Histogram<f64> = METER.f64_histogram("rivet_gasoline_pull_workflows_history_duration")
-		.with_description("Duration of pulling workflow histories.")
-		.with_boundaries(BUCKETS.to_vec())
-		.build();
-	/// Expected attributes: "worker_id"
-	pub static ref PULL_WORKFLOWS_FULL_DURATION: Histogram<f64> = METER.f64_histogram("rivet_gasoline_pull_workflows_full_duration")
-		.with_description("Duration of pulling workflow data and history.")
-		.with_boundaries(BUCKETS.to_vec())
-		.build();
+	pub static ref WORKER_LAST_PING: IntGaugeVec = register_int_gauge_vec_with_registry!(
+		"gasoline_worker_last_ping",
+		"Last ping of a worker as a unix ts.",
+		&["worker_id"],
+		*REGISTRY
+	).unwrap();
+	pub static ref WORKER_LAST_METRICS_PUBLISH: IntGauge = register_int_gauge_with_registry!(
+		"gasoline_worker_last_metrics_publish",
+		"Last timestamp of metrics publish.",
+		*REGISTRY
+	).unwrap();
+	pub static ref WORKER_BUMPS_PER_TICK: HistogramVec = register_histogram_vec_with_registry!(
+		"gasoline_worker_bumps_per_tick",
+		"Amount of bump messages received in a single worker tick.",
+		&["worker_id"],
+		vec![1.0, 2.0, 3.0, 4.0, 8.0, 16.0, 32.0, 64.0, 128.0, 256.0, 512.0, 1024.0],
+		*REGISTRY
+	).unwrap();
+	pub static ref LAST_PULL_WORKFLOWS_DURATION: GaugeVec = register_gauge_vec_with_registry!(
+		"gasoline_last_pull_workflows_duration",
+		"Last duration of pulling workflow data.",
+		&["worker_id"],
+		*REGISTRY
+	).unwrap();
+	pub static ref LAST_PULL_WORKFLOWS_HISTORY_DURATION: GaugeVec = register_gauge_vec_with_registry!(
+		"gasoline_last_pull_workflows_history_duration",
+		"Last duration of pulling workflow histories.",
+		&["worker_id"],
+		*REGISTRY
+	).unwrap();
+	pub static ref LAST_PULL_WORKFLOWS_FULL_DURATION: GaugeVec = register_gauge_vec_with_registry!(
+		"gasoline_last_pull_workflows_full_duration",
+		"Last duration of pulling workflow data and history.",
+		&["worker_id"],
+		*REGISTRY
+	).unwrap();
+	pub static ref PULL_WORKFLOWS_DURATION: HistogramVec = register_histogram_vec_with_registry!(
+		"gasoline_pull_workflows_duration",
+		"Duration of pulling workflow data.",
+		&["worker_id"],
+		BUCKETS.to_vec(),
+		*REGISTRY
+	).unwrap();
+	pub static ref PULL_WORKFLOWS_HISTORY_DURATION: HistogramVec = register_histogram_vec_with_registry!(
+		"gasoline_pull_workflows_history_duration",
+		"Duration of pulling workflow histories.",
+		&["worker_id"],
+		BUCKETS.to_vec(),
+		*REGISTRY
+	).unwrap();
+	pub static ref PULL_WORKFLOWS_FULL_DURATION: HistogramVec = register_histogram_vec_with_registry!(
+		"gasoline_pull_workflows_full_duration",
+		"Duration of pulling workflow data and history.",
+		&["worker_id"],
+		BUCKETS.to_vec(),
+		*REGISTRY
+	).unwrap();
+	pub static ref WORKER_WORKFLOW_ACTIVE: IntGaugeVec = register_int_gauge_vec_with_registry!(
+		"gasoline_worker_workflow_active",
+		"Total active workflows in memory for the given worker.",
+		&["worker_id", "workflow_name"],
+		*REGISTRY
+	).unwrap();
 
-	/// Expected attributes: "workflow_name"
-	pub static ref FIND_WORKFLOWS_DURATION: Histogram<f64> = METER.f64_histogram("rivet_gasoline_find_workflows_duration")
-		.with_description("Duration to find a workflow with a given name and tags.")
-		.with_boundaries(BUCKETS.to_vec())
-		.build();
+	pub static ref FIND_WORKFLOWS_DURATION: HistogramVec = register_histogram_vec_with_registry!(
+		"gasoline_find_workflows_duration",
+		"Duration to find a workflow with a given name and tags.",
+		&["workflow_name"],
+		BUCKETS.to_vec(),
+		*REGISTRY
+	).unwrap();
 
-	/// Expected attributes: "workflow_name"
-	pub static ref WORKFLOW_TOTAL: Gauge<u64> = METER.u64_gauge("rivet_gasoline_workflow_total")
-		.with_description("Total workflows.")
-		.build();
-	/// Expected attributes: "workflow_name"
-	pub static ref WORKFLOW_ACTIVE: Gauge<u64> = METER.u64_gauge("rivet_gasoline_workflow_active")
-		.with_description("Total active workflows.")
-		.build();
-	/// Expected attributes: "workflow_name", "error"
-	pub static ref WORKFLOW_DEAD: Gauge<u64> = METER.u64_gauge("rivet_gasoline_workflow_dead")
-		.with_description("Total dead workflows.")
-		.build();
-	/// Expected attributes: "workflow_name"
-	pub static ref WORKFLOW_SLEEPING: Gauge<u64> = METER.u64_gauge("rivet_gasoline_workflow_sleeping")
-		.with_description("Total sleeping workflows.")
-		.build();
-	/// Expected attributes: "workflow_name", "error"
-	pub static ref WORKFLOW_ERRORS: Counter<u64> = METER.u64_counter("rivet_gasoline_workflow_errors")
-		.with_description("All errors made in a workflow.")
-		.build();
+	pub static ref FIND_WORKFLOWS_BATCH_DURATION: Histogram = register_histogram_with_registry!(
+		"gasoline_find_workflows_batch_duration",
+		"Duration to find workflows.",
+		*REGISTRY
+	).unwrap();
 
-	/// Expected attributes: "workflow_name"
-	pub static ref COMPLETE_WORKFLOW_DURATION: Histogram<f64> = METER.f64_histogram("rivet_gasoline_complete_workflow_duration")
-		.with_description("Duration to complete a workflow with a given name.")
-		.with_boundaries(BUCKETS.to_vec())
-		.build();
-	/// Expected attributes: "workflow_name"
-	pub static ref COMMIT_WORKFLOW_DURATION: Histogram<f64> = METER.f64_histogram("rivet_gasoline_commit_workflow_duration")
-		.with_description("Duration to commit a workflow with a given name.")
-		.with_boundaries(BUCKETS.to_vec())
-		.build();
+	pub static ref WORKFLOW_TOTAL: IntGaugeVec = register_int_gauge_vec_with_registry!(
+		"gasoline_workflow_total",
+		"Total workflows.",
+		&["workflow_name"],
+		*REGISTRY
+	).unwrap();
+	pub static ref WORKFLOW_ACTIVE: IntGaugeVec = register_int_gauge_vec_with_registry!(
+		"gasoline_workflow_active",
+		"Total active workflows.",
+		&["workflow_name"],
+		*REGISTRY
+	).unwrap();
+	pub static ref WORKFLOW_DEAD: IntGaugeVec = register_int_gauge_vec_with_registry!(
+		"gasoline_workflow_dead",
+		"Total dead workflows.",
+		&["workflow_name", "error"],
+		*REGISTRY
+	).unwrap();
+	pub static ref WORKFLOW_SLEEPING: IntGaugeVec = register_int_gauge_vec_with_registry!(
+		"gasoline_workflow_sleeping",
+		"Total sleeping workflows.",
+		&["workflow_name"],
+		*REGISTRY
+	).unwrap();
+	pub static ref WORKFLOW_ERRORS: IntCounterVec = register_int_counter_vec_with_registry!(
+		"gasoline_workflow_errors",
+		"All errors made in a workflow.",
+		&["workflow_name", "error"],
+		*REGISTRY
+	).unwrap();
+	pub static ref WORKFLOW_WAKE_DELTA_DURATION: HistogramVec = register_histogram_vec_with_registry!(
+		"gasoline_workflow_wake_delta_duration",
+		"Duration from wake condition insertion to pull.",
+		&["workflow_name"],
+		MICRO_BUCKETS.to_vec(),
+		*REGISTRY
+	).unwrap();
+	pub static ref WORKFLOW_LEASED: HistogramVec = register_histogram_vec_with_registry!(
+		"gasoline_workflow_leased",
+		"Amount of workflows leased per pull.",
+		&["workflow_name"],
+		vec![1.0, 2.0, 3.0, 4.0, 8.0, 16.0, 30.0, 60.0, 125.0, 250.0, 500.0, 1000.0],
+		*REGISTRY
+	).unwrap();
 
-	/// Expected attributes: "workflow_name", "activity_name", "error_code"
-	pub static ref ACTIVITY_DURATION: Histogram<f64> = METER.f64_histogram("rivet_gasoline_activity_duration")
-		.with_description("Total duration of an activity.")
-		.with_boundaries(BUCKETS.to_vec())
-		.build();
-	/// Expected attributes: "workflow_name", "activity_name", "error_code"
-	pub static ref ACTIVITY_ERRORS: Counter<u64> = METER.u64_counter("rivet_gasoline_activity_errors")
-		.with_description("All errors made in an activity.")
-		.build();
+	pub static ref COMPLETE_WORKFLOW_DURATION: HistogramVec = register_histogram_vec_with_registry!(
+		"gasoline_complete_workflow_duration",
+		"Duration to complete a workflow with a given name.",
+		&["workflow_name"],
+		BUCKETS.to_vec(),
+		*REGISTRY
+	).unwrap();
+	pub static ref COMMIT_WORKFLOW_DURATION: HistogramVec = register_histogram_vec_with_registry!(
+		"gasoline_commit_workflow_duration",
+		"Duration to commit a workflow with a given name.",
+		&["workflow_name"],
+		BUCKETS.to_vec(),
+		*REGISTRY
+	).unwrap();
 
-	/// Expected attributes: "signal_name"
-	pub static ref SIGNAL_PENDING: Gauge<u64> = METER.u64_gauge("rivet_gasoline_signal_pending")
-		.with_description("Total pending signals.")
-		.build();
-	/// Expected attributes: "workflow_name", "signal_name"
-	pub static ref SIGNAL_RECV_LAG: Histogram<f64> = METER.f64_histogram("rivet_gasoline_signal_recv_lag")
-		.with_description("Time between the publish timestamp and the timestamp the signal was received.")
-		.with_boundaries(BUCKETS.to_vec())
-		.build();
-	/// Expected attributes: "workflow_name", "signal_name"
-	pub static ref SIGNAL_PULL_DURATION: Histogram<f64> = METER.f64_histogram("rivet_gasoline_signal_pull_duration")
-		.with_description("Total duration to pull signals.")
-		.with_boundaries(BUCKETS.to_vec())
-		.build();
-	/// Expected attributes: "workflow_name", "signal_name"
-	pub static ref SIGNAL_PUBLISHED: Counter<u64> = METER.u64_counter("rivet_gasoline_signal_published")
-		.with_description("Total published signals.")
-		.build();
-	/// Expected attributes: "workflow_name", "signal_name"
-	pub static ref SIGNAL_SEND_DURATION: Histogram<f64> = METER.f64_histogram("rivet_gasoline_signal_send_duration")
-		.with_description("Total duration of a signal send.")
-		.with_boundaries(BUCKETS.to_vec())
-		.build();
+	pub static ref ACTIVITY_DURATION: HistogramVec = register_histogram_vec_with_registry!(
+		"gasoline_activity_duration",
+		"Total duration of an activity.",
+		&["workflow_name", "activity_name", "error"],
+		BUCKETS.to_vec(),
+		*REGISTRY
+	).unwrap();
+	pub static ref ACTIVITY_ERRORS: IntCounterVec = register_int_counter_vec_with_registry!(
+		"gasoline_activity_errors",
+		"All errors made in an activity.",
+		&["workflow_name", "activity_name", "error"],
+		*REGISTRY
+	).unwrap();
 
-	/// Expected attributes: "workflow_name", "message_name"
-	pub static ref MESSAGE_PUBLISHED: Counter<u64> = METER.u64_counter("rivet_gasoline_message_published")
-		.with_description("Total published messages.")
-		.build();
-	/// Expected attributes: "workflow_name", "message_name"
-	pub static ref MESSAGE_SEND_DURATION: Histogram<f64> = METER.f64_histogram("rivet_gasoline_message_send_duration")
-		.with_description("Total duration of a message send.")
-		.with_boundaries(BUCKETS.to_vec())
-		.build();
+	pub static ref SIGNAL_PENDING: IntGaugeVec = register_int_gauge_vec_with_registry!(
+		"gasoline_signal_pending",
+		"Total pending signals.",
+		&["signal_name"],
+		*REGISTRY
+	).unwrap();
+	pub static ref SIGNAL_RECV_LAG: HistogramVec = register_histogram_vec_with_registry!(
+		"gasoline_signal_recv_lag",
+		"Time between the publish timestamp and the timestamp the signal was received.",
+		&["workflow_name", "signal_name"],
+		BUCKETS.to_vec(),
+		*REGISTRY
+	).unwrap();
+	pub static ref SIGNAL_PUBLISHED: IntCounterVec = register_int_counter_vec_with_registry!(
+		"gasoline_signal_published",
+		"Total published signals.",
+		&["workflow_name", "signal_name"],
+		*REGISTRY
+	).unwrap();
+	pub static ref SIGNAL_SEND_DURATION: HistogramVec = register_histogram_vec_with_registry!(
+		"gasoline_signal_send_duration",
+		"Total duration of a signal send.",
+		&["workflow_name", "signal_name"],
+		BUCKETS.to_vec(),
+		*REGISTRY
+	).unwrap();
 
-	/// Expected attributes: "workflow_name", "sub_workflow_name"
-	pub static ref WORKFLOW_DISPATCHED: Counter<u64> = METER.u64_counter("rivet_gasoline_workflow_dispatched")
-		.with_description("Total dispatched workflows.")
-		.build();
-	/// Expected attributes: "workflow_name", "sub_workflow_name"
-	pub static ref WORKFLOW_DISPATCH_DURATION: Histogram<f64> = METER.f64_histogram("rivet_gasoline_workflow_dispatch_duration")
-		.with_description("Total duration of a workflow dispatch.")
-		.with_boundaries(BUCKETS.to_vec())
-		.build();
+	pub static ref MESSAGE_PUBLISHED: IntCounterVec = register_int_counter_vec_with_registry!(
+		"gasoline_message_published",
+		"Total published messages.",
+		&["workflow_name", "message_name"],
+		*REGISTRY
+	).unwrap();
+	pub static ref MESSAGE_SEND_DURATION: HistogramVec = register_histogram_vec_with_registry!(
+		"gasoline_message_send_duration",
+		"Total duration of a message send.",
+		&["workflow_name", "message_name"],
+		BUCKETS.to_vec(),
+		*REGISTRY
+	).unwrap();
 
-	/// Expected attributes: "workflow_name"
-	pub static ref LOOP_ITERATION_DURATION: Histogram<f64> = METER.f64_histogram("rivet_gasoline_loop_iteration_duration")
-		.with_description("Total duration of a single loop iteration (excluding its body).")
-		.with_boundaries(BUCKETS.to_vec())
-		.build();
+	pub static ref WORKFLOW_DISPATCHED: IntCounterVec = register_int_counter_vec_with_registry!(
+		"gasoline_workflow_dispatched",
+		"Total dispatched workflows.",
+		&["workflow_name", "sub_workflow_name"],
+		*REGISTRY
+	).unwrap();
+	pub static ref WORKFLOW_DISPATCH_DURATION: HistogramVec = register_histogram_vec_with_registry!(
+		"gasoline_workflow_dispatch_duration",
+		"Total duration of a workflow dispatch.",
+		&["workflow_name", "sub_workflow_name"],
+		BUCKETS.to_vec(),
+		*REGISTRY
+	).unwrap();
+
+	pub static ref LOOP_COMMIT_DURATION: HistogramVec = register_histogram_vec_with_registry!(
+		"gasoline_loop_commit_duration",
+		"Total duration of a single loop commit.",
+		&["workflow_name"],
+		BUCKETS.to_vec(),
+		*REGISTRY
+	).unwrap();
+
+	pub static ref LOOP_ITERATION_DURATION: HistogramVec = register_histogram_vec_with_registry!(
+		"gasoline_loop_iteration_duration",
+		"Total duration of a single loop iteration.",
+		&["workflow_name"],
+		BUCKETS.to_vec(),
+		*REGISTRY
+	).unwrap();
 
 	// MARK: Ops
-	/// Expected attributes: "operation_name"
-	pub static ref OPERATION_PENDING: UpDownCounter<i64> = METER.i64_up_down_counter("rivet_gasoline_operation_pending")
-		.with_description("Total number of operation calls in progress.")
-		.build();
-	/// Expected attributes: "operation_name"
-	pub static ref OPERATION_TOTAL: Counter<u64> = METER.u64_counter("rivet_gasoline_operation_total")
-		.with_description("Total number of operation calls.")
-		.build();
-	/// Expected attributes: "operation_name", "error"
-	pub static ref OPERATION_DURATION: Histogram<f64> = METER.f64_histogram("rivet_gasoline_operation_duration")
-		.with_description("Total duration of an op call.")
-		.with_boundaries(BUCKETS.to_vec())
-		.build();
-	/// Expected attributes: "operation_name", "error"
-	pub static ref OPERATION_ERRORS: Counter<u64> = METER.u64_counter("rivet_gasoline_operation_errors")
-		.with_description("All errors made by this operation.")
-		.build();
+	pub static ref OPERATION_PENDING: IntGaugeVec = register_int_gauge_vec_with_registry!(
+		"gasoline_operation_pending",
+		"Total number of operation calls in progress.",
+		&["operation_name"],
+		*REGISTRY
+	).unwrap();
+	pub static ref OPERATION_TOTAL: IntCounterVec = register_int_counter_vec_with_registry!(
+		"gasoline_operation_total",
+		"Total number of operation calls.",
+		&["operation_name"],
+		*REGISTRY
+	).unwrap();
+	pub static ref OPERATION_DURATION: HistogramVec = register_histogram_vec_with_registry!(
+		"gasoline_operation_duration",
+		"Total duration of an op call.",
+		&["operation_name", "error"],
+		BUCKETS.to_vec(),
+		*REGISTRY
+	).unwrap();
+	pub static ref OPERATION_ERRORS: IntCounterVec = register_int_counter_vec_with_registry!(
+		"gasoline_operation_errors",
+		"All errors made by this operation.",
+		&["operation_name", "error"],
+		*REGISTRY
+	).unwrap();
+
+	// MARK: Load Shedding
+	pub static ref CPU_USAGE: Histogram = register_histogram_with_registry!(
+		"gasoline_cpu_usage",
+		"CPU usage (100 per core).",
+		vec![0.1, 0.25, 0.5, 1.0, 1.5, 2.0, 4.0, 8.0, 16.0],
+		*REGISTRY
+	).unwrap();
+	pub static ref LOAD_SHEDDING_RATIO: Histogram = register_histogram_with_registry!(
+		"gasoline_load_shedding_ratio",
+		"Load shedding ratio (0-1) based on CPU usage, determining the fraction of workflows to pull.",
+		vec![0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0],
+		*REGISTRY
+	).unwrap();
+
+	pub static ref DB_INSTANCE: IntGauge = register_int_gauge_with_registry!(
+		"gasoline_db_instance_count",
+		"Amount of DB instances currently active.",
+		*REGISTRY
+	).unwrap();
 }

package/packages/gasoline/src/prelude.rs

@@ -17,7 +17,7 @@ pub use crate::{
 	error::{WorkflowError, WorkflowResult},
 	executable::Executable,
 	history::removed::*,
-	listen::{CustomListener, Listen},
+	listen::Listen,
 	message::Message as MessageTrait,
 	operation::Operation as OperationTrait,
 	registry::Registry,

package/packages/gasoline/src/registry.rs

@@ -6,7 +6,7 @@ use tracing::Instrument;
 use crate::{
 	ctx::WorkflowCtx,
 	error::{WorkflowError, WorkflowResult},
-	workflow::Workflow,
+	workflow::{PruneVariant, Workflow},
 };
 
 pub type RegistryHandle = Arc<Registry>;
@@ -72,7 +72,9 @@ impl Registry {
 							// Differentiate between WorkflowError and user error
 							Err(err) => match err.downcast::<WorkflowError>() {
 								Ok(inner_err) => return Err(inner_err),
-								Err(err) => return Err(WorkflowError::WorkflowFailure(err)),
+								Err(err) => {
+									return Err(WorkflowError::WorkflowFailure(W::NAME, err));
+								}
 							},
 						};
 
@@ -85,6 +87,7 @@ impl Registry {
 					.in_current_span()
 					.boxed()
 				},
+				prune_variant: W::PRUNE_VARIANT,
 			}),
 		);
 
@@ -108,4 +111,5 @@ pub struct RegistryWorkflow {
 	) -> Pin<
 		Box<dyn Future<Output = WorkflowResult<Box<serde_json::value::RawValue>>> + Send + 'a>,
 	>,
+	pub prune_variant: PruneVariant,
 }