@rivetkit/engine 1.0.0

package/packages/gasoline/src/metrics.rs

@@ -0,0 +1,156 @@
+use rivet_metrics::{
+	BUCKETS,
+	otel::{global::*, metrics::*},
+};
+
+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();
+
+	/// 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();
+
+	/// 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();
+
+	/// 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();
+
+	/// 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();
+
+	/// 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();
+
+	/// 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();
+
+	/// 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();
+
+	/// 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();
+
+	// 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();
+}

package/packages/gasoline/src/operation.rs

@@ -0,0 +1,21 @@
+use std::fmt::Debug;
+
+use anyhow::Result;
+use async_trait::async_trait;
+
+use crate::ctx::OperationCtx;
+
+#[async_trait]
+pub trait Operation {
+	type Input: OperationInput;
+	type Output: Debug + Send;
+
+	const NAME: &'static str;
+	const TIMEOUT: std::time::Duration;
+
+	async fn run(ctx: &OperationCtx, input: &Self::Input) -> Result<Self::Output>;
+}
+
+pub trait OperationInput: Debug + Send {
+	type Operation: Operation;
+}

package/packages/gasoline/src/prelude.rs

@@ -0,0 +1,53 @@
+// Internal types
+#[doc(hidden)]
+pub use rivet_cache;
+#[doc(hidden)]
+pub use rivet_pools::{self, prelude::*};
+pub use rivet_util::{Id, future::CustomInstrumentExt, timestamp::DateTimeExt};
+
+pub mod util {
+	pub use rivet_util::*;
+}
+
+pub use crate::{
+	activity::Activity as ActivityTrait,
+	ctx::workflow::Loop,
+	ctx::*,
+	db::{self, Database},
+	error::{WorkflowError, WorkflowResult},
+	executable::Executable,
+	history::removed::*,
+	listen::{CustomListener, Listen},
+	message::Message as MessageTrait,
+	operation::Operation as OperationTrait,
+	registry::Registry,
+	signal::{Signal as SignalTrait, join_signal},
+	stub::{activity, closure, removed, v},
+	worker::Worker,
+	workflow::Workflow as WorkflowTrait,
+};
+pub use gasoline_macros::*;
+
+// External libraries
+#[doc(hidden)]
+pub use anyhow::{Context, Result, anyhow, bail, ensure};
+#[doc(hidden)]
+pub use async_trait;
+#[doc(hidden)]
+pub use futures_util;
+#[doc(hidden)]
+pub use serde::{Deserialize, Serialize};
+#[doc(hidden)]
+pub use serde_json;
+#[doc(hidden)]
+pub use tokio;
+#[doc(hidden)]
+pub use tracing;
+pub use tracing::Instrument;
+pub use uuid::Uuid;
+
+// External libraries for tests
+#[doc(hidden)]
+pub use rivet_metrics as __rivet_metrics;
+#[doc(hidden)]
+pub use rivet_runtime as __rivet_runtime;

package/packages/gasoline/src/registry.rs

@@ -0,0 +1,111 @@
+use std::{collections::HashMap, future::Future, pin::Pin, sync::Arc};
+
+use futures_util::FutureExt;
+use tracing::Instrument;
+
+use crate::{
+	ctx::WorkflowCtx,
+	error::{WorkflowError, WorkflowResult},
+	workflow::Workflow,
+};
+
+pub type RegistryHandle = Arc<Registry>;
+
+/// Contains a lookup map for workflow run handlers by workflow name.
+pub struct Registry {
+	pub(crate) workflows: HashMap<String, Arc<RegistryWorkflow>>,
+}
+
+impl Default for Registry {
+	fn default() -> Self {
+		Self::new()
+	}
+}
+
+impl Registry {
+	pub fn new() -> Self {
+		Registry {
+			workflows: HashMap::new(),
+		}
+	}
+
+	pub fn handle(self) -> RegistryHandle {
+		Arc::new(self)
+	}
+
+	pub fn merge(mut self, registry: Registry) -> WorkflowResult<Registry> {
+		// Check for duplicates
+		for workflow_name in registry.workflows.keys() {
+			if self.workflows.contains_key(workflow_name.as_str()) {
+				return Err(WorkflowError::DuplicateRegisteredWorkflow(
+					workflow_name.clone(),
+				));
+			}
+		}
+
+		self.workflows.extend(registry.workflows);
+
+		Ok(self)
+	}
+
+	pub fn register_workflow<W: Workflow>(&mut self) -> WorkflowResult<()> {
+		// Check for duplicates
+		if self.workflows.contains_key(W::NAME) {
+			return Err(WorkflowError::DuplicateRegisteredWorkflow(
+				W::NAME.to_string(),
+			));
+		}
+
+		self.workflows.insert(
+			W::NAME.to_string(),
+			Arc::new(RegistryWorkflow {
+				run: |ctx| {
+					async move {
+						// Deserialize input
+						let input = serde_json::from_str(ctx.input().get())
+							.map_err(WorkflowError::DeserializeWorkflowInput)?;
+
+						// Run workflow
+						let output = match W::run(ctx, &input).await {
+							Ok(x) => x,
+							// TODO: This should check .chain() for the error
+							// 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)),
+							},
+						};
+
+						// Serialize output
+						let output_val = serde_json::value::to_raw_value(&output)
+							.map_err(WorkflowError::SerializeWorkflowOutput)?;
+
+						Ok(output_val)
+					}
+					.in_current_span()
+					.boxed()
+				},
+			}),
+		);
+
+		Ok(())
+	}
+
+	pub fn get_workflow(&self, name: &str) -> WorkflowResult<&Arc<RegistryWorkflow>> {
+		self.workflows
+			.get(name)
+			.ok_or(WorkflowError::WorkflowMissingFromRegistry(name.to_string()))
+	}
+
+	pub fn size(&self) -> usize {
+		self.workflows.len()
+	}
+}
+
+pub struct RegistryWorkflow {
+	pub run: for<'a> fn(
+		&'a mut WorkflowCtx,
+	) -> Pin<
+		Box<dyn Future<Output = WorkflowResult<Box<serde_json::value::RawValue>>> + Send + 'a>,
+	>,
+}

package/packages/gasoline/src/signal.rs

@@ -0,0 +1,117 @@
+pub trait Signal {
+	const NAME: &'static str;
+}
+
+/// Creates an enum that implements `Listen` and selects one of X signals.
+///
+/// Example:
+/// ```rust
+/// #[signal("my_signal")]
+/// struct MySignal {
+/// 	x: i64,
+/// }
+
+/// #[signal("my_signal2")]
+/// struct MySignal2 {
+/// 	y: i64,
+/// }
+///
+/// join_signal!(MyJoinSignal {
+/// 	MySignal,
+/// 	MySignal2
+/// });
+///
+/// // Automatically becomes:
+/// enum MyJoinSignal {
+/// 	MySignal(MySignal),
+/// 	MySignal2(MySignal2),
+/// }
+///
+/// // Listening:
+/// match ctx.listen::<MyJoinSignal>() {
+/// 	MySignal(sig) => println!("received MySignal {sig:?}"),
+/// 	MySignal2(sig) => println!("received MySignal2 {sig:?}"),
+/// }
+///
+///
+/// // Also allows aliases:
+/// join_signal!(MyJoinSignal {
+/// 	MySignal,
+/// 	MySignal2(some_pkg::Signal),
+/// }
+/// ```
+#[macro_export]
+macro_rules! join_signal {
+	($vis:vis $join:ident { $($tt:tt)* }) => {
+		join_signal!(@ $vis $join [] [] $($tt)*);
+	};
+	(@
+	    $vis:vis $join:ident
+	    [$({ $names:tt } { $types:tt })*]
+	    [$({ $just_types:tt })*]
+	) => {
+    	$vis enum $join {
+			$( $names ($types) ),*
+		}
+
+    	#[async_trait::async_trait]
+		impl Listen for $join {
+			#[tracing::instrument(skip_all, fields(t=std::any::type_name::<Self>()))]
+			async fn listen(ctx: &mut gas::prelude::ListenCtx) -> gas::prelude::WorkflowResult<Self> {
+				let row = ctx.listen_any(&[
+				    $(<$just_types as gas::signal::Signal>::NAME),*
+				]).await?;
+
+				Self::parse(&row.signal_name, &row.body)
+			}
+
+			fn parse(name: &str, body: &serde_json::value::RawValue) -> gas::prelude::WorkflowResult<Self> {
+				$(
+				    if name == <$types as gas::signal::Signal>::NAME {
+						std::result::Result::Ok(
+							Self::$names(
+								serde_json::from_str(body.get())
+									.map_err(WorkflowError::DeserializeSignalBody)?
+							)
+						)
+					}
+				)else*
+				else {
+					unreachable!(
+						"received signal that wasn't queried for: {}, expected {:?}",
+						name, &[$(<$just_types as gas::signal::Signal>::NAME),*]
+					);
+				}
+			}
+		}
+    };
+	(@
+	    $vis:vis $join:ident
+	    [$({ $names:tt } { $types:tt })*]
+	    [$({ $just_types:tt })*]
+	    $name:ident,
+	    $($tail:tt)*
+	) => {
+	   join_signal!(@
+	       $vis $join
+	       [$( { $names } { $types } )* { $name } { $name }]
+	       [$( { $just_types } )* { $name }]
+	       $($tail)*
+	   );
+	};
+	(@
+	    $vis:vis $join:ident
+	    [$({ $names:tt } { $types:tt })*]
+	    [$({ $just_types:tt })*]
+	    $name:ident($ty:ty),
+	    $($tail:tt)*
+	) => {
+	   join_signal!(@
+	       $vis $join
+	       [$( { $names } { $types } )* { $name } { $ty }]
+	       [$( { $just_types } )* { $ty }]
+	       $($tail)*
+	   );
+	};
+}
+pub use join_signal;

package/packages/gasoline/src/stub.rs

@@ -0,0 +1,118 @@
+//! Stubs provide the ability to create the blueprint for a workflow step without a workflow context, so its
+//! execution can be deferred to later
+
+// TODO: Add signal, workflow, message, stubs
+
+use std::marker::PhantomData;
+
+use anyhow::Result;
+use async_trait::async_trait;
+
+use crate::{
+	activity::{Activity, ActivityInput},
+	ctx::WorkflowCtx,
+	error::WorkflowResult,
+	executable::{AsyncResult, Executable},
+	history::removed::Removed,
+};
+
+// Must wrap all closures being used as executables in this function due to
+// https://github.com/rust-lang/rust/issues/70263
+pub fn closure<F, T: Send>(f: F) -> F
+where
+	F: for<'a> FnOnce(&'a mut WorkflowCtx) -> AsyncResult<'a, T> + Send,
+{
+	f
+}
+
+pub struct ActivityStub<I>
+where
+	I: ActivityInput,
+	<I as ActivityInput>::Activity: Activity<Input = I>,
+{
+	inner: I,
+	version: Option<usize>,
+}
+
+#[async_trait]
+impl<I> Executable for ActivityStub<I>
+where
+	I: ActivityInput + Send + Sync,
+	<I as ActivityInput>::Activity: Activity<Input = I>,
+{
+	type Output = <I::Activity as Activity>::Output;
+
+	#[tracing::instrument(skip_all)]
+	async fn execute(self, ctx: &mut WorkflowCtx) -> Result<Self::Output> {
+		if let Some(version) = self.version {
+			ctx.v(version).activity(self.inner).await
+		} else {
+			ctx.activity(self.inner).await
+		}
+	}
+
+	fn shift_cursor(&self, ctx: &mut WorkflowCtx) -> WorkflowResult<()> {
+		let history_res = ctx
+			.cursor()
+			.compare_activity(self.version.unwrap_or(ctx.version()), &I::Activity::NAME)?;
+		let location = ctx.cursor().current_location_for(&history_res);
+
+		ctx.cursor_mut().update(&location);
+
+		Ok(())
+	}
+}
+
+// Wraps activity inputs for trait impl
+pub fn activity<I>(input: I) -> ActivityStub<I>
+where
+	I: ActivityInput,
+	<I as ActivityInput>::Activity: Activity<Input = I>,
+{
+	ActivityStub {
+		inner: input,
+		version: None,
+	}
+}
+
+pub struct VersionStub {
+	version: usize,
+}
+
+impl VersionStub {
+	pub fn activity<I>(self, input: I) -> ActivityStub<I>
+	where
+		I: ActivityInput,
+		<I as ActivityInput>::Activity: Activity<Input = I>,
+	{
+		ActivityStub {
+			inner: input,
+			version: Some(self.version),
+		}
+	}
+}
+
+pub fn v(version: usize) -> VersionStub {
+	VersionStub { version }
+}
+
+pub struct RemovedStub<T: Removed>(PhantomData<T>);
+
+#[async_trait]
+impl<T: Removed + Send + Sync> Executable for RemovedStub<T> {
+	type Output = ();
+
+	#[tracing::instrument(skip_all)]
+	async fn execute(self, ctx: &mut WorkflowCtx) -> Result<Self::Output> {
+		ctx.removed::<T>().await
+	}
+
+	fn shift_cursor(&self, ctx: &mut WorkflowCtx) -> WorkflowResult<()> {
+		ctx.cursor_mut().inc();
+		Ok(())
+	}
+}
+
+pub fn removed<T: Removed>() -> RemovedStub<T> {
+	RemovedStub(PhantomData)
+}

package/packages/gasoline/src/utils/mod.rs

@@ -0,0 +1,20 @@
+pub mod tags;
+pub mod time;
+
+/// Returns true if `subset` is a subset of `superset`.
+pub fn is_value_subset(subset: &serde_json::Value, superset: &serde_json::Value) -> bool {
+	match (subset, superset) {
+		(serde_json::Value::Object(sub_obj), serde_json::Value::Object(super_obj)) => {
+			sub_obj.iter().all(|(k, sub_val)| {
+				super_obj
+					.get(k)
+					.map_or(false, |super_val| is_value_subset(sub_val, super_val))
+			})
+		}
+		(serde_json::Value::Array(sub_arr), serde_json::Value::Array(super_arr)) => sub_arr
+			.iter()
+			.zip(super_arr)
+			.all(|(sub_val, super_val)| is_value_subset(sub_val, super_val)),
+		_ => subset == superset,
+	}
+}

package/packages/gasoline/src/utils/tags.rs

@@ -0,0 +1,82 @@
+use std::fmt::Display;
+
+use serde::Serialize;
+
+use crate::error::{WorkflowError, WorkflowResult};
+
+pub trait AsTags: Send + Sync {
+	fn as_tags(&self) -> WorkflowResult<serde_json::Value>;
+	fn as_cjson_tags(&self) -> WorkflowResult<String>;
+}
+
+impl<T: Display + Send + Sync, U: Serialize + Send + Sync> AsTags for (T, U) {
+	fn as_tags(&self) -> WorkflowResult<serde_json::Value> {
+		let (k, v) = self;
+		Ok(serde_json::Value::Object(
+			IntoIterator::into_iter([(
+				k.to_string(),
+				serde_json::to_value(v).map_err(WorkflowError::SerializeTags)?,
+			)])
+			.collect(),
+		))
+	}
+
+	fn as_cjson_tags(&self) -> WorkflowResult<String> {
+		cjson::to_string(&self.as_tags()?).map_err(WorkflowError::CjsonSerializeTags)
+	}
+}
+
+impl<T: Display + Send + Sync, U: Serialize + Send + Sync> AsTags for &[(T, U)] {
+	fn as_tags(&self) -> WorkflowResult<serde_json::Value> {
+		let mut map = serde_json::Map::new();
+		for (k, v) in self.iter() {
+			map.insert(
+				k.to_string(),
+				serde_json::to_value(v).map_err(WorkflowError::SerializeTags)?,
+			);
+		}
+		Ok(serde_json::Value::Object(map))
+	}
+
+	fn as_cjson_tags(&self) -> WorkflowResult<String> {
+		cjson::to_string(&self.as_tags()?).map_err(WorkflowError::CjsonSerializeTags)
+	}
+}
+
+impl AsTags for serde_json::Value {
+	fn as_tags(&self) -> WorkflowResult<serde_json::Value> {
+		match self {
+			serde_json::Value::Object(_) => Ok(self.clone()),
+			_ => Err(WorkflowError::InvalidTags("must be an object".to_string())),
+		}
+	}
+
+	fn as_cjson_tags(&self) -> WorkflowResult<String> {
+		match self {
+			serde_json::Value::Object(_) => {
+				cjson::to_string(&self).map_err(WorkflowError::CjsonSerializeTags)
+			}
+			_ => Err(WorkflowError::InvalidTags("must be an object".to_string())),
+		}
+	}
+}
+
+impl AsTags for () {
+	fn as_tags(&self) -> WorkflowResult<serde_json::Value> {
+		Ok(serde_json::Value::Object(serde_json::Map::new()))
+	}
+
+	fn as_cjson_tags(&self) -> WorkflowResult<String> {
+		Ok(String::new())
+	}
+}
+
+impl<T: AsTags> AsTags for &T {
+	fn as_tags(&self) -> WorkflowResult<serde_json::Value> {
+		(*self).as_tags()
+	}
+
+	fn as_cjson_tags(&self) -> WorkflowResult<String> {
+		(*self).as_cjson_tags()
+	}
+}