From 292c6bc88e5bd3753169683cbe7d95e16d14e082 Mon Sep 17 00:00:00 2001
From: Jesse Szwedko <jesse@szwedko.me>
Date: Mon, 18 Jan 2021 13:23:38 -0400
Subject: [PATCH 01/19] chore(external docs): Document additional ACLs for
 aws_s3 sink (#6087)

* chore(external docs): Document additional ACLs for aws_s3 sink

Added in https://github.com/timberio/vector/pull/3439
---
 docs/reference/components/sinks/aws_s3.cue | 14 ++++++++------
 docs/reference/urls.cue                    |  1 +
 2 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/docs/reference/components/sinks/aws_s3.cue b/docs/reference/components/sinks/aws_s3.cue
index e7a34a3a01db1..792e5cba2470a 100644
--- a/docs/reference/components/sinks/aws_s3.cue
+++ b/docs/reference/components/sinks/aws_s3.cue
@@ -91,12 +91,14 @@ components: sinks: aws_s3: components._aws & {
 			type: string: {
 				default: null
 				enum: {
-					"private":            "Owner gets FULL_CONTROL. No one else has access rights (default)."
-					"public-read":        "Owner gets FULL_CONTROL. The AllUsers group gets READ access."
-					"public-read-write":  "Owner gets FULL_CONTROL. The AllUsers group gets READ and WRITE access. Granting this on a bucket is generally not recommended."
-					"aws-exec-read":      "Owner gets FULL_CONTROL. Amazon EC2 gets READ access to GET an Amazon Machine Image (AMI) bundle from Amazon S3."
-					"authenticated-read": "Owner gets FULL_CONTROL. The AuthenticatedUsers group gets READ access."
-					"log-delivery-write": "The LogDelivery group gets WRITE and READ_ACP permissions on the bucket. For more information about logs, see [Amazon S3 Server Access Logging](https://docs.aws.amazon.com/AmazonS3/latest/dev/ServerLogs.html)."
+					"private":                   "Owner gets `FULL_CONTROL`. No one else has access rights (default)."
+					"public-read":               "Owner gets `FULL_CONTROL`. The AllUsers group gets `READ` access."
+					"public-read-write":         "Owner gets `FULL_CONTROL`. The AllUsers group gets `READ` and `WRITE` access. Granting this on a bucket is generally not recommended."
+					"aws-exec-read":             "Owner gets `FULL_CONTROL`. Amazon EC2 gets `READ` access to `GET` an Amazon Machine Image (AMI) bundle from Amazon S3."
+					"authenticated-read":        "Owner gets `FULL_CONTROL`. The AuthenticatedUsers group gets `READ` access."
+					"bucket-owner-read":         "Object owner gets `FULL_CONTROL`. Bucket owner gets `READ. access."
+					"bucket-owner-full-control": "Both the object owner and the bucket owner get `FULL_CONTROL` over the object."
+					"log-delivery-write":        "The LogDelivery group gets `WRITE` and `READ_ACP` permissions on the bucket. For more information about logs, see [Amazon S3 Server Access Logging](\(urls.aws_s3_server_access_logs))."
 				}
 			}
 		}
diff --git a/docs/reference/urls.cue b/docs/reference/urls.cue
index fefc8c2e31dcd..061502f5cb376 100644
--- a/docs/reference/urls.cue
+++ b/docs/reference/urls.cue
@@ -67,6 +67,7 @@ urls: {
 	aws_s3_grantee:                                           "\(aws_docs)/AmazonS3/latest/dev/acl-overview.html#specifying-grantee"
 	aws_s3_metadata:                                          "\(aws_docs)/AmazonS3/latest/dev/UsingMetadata.html#object-metadata"
 	aws_s3_regions:                                           "\(aws_docs)/general/latest/gr/rande.html#s3_region"
+	aws_s3_server_access_logs:                                "\(aws_docs)/AmazonS3/latest/dev/ServerLogs.html"
 	aws_s3_service_limits:                                    "\(aws_docs)/streams/latest/dev/service-sizes-and-limits.html"
 	aws_s3_sse:                                               "\(aws_docs)/AmazonS3/latest/dev/UsingServerSideEncryption.html"
 	aws_s3_storage_classes:                                   "https://aws.amazon.com/s3/storage-classes/"

From 7e838abbe9d9cf6a338dde55a31a6ba9727a425e Mon Sep 17 00:00:00 2001
From: MOZGIII <mike-n@narod.ru>
Date: Mon, 18 Jan 2021 21:03:55 +0300
Subject: [PATCH 02/19] chore(external docs): Remove the rawConfig from Helm
 tutorial (#6116)

Signed-off-by: MOZGIII <mike-n@narod.ru>
---
 docs/reference/installation/_interfaces/helm3.cue | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/docs/reference/installation/_interfaces/helm3.cue b/docs/reference/installation/_interfaces/helm3.cue
index b84f33c54d67c..d9c3bc8c60117 100644
--- a/docs/reference/installation/_interfaces/helm3.cue
+++ b/docs/reference/installation/_interfaces/helm3.cue
@@ -41,9 +41,8 @@ installation: _interfaces: "helm3": {
 				  stdout:
 				    type: console
 				    inputs: ["kubernetes_logs"]
-				    rawConfig: |
-				      target = "stdout"
-				      encoding = "json"
+				    target: "stdout"
+				    encoding: "json"
 				VALUES
 				"""#
 			install:   #"helm install --namespace \#(_namespace) --create-namespace \#(_release_name) \#(_repo_name)/\#(_chart_name) --values values.yaml"#

From f5f7228339fe3362d1cb841324deb87eeef78eb0 Mon Sep 17 00:00:00 2001
From: MOZGIII <mike-n@narod.ru>
Date: Mon, 18 Jan 2021 21:04:24 +0300
Subject: [PATCH 03/19] fix(kubernetes_logs source): Support for collecting
 logs from static pods (#6056)

---
 src/kubernetes/hash_value.rs                  | 83 ++++++++++++++++++-
 src/kubernetes/mod.rs                         |  1 +
 src/kubernetes/pod_manager_logic.rs           | 71 ++++++++++++++++
 src/kubernetes/state/evmap.rs                 | 22 +++++
 .../kubernetes_logs/k8s_paths_provider.rs     | 57 ++++++++++++-
 5 files changed, 229 insertions(+), 5 deletions(-)
 create mode 100644 src/kubernetes/pod_manager_logic.rs

diff --git a/src/kubernetes/hash_value.rs b/src/kubernetes/hash_value.rs
index 6a41d9f33e14b..3688910272b45 100644
--- a/src/kubernetes/hash_value.rs
+++ b/src/kubernetes/hash_value.rs
@@ -4,6 +4,8 @@ use k8s_openapi::{apimachinery::pkg::apis::meta::v1::ObjectMeta, Metadata};
 use std::hash::{Hash, Hasher};
 use std::ops::Deref;
 
+use super::pod_manager_logic::extract_static_pod_config_hashsum;
+
 /// A wrapper that provides a [`Hash`] implementation for any k8s resource
 /// object.
 /// Delegates to object uid for hashing and equality.
@@ -20,10 +22,17 @@ where
     }
 
     /// Get the `uid` from the `T`'s [`Metadata`] (if any).
+    ///
+    /// If the static pod config hashsum annotation exists in the metadata, it
+    /// will be used instead of the mirror pod uid.
     pub fn uid(&self) -> Option<&str> {
-        let ObjectMeta { ref uid, .. } = self.0.metadata();
-        let uid = uid.as_ref()?;
-        Some(uid.as_str())
+        let metadata = self.0.metadata();
+        // If static pod config hashsum annotation exists in the metadata -
+        // use it instead of the uid.
+        if let Some(config_hashsum) = extract_static_pod_config_hashsum(metadata) {
+            return Some(config_hashsum);
+        }
+        Some(metadata.uid.as_ref()?.as_str())
     }
 }
 
@@ -70,3 +79,71 @@ where
         &self.0
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use k8s_openapi::api::core::v1::Pod;
+
+    use super::*;
+
+    #[test]
+    fn test_uid() {
+        let cases = vec![
+            // No uid or config hashsum.
+            (Pod::default(), None),
+            // Has uid, doesn't have a config hashsum.
+            (
+                Pod {
+                    metadata: ObjectMeta {
+                        uid: Some("uid".to_owned()),
+                        ..ObjectMeta::default()
+                    },
+                    ..Pod::default()
+                },
+                Some("uid"),
+            ),
+            // Has both the uid and the config hashsum.
+            (
+                Pod {
+                    metadata: ObjectMeta {
+                        uid: Some("uid".to_owned()),
+                        annotations: Some(
+                            vec![(
+                                "kubernetes.io/config.mirror".to_owned(),
+                                "config-hashsum".to_owned(),
+                            )]
+                            .into_iter()
+                            .collect(),
+                        ),
+                        ..ObjectMeta::default()
+                    },
+                    ..Pod::default()
+                },
+                Some("config-hashsum"),
+            ),
+            // Has only the config hashsum.
+            (
+                Pod {
+                    metadata: ObjectMeta {
+                        annotations: Some(
+                            vec![(
+                                "kubernetes.io/config.mirror".to_owned(),
+                                "config-hashsum".to_owned(),
+                            )]
+                            .into_iter()
+                            .collect(),
+                        ),
+                        ..ObjectMeta::default()
+                    },
+                    ..Pod::default()
+                },
+                Some("config-hashsum"),
+            ),
+        ];
+
+        for (pod, expected) in cases {
+            let hash_value = HashValue::new(pod);
+            assert_eq!(hash_value.uid(), expected);
+        }
+    }
+}
diff --git a/src/kubernetes/mod.rs b/src/kubernetes/mod.rs
index f9df1a26cf21c..5be1f97714b65 100644
--- a/src/kubernetes/mod.rs
+++ b/src/kubernetes/mod.rs
@@ -27,6 +27,7 @@ pub mod hash_value;
 pub mod instrumenting_watcher;
 pub mod mock_watcher;
 pub mod multi_response_decoder;
+pub mod pod_manager_logic;
 pub mod reflector;
 pub mod resource_version;
 pub mod state;
diff --git a/src/kubernetes/pod_manager_logic.rs b/src/kubernetes/pod_manager_logic.rs
new file mode 100644
index 0000000000000..fc4fc05b6839d
--- /dev/null
+++ b/src/kubernetes/pod_manager_logic.rs
@@ -0,0 +1,71 @@
+//! This mod contains bits of logic related to the `kubelet` part called
+//! Pod Manager internal implementation.
+
+use k8s_openapi::apimachinery::pkg::apis::meta::v1::ObjectMeta;
+
+/// Extract the static pod config hashsum from the mirror pod annotations.
+///
+/// This part of Kubernetes changed a bit over time, so we're implemeting
+/// support up to 1.14, which is an MSKV at this time.
+///
+/// See: https://github.com/kubernetes/kubernetes/blob/cea1d4e20b4a7886d8ff65f34c6d4f95efcb4742/pkg/kubelet/pod/mirror_client.go#L80-L81
+pub fn extract_static_pod_config_hashsum(metadata: &ObjectMeta) -> Option<&str> {
+    let annotations = metadata.annotations.as_ref()?;
+    annotations
+        .get("kubernetes.io/config.mirror")
+        .map(String::as_str)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_extract_static_pod_config_hashsum() {
+        let cases = vec![
+            (ObjectMeta::default(), None),
+            (
+                ObjectMeta {
+                    annotations: Some(vec![].into_iter().collect()),
+                    ..ObjectMeta::default()
+                },
+                None,
+            ),
+            (
+                ObjectMeta {
+                    annotations: Some(
+                        vec![(
+                            "kubernetes.io/config.mirror".to_owned(),
+                            "config-hashsum".to_owned(),
+                        )]
+                        .into_iter()
+                        .collect(),
+                    ),
+                    ..ObjectMeta::default()
+                },
+                Some("config-hashsum"),
+            ),
+            (
+                ObjectMeta {
+                    annotations: Some(
+                        vec![
+                            (
+                                "kubernetes.io/config.mirror".to_owned(),
+                                "config-hashsum".to_owned(),
+                            ),
+                            ("other".to_owned(), "value".to_owned()),
+                        ]
+                        .into_iter()
+                        .collect(),
+                    ),
+                    ..ObjectMeta::default()
+                },
+                Some("config-hashsum"),
+            ),
+        ];
+
+        for (metadata, expected) in cases {
+            assert_eq!(extract_static_pod_config_hashsum(&metadata), expected);
+        }
+    }
+}
diff --git a/src/kubernetes/state/evmap.rs b/src/kubernetes/state/evmap.rs
index a7fa5c63d9db6..5f496e82b6003 100644
--- a/src/kubernetes/state/evmap.rs
+++ b/src/kubernetes/state/evmap.rs
@@ -149,6 +149,28 @@ mod tests {
         assert_eq!(val, Box::new(HashValue::new(pod)));
     }
 
+    #[test]
+    fn test_kv_static_pod() {
+        let pod = Pod {
+            metadata: ObjectMeta {
+                uid: Some("uid".to_owned()),
+                annotations: Some(
+                    vec![(
+                        "kubernetes.io/config.mirror".to_owned(),
+                        "config-hashsum".to_owned(),
+                    )]
+                    .into_iter()
+                    .collect(),
+                ),
+                ..ObjectMeta::default()
+            },
+            ..Pod::default()
+        };
+        let (key, val) = kv(pod.clone()).unwrap();
+        assert_eq!(key, "config-hashsum");
+        assert_eq!(val, Box::new(HashValue::new(pod)));
+    }
+
     #[tokio::test]
     async fn test_without_debounce() {
         let (state_reader, state_writer) = evmap::new();
diff --git a/src/sources/kubernetes_logs/k8s_paths_provider.rs b/src/sources/kubernetes_logs/k8s_paths_provider.rs
index 5bee0ca94966e..04a35a3bc25dc 100644
--- a/src/sources/kubernetes_logs/k8s_paths_provider.rs
+++ b/src/sources/kubernetes_logs/k8s_paths_provider.rs
@@ -3,7 +3,7 @@
 #![deny(missing_docs)]
 
 use super::path_helpers::build_pod_logs_directory;
-use crate::kubernetes as k8s;
+use crate::kubernetes::{self as k8s, pod_manager_logic::extract_static_pod_config_hashsum};
 use evmap::ReadHandle;
 use file_source::paths_provider::PathsProvider;
 use k8s_openapi::api::core::v1::Pod;
@@ -60,11 +60,38 @@ impl PathsProvider for K8sPathsProvider {
     }
 }
 
+/// This function takes a `Pod` resource and returns the path to where the logs
+/// for the said `Pod` are expected to be found.
+///
+/// In the common case, the effective path is built using the `namespace`,
+/// `name` and `uid` of the Pod. However, there's a special case for
+/// `Static Pod`s: they keep their logs at the path that consists of config
+/// hashsum instead of the `Pod` `uid`. The reason for this is `kubelet` is
+/// locally authoritative over those `Pod`s, and the API only has
+/// `Monitor Pod`s - the "dummy" entires useful for discovery and association.
+/// Their UIDs are generated at the Kubernetes API side, and do not represent
+/// the actual config hashsum as one would expect.
+///
+/// To work around this, we use the mirror pod annotations (if any) to obtain
+/// the effective config hashsum, see the `extract_static_pod_config_hashsum`
+/// function that does this.
+///
+/// See https://github.com/timberio/vector/issues/6001
+/// See https://github.com/kubernetes/kubernetes/blob/ef3337a443b402756c9f0bfb1f844b1b45ce289d/pkg/kubelet/pod/pod_manager.go#L30-L44
+/// See https://github.com/kubernetes/kubernetes/blob/cea1d4e20b4a7886d8ff65f34c6d4f95efcb4742/pkg/kubelet/pod/mirror_client.go#L80-L81
 fn extract_pod_logs_directory(pod: &Pod) -> Option<PathBuf> {
     let metadata = &pod.metadata;
     let namespace = metadata.namespace.as_ref()?;
     let name = metadata.name.as_ref()?;
-    let uid = metadata.uid.as_ref()?;
+
+    let uid = if let Some(static_pod_config_hashsum) = extract_static_pod_config_hashsum(metadata) {
+        // If there's a static pod config hashsum - use it instead of uid.
+        static_pod_config_hashsum
+    } else {
+        // In the common case - just fallback to the real pod uid.
+        metadata.uid.as_ref()?
+    };
+
     Some(build_pod_logs_directory(&namespace, &name, &uid))
 }
 
@@ -174,7 +201,9 @@ mod tests {
     #[test]
     fn test_extract_pod_logs_directory() {
         let cases = vec![
+            // Empty pod.
             (Pod::default(), None),
+            // Happy path.
             (
                 Pod {
                     metadata: ObjectMeta {
@@ -187,6 +216,7 @@ mod tests {
                 },
                 Some("/var/log/pods/sandbox0-ns_sandbox0-name_sandbox0-uid"),
             ),
+            // No uid.
             (
                 Pod {
                     metadata: ObjectMeta {
@@ -198,6 +228,7 @@ mod tests {
                 },
                 None,
             ),
+            // No name.
             (
                 Pod {
                     metadata: ObjectMeta {
@@ -209,6 +240,7 @@ mod tests {
                 },
                 None,
             ),
+            // No namespace.
             (
                 Pod {
                     metadata: ObjectMeta {
@@ -220,6 +252,27 @@ mod tests {
                 },
                 None,
             ),
+            // Static pod config hashsum as uid.
+            (
+                Pod {
+                    metadata: ObjectMeta {
+                        namespace: Some("sandbox0-ns".to_owned()),
+                        name: Some("sandbox0-name".to_owned()),
+                        uid: Some("sandbox0-uid".to_owned()),
+                        annotations: Some(
+                            vec![(
+                                "kubernetes.io/config.mirror".to_owned(),
+                                "sandbox0-config-hashsum".to_owned(),
+                            )]
+                            .into_iter()
+                            .collect(),
+                        ),
+                        ..ObjectMeta::default()
+                    },
+                    ..Pod::default()
+                },
+                Some("/var/log/pods/sandbox0-ns_sandbox0-name_sandbox0-config-hashsum"),
+            ),
         ];
 
         for (pod, expected) in cases {

From fee348396779b009d28ae5b7fbbf663b7bb46ffe Mon Sep 17 00:00:00 2001
From: Ian Henry <ianjhenry00@gmail.com>
Date: Mon, 18 Jan 2021 13:33:02 -0500
Subject: [PATCH 04/19] chore(host_metrics source): Adds cue docs for
 customizing sysfs and procfs in host_metrics component (#6033)

Co-authored-by: Binary Logic <bjohnson@binarylogic.com>
Co-authored-by: James Turnbull <james@lovedthanlost.net>
---
 .../components/sources/host_metrics.cue        | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/docs/reference/components/sources/host_metrics.cue b/docs/reference/components/sources/host_metrics.cue
index 7c9a3cac70b83..bc8f2c457113a 100644
--- a/docs/reference/components/sources/host_metrics.cue
+++ b/docs/reference/components/sources/host_metrics.cue
@@ -45,6 +45,24 @@ components: sources: host_metrics: {
 		platform_name: null
 	}
 
+	env_vars: {
+		PROCFS_ROOT: {
+			description: "Sets an arbitrary path to the system's Procfs root. Can be used to expose host metrics from within a container. Unset and uses system `/proc` by default."
+			type: string: {
+				default: null
+				examples: ["/mnt/host/proc"]
+			}
+		}
+
+		SYSFS_ROOT: {
+			description: "Sets an arbitrary path to the system's Sysfs root. Can be used to expose host metrics from within a container. Unset and uses system `/sys` by default."
+			type: string: {
+				default: null
+				examples: ["/mnt/host/sys"]
+			}
+		}
+	}
+
 	configuration: {
 		collectors: {
 			description: "The list of host metric collector services to use. Defaults to all collectors."

From a2107bb182d471b5a351600d4ff8079de066564b Mon Sep 17 00:00:00 2001
From: Jean Mertz <git@jeanmertz.com>
Date: Mon, 18 Jan 2021 23:20:07 +0100
Subject: [PATCH 05/19] feat(remap): diagnostic error messages (#6023)

---
 Cargo.lock                                    |   12 +
 lib/remap-cli/src/cmd.rs                      |   14 +-
 lib/remap-cli/src/lib.rs                      |    7 +-
 lib/remap-cli/src/repl.rs                     |   31 +-
 lib/remap-lang/Cargo.toml                     |    2 +
 lib/remap-lang/src/diagnostic.rs              |  488 ++++++
 lib/remap-lang/src/error.rs                   |   68 +-
 lib/remap-lang/src/expression.rs              |   14 +-
 lib/remap-lang/src/expression/array.rs        |    4 -
 lib/remap-lang/src/expression/assignment.rs   |   53 +-
 lib/remap-lang/src/expression/function.rs     |   63 +-
 lib/remap-lang/src/expression/if_statement.rs |   89 +-
 lib/remap-lang/src/expression/not.rs          |    6 -
 lib/remap-lang/src/expression/path.rs         |   41 +-
 lib/remap-lang/src/expression/variable.rs     |   44 +-
 lib/remap-lang/src/lib.rs                     |  133 +-
 lib/remap-lang/src/parser.rs                  | 1353 +++++++++++------
 lib/remap-lang/src/path.rs                    |   36 +-
 lib/remap-lang/src/program.rs                 |  298 ++--
 lib/remap-lang/src/runtime.rs                 |   34 +-
 lib/remap-lang/src/state.rs                   |   29 +
 lib/remap-lang/src/value.rs                   |    1 +
 lib/remap-tests/src/main.rs                   |   49 +-
 ...ent_fallible_for_infallible_expression.vrl |   15 +
 .../tests/assignment_variable_with_path.vrl   |   14 +
 .../tests/fallible_root_expression.vrl        |   16 +
 .../tests/function_call_abort_infallible.vrl  |   15 +
 .../tests/function_call_internal_error.vrl    |   16 +
 .../function_call_invalid_argument_type.vrl   |   16 +
 .../tests/function_call_missing_argument.vrl  |   12 +
 .../tests/function_call_undefined.vrl         |   12 +
 .../tests/function_call_unknown_keyword.vrl   |   12 +
 .../tests/funtion_call_arity_mismatch.vrl     |   15 +
 .../if_statement_non_boolean_condition.vrl    |   18 +
 lib/remap-tests/tests/invalid_path.vrl        |   16 +-
 lib/remap-tests/tests/regex_invalid.vrl       |   16 +
 scripts/check-style.sh                        |    1 +
 src/conditions/remap.rs                       |   66 +-
 src/mapping/query/query_value.rs              |    1 +
 src/transforms/remap.rs                       |   17 +-
 tests/behavior/transforms/coercer.toml        |    4 +-
 tests/behavior/transforms/filter.toml         |    4 +-
 tests/behavior/transforms/reduce.toml         |   14 +-
 tests/behavior/transforms/remap.toml          |  307 ++--
 44 files changed, 2306 insertions(+), 1170 deletions(-)
 create mode 100644 lib/remap-lang/src/diagnostic.rs
 create mode 100644 lib/remap-tests/tests/assignment_fallible_for_infallible_expression.vrl
 create mode 100644 lib/remap-tests/tests/assignment_variable_with_path.vrl
 create mode 100644 lib/remap-tests/tests/fallible_root_expression.vrl
 create mode 100644 lib/remap-tests/tests/function_call_abort_infallible.vrl
 create mode 100644 lib/remap-tests/tests/function_call_internal_error.vrl
 create mode 100644 lib/remap-tests/tests/function_call_invalid_argument_type.vrl
 create mode 100644 lib/remap-tests/tests/function_call_missing_argument.vrl
 create mode 100644 lib/remap-tests/tests/function_call_undefined.vrl
 create mode 100644 lib/remap-tests/tests/function_call_unknown_keyword.vrl
 create mode 100644 lib/remap-tests/tests/funtion_call_arity_mismatch.vrl
 create mode 100644 lib/remap-tests/tests/if_statement_non_boolean_condition.vrl
 create mode 100644 lib/remap-tests/tests/regex_invalid.vrl

diff --git a/Cargo.lock b/Cargo.lock
index f0307bfbda773..9a9b4138c77ba 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -943,6 +943,16 @@ dependencies = [
  "tracing 0.1.22",
 ]
 
+[[package]]
+name = "codespan-reporting"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c6ce42b8998a383572e0a802d859b1f00c79b7b7474e62fff88ee5c2845d9c13"
+dependencies = [
+ "termcolor",
+ "unicode-width",
+]
+
 [[package]]
 name = "colored"
 version = "2.0.0"
@@ -5353,6 +5363,7 @@ dependencies = [
  "bitflags",
  "bytes 0.5.6",
  "chrono",
+ "codespan-reporting",
  "criterion",
  "dyn-clone",
  "paste",
@@ -5360,6 +5371,7 @@ dependencies = [
  "pest_derive",
  "regex",
  "serde",
+ "termcolor",
  "thiserror",
 ]
 
diff --git a/lib/remap-cli/src/cmd.rs b/lib/remap-cli/src/cmd.rs
index c6bfc18b46d43..b8a8c5e1bf19c 100644
--- a/lib/remap-cli/src/cmd.rs
+++ b/lib/remap-cli/src/cmd.rs
@@ -1,5 +1,5 @@
 use super::{repl, Error};
-use remap::{state, Object, Program, Runtime, Value};
+use remap::{state, Formatter, Object, Program, Runtime, Value};
 use std::collections::BTreeMap;
 use std::fs::File;
 use std::io::{self, Read};
@@ -51,7 +51,7 @@ fn run(opts: &Opts) -> Result<(), Error> {
         repl(objects)
     } else {
         for mut object in objects {
-            let result = execute(&mut object, &program).map(|v| {
+            let result = execute(&mut object, program.clone()).map(|v| {
                 if opts.print_object {
                     object.to_string()
                 } else {
@@ -79,12 +79,16 @@ fn repl(object: Vec<Value>) -> Result<(), Error> {
     Err(Error::ReplFeature)
 }
 
-fn execute(object: &mut impl Object, program: &str) -> Result<Value, Error> {
+fn execute(object: &mut impl Object, source: String) -> Result<Value, Error> {
     let state = state::Program::default();
     let mut runtime = Runtime::new(state);
-    let program = Program::new(program, &remap_functions::all(), None, true)?;
+    let (program, _) = Program::new(source.clone(), &remap_functions::all(), None, true).map_err(
+        |diagnostics| Error::Parse(Formatter::new(&source, diagnostics).colored().to_string()),
+    )?;
 
-    runtime.execute(object, &program).map_err(Into::into)
+    runtime
+        .run(object, &program)
+        .map_err(|err| Error::Runtime(err.to_string()))
 }
 
 fn read_program(source: Option<&str>, file: Option<&PathBuf>) -> Result<String, Error> {
diff --git a/lib/remap-cli/src/lib.rs b/lib/remap-cli/src/lib.rs
index 5530856a83f81..1ad764a42af61 100644
--- a/lib/remap-cli/src/lib.rs
+++ b/lib/remap-cli/src/lib.rs
@@ -9,8 +9,11 @@ pub enum Error {
     #[error("io error")]
     Io(#[from] std::io::Error),
 
-    #[error("remap error: {0}")]
-    Remap(#[from] remap::RemapError),
+    #[error("parse error")]
+    Parse(String),
+
+    #[error("runtime error")]
+    Runtime(String),
 
     #[error("json error")]
     Json(#[from] serde_json::Error),
diff --git a/lib/remap-cli/src/repl.rs b/lib/remap-cli/src/repl.rs
index 2c571ec82bb7c..8a4a622db740d 100644
--- a/lib/remap-cli/src/repl.rs
+++ b/lib/remap-cli/src/repl.rs
@@ -1,7 +1,7 @@
 use crate::Error;
 use prettytable::{format, Cell, Row, Table};
 use regex::Regex;
-use remap::{state, Object, Program, Runtime, Value};
+use remap::{state, Formatter, Object, Program, Runtime, Value};
 use remap_functions::all as funcs;
 use rustyline::completion::Completer;
 use rustyline::error::ReadlineError;
@@ -27,6 +27,7 @@ pub(crate) fn run(mut objects: Vec<Value>) -> Result<(), Error> {
     let mut index = 0;
     let func_docs_regex = Regex::new(r"^help\sdocs\s(\w{1,})$").unwrap();
 
+    let mut compiler_state = state::Compiler::default();
     let mut rt = Runtime::new(state::Program::default());
     let mut rl = Editor::<Repl>::new();
     rl.set_helper(Some(Repl::new()));
@@ -113,7 +114,12 @@ pub(crate) fn run(mut objects: Vec<Value>) -> Result<(), Error> {
                     _ => line,
                 };
 
-                let value = resolve(objects.get_mut(index), &mut rt, command);
+                let value = resolve(
+                    objects.get_mut(index),
+                    &mut rt,
+                    command,
+                    &mut compiler_state,
+                );
                 println!("{}\n", value);
             }
             Err(ReadlineError::Interrupted) => break,
@@ -128,18 +134,29 @@ pub(crate) fn run(mut objects: Vec<Value>) -> Result<(), Error> {
     Ok(())
 }
 
-fn resolve(object: Option<&mut impl Object>, runtime: &mut Runtime, program: &str) -> String {
+fn resolve(
+    object: Option<&mut impl Object>,
+    runtime: &mut Runtime,
+    program: &str,
+    state: &mut state::Compiler,
+) -> String {
     let object = match object {
         None => return Value::Null.to_string(),
         Some(object) => object,
     };
 
-    let program = match Program::new(program, &remap_functions::all(), None, true) {
-        Ok(program) => program,
-        Err(err) => return err.to_string(),
+    let program = match Program::new_with_state(
+        program.to_owned(),
+        &remap_functions::all(),
+        None,
+        true,
+        state,
+    ) {
+        Ok((program, _)) => program,
+        Err(diagnostics) => return Formatter::new(program, diagnostics).colored().to_string(),
     };
 
-    match runtime.execute(object, &program) {
+    match runtime.run(object, &program) {
         Ok(value) => value.to_string(),
         Err(err) => err.to_string(),
     }
diff --git a/lib/remap-lang/Cargo.toml b/lib/remap-lang/Cargo.toml
index 296fa5200a057..b77db4bb5c6cb 100644
--- a/lib/remap-lang/Cargo.toml
+++ b/lib/remap-lang/Cargo.toml
@@ -10,6 +10,7 @@ license = "MPL-2.0"
 bitflags = "1"
 bytes = "0.5.6"
 chrono = "0.4"
+codespan-reporting = "0.11"
 dyn-clone = "1"
 paste = "1"
 pest = "2"
@@ -17,6 +18,7 @@ pest_derive = "2"
 regex = "1"
 serde = "1"
 thiserror = "1"
+termcolor = "1"
 
 [dev-dependencies]
 criterion = "0.3"
diff --git a/lib/remap-lang/src/diagnostic.rs b/lib/remap-lang/src/diagnostic.rs
new file mode 100644
index 0000000000000..24cb27536f7a2
--- /dev/null
+++ b/lib/remap-lang/src/diagnostic.rs
@@ -0,0 +1,488 @@
+use crate::value::Kind;
+use codespan_reporting::diagnostic;
+use std::fmt;
+use std::ops::{Deref, DerefMut, Range, RangeInclusive};
+
+/// A result type in which the `Ok` variant contains `T` and a list of zero or
+/// more non-error diagnostics. The `Err` variant contains a list of one or more
+/// diagnostics (errors and warnings).
+pub type Result<T> = std::result::Result<(T, DiagnosticList), DiagnosticList>;
+
+/// A formatter to display diagnostics tied to a given source.
+pub struct Formatter<'a> {
+    source: &'a str,
+    diagnostics: DiagnosticList,
+    color: bool,
+}
+
+impl<'a> Formatter<'a> {
+    pub fn new(source: &'a str, diagnostics: impl Into<DiagnosticList>) -> Self {
+        Self {
+            source,
+            diagnostics: diagnostics.into(),
+            color: false,
+        }
+    }
+
+    pub fn colored(mut self) -> Self {
+        self.color = true;
+        self
+    }
+
+    pub fn enable_colors(&mut self, color: bool) {
+        self.color = color
+    }
+}
+
+impl<'a> fmt::Display for Formatter<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use codespan_reporting::files::SimpleFile;
+        use codespan_reporting::term;
+        use std::str::from_utf8;
+        use termcolor::Buffer;
+
+        let file = SimpleFile::new("", self.source);
+        let config = term::Config::default();
+        let mut buffer = if self.color {
+            Buffer::ansi()
+        } else {
+            Buffer::no_color()
+        };
+
+        f.write_str("\n")?;
+
+        for diagnostic in self.diagnostics.iter() {
+            term::emit(&mut buffer, &config, &file, &diagnostic.to_owned().into())
+                .map_err(|_| fmt::Error)?;
+        }
+
+        f.write_str(from_utf8(buffer.as_slice()).map_err(|_| fmt::Error)?)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct Diagnostic {
+    severity: Severity,
+    message: String,
+    labels: Vec<Label>,
+    notes: Vec<Note>,
+}
+
+impl Diagnostic {
+    pub fn error(message: impl ToString) -> Self {
+        Self::new(Severity::Error, message, vec![], vec![])
+    }
+
+    pub fn bug(message: impl ToString) -> Self {
+        Self::new(Severity::Bug, message, vec![], vec![])
+    }
+
+    pub fn new(
+        severity: Severity,
+        message: impl ToString,
+        labels: Vec<Label>,
+        notes: Vec<Note>,
+    ) -> Self {
+        Self {
+            severity,
+            message: message.to_string(),
+            labels,
+            notes,
+        }
+    }
+
+    pub fn with_primary(self, message: impl ToString, span: impl Into<Span>) -> Self {
+        self.with_label(Label::primary(message, span.into()))
+    }
+
+    pub fn with_context(self, message: impl ToString, span: impl Into<Span>) -> Self {
+        self.with_label(Label::context(message, span.into()))
+    }
+
+    pub fn with_label(mut self, label: Label) -> Self {
+        self.labels.push(label);
+        self
+    }
+
+    pub fn with_note(mut self, note: Note) -> Self {
+        self.notes.push(note);
+        self
+    }
+
+    pub fn severity(&self) -> Severity {
+        self.severity
+    }
+
+    pub fn message(&self) -> &str {
+        &self.message
+    }
+
+    pub fn notes(&self) -> &[Note] {
+        &self.notes
+    }
+
+    pub fn labels(&self) -> &[Label] {
+        &self.labels
+    }
+
+    /// Returns `true` if the diagnostic represents either an
+    /// [error](Variant::Error) or [bug](Variant::Bug).
+    #[inline]
+    pub fn is_problem(&self) -> bool {
+        self.severity.is_error() || self.severity.is_bug()
+    }
+
+    /// Returns `true` if the diagnostic represents a [bug](Variant::Bug).
+    #[inline]
+    pub fn is_bug(&self) -> bool {
+        self.severity.is_bug()
+    }
+
+    /// Returns `true` if the diagnostic represents an [error](Variant::Error).
+    #[inline]
+    pub fn is_error(&self) -> bool {
+        self.severity.is_error()
+    }
+
+    /// Returns `true` if the diagnostic represents a
+    /// [warning](Variant::Warning).
+    #[inline]
+    pub fn is_warning(&self) -> bool {
+        self.severity.is_warning()
+    }
+
+    /// Returns `true` if the diagnostic represents a [note](Variant::Note).
+    #[inline]
+    pub fn is_note(&self) -> bool {
+        self.severity.is_note()
+    }
+}
+
+impl Into<diagnostic::Diagnostic<()>> for Diagnostic {
+    fn into(self) -> diagnostic::Diagnostic<()> {
+        let mut notes = self.notes.to_vec();
+        notes.push(Note::SeeLangDocs);
+
+        diagnostic::Diagnostic {
+            severity: self.severity.into(),
+            code: None,
+            message: self.message.to_string(),
+            labels: self.labels.to_vec().into_iter().map(Into::into).collect(),
+            notes: notes.iter().map(ToString::to_string).collect(),
+        }
+    }
+}
+
+// -----------------------------------------------------------------------------
+
+#[derive(Debug, Clone, Default, PartialEq)]
+pub struct DiagnosticList(Vec<Diagnostic>);
+
+impl DiagnosticList {
+    /// Turns the diagnostic list into a result type, the `Ok` variant is
+    /// returned if none of the diagnostics are errors or bugs. Otherwise the
+    /// `Err` variant is returned.
+    pub fn into_result(self) -> std::result::Result<DiagnosticList, DiagnosticList> {
+        if self.is_err() {
+            return Err(self);
+        }
+
+        Ok(self)
+    }
+
+    /// Returns `true` if there are any errors or bugs in the parsed source.
+    pub fn is_err(&self) -> bool {
+        self.0.iter().any(|d| d.is_problem())
+    }
+
+    /// Returns the list of bug-level diagnostics.
+    pub fn bugs(&self) -> Vec<&Diagnostic> {
+        self.0.iter().filter(|d| d.is_bug()).collect()
+    }
+
+    /// Returns the list of error-level diagnostics.
+    pub fn errors(&self) -> Vec<&Diagnostic> {
+        self.0.iter().filter(|d| d.is_error()).collect()
+    }
+
+    /// Returns the list of warning-level diagnostics.
+    pub fn warnings(&self) -> Vec<&Diagnostic> {
+        self.0.iter().filter(|d| d.is_warning()).collect()
+    }
+
+    /// Returns the list of note-level diagnostics.
+    pub fn notes(&self) -> Vec<&Diagnostic> {
+        self.0.iter().filter(|d| d.is_note()).collect()
+    }
+
+    /// Returns `true` if there are any bug diagnostics.
+    pub fn has_bugs(&self) -> bool {
+        self.0.iter().any(|d| d.is_bug())
+    }
+
+    /// Returns `true` if there are any error diagnostics.
+    pub fn has_errors(&self) -> bool {
+        self.0.iter().any(|d| d.is_error())
+    }
+
+    /// Returns `true` if there are any warning diagnostics.
+    pub fn has_warnings(&self) -> bool {
+        self.0.iter().any(|d| d.is_warning())
+    }
+
+    /// Returns `true` if there are any note diagnostics.
+    pub fn has_notes(&self) -> bool {
+        self.0.iter().any(|d| d.is_note())
+    }
+}
+
+impl Deref for DiagnosticList {
+    type Target = Vec<Diagnostic>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for DiagnosticList {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl IntoIterator for DiagnosticList {
+    type Item = Diagnostic;
+    type IntoIter = std::vec::IntoIter<Diagnostic>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter()
+    }
+}
+
+impl From<Vec<Diagnostic>> for DiagnosticList {
+    fn from(diagnostics: Vec<Diagnostic>) -> Self {
+        Self(diagnostics)
+    }
+}
+
+impl From<Diagnostic> for DiagnosticList {
+    fn from(diagnostic: Diagnostic) -> Self {
+        Self(vec![diagnostic])
+    }
+}
+
+// -----------------------------------------------------------------------------
+
+/// A span pointing into the program source.
+///
+/// This exists because `Range` doesn't implement `Copy` and to make it easy to
+/// convert other types into spans.
+///
+/// Similar to `Range`, the range is half-open, meaning `end` is exclusive.
+#[derive(Clone, Copy, Debug, PartialEq, Default)]
+pub struct Span {
+    pub start: usize,
+    pub end: usize,
+}
+
+impl Span {
+    pub fn new(start: usize, end: usize) -> Self {
+        Span { start, end }
+    }
+}
+
+impl From<Span> for Range<usize> {
+    fn from(span: Span) -> Self {
+        span.start..span.end
+    }
+}
+
+impl From<Range<usize>> for Span {
+    fn from(range: Range<usize>) -> Self {
+        Span {
+            start: range.start,
+            end: range.end,
+        }
+    }
+}
+
+impl From<RangeInclusive<usize>> for Span {
+    fn from(range: RangeInclusive<usize>) -> Self {
+        let (start, end) = range.into_inner();
+
+        Span {
+            start,
+            end: end + 1,
+        }
+    }
+}
+
+impl From<&str> for Span {
+    fn from(source: &str) -> Self {
+        (0..source.bytes().len().saturating_sub(1)).into()
+    }
+}
+
+// -----------------------------------------------------------------------------
+
+#[derive(Debug, PartialEq, Clone, Copy)]
+pub enum Severity {
+    Bug,
+    Error,
+    Warning,
+    Note,
+}
+
+impl Severity {
+    /// Returns `true` if the severity is a [bug](Variant::Bug).
+    #[inline]
+    pub fn is_bug(self) -> bool {
+        matches!(self, Severity::Bug)
+    }
+
+    /// Returns `true` if the severity is an [error](Variant::Error).
+    #[inline]
+    pub fn is_error(self) -> bool {
+        matches!(self, Severity::Error)
+    }
+
+    /// Returns `true` if the severity is a [warning](Variant::Warning).
+    #[inline]
+    pub fn is_warning(self) -> bool {
+        matches!(self, Severity::Warning)
+    }
+
+    /// Returns `true` if the severity is a [note](Variant::Note).
+    #[inline]
+    pub fn is_note(self) -> bool {
+        matches!(self, Severity::Note)
+    }
+}
+
+impl Into<diagnostic::Severity> for Severity {
+    fn into(self) -> diagnostic::Severity {
+        use Severity::*;
+
+        match self {
+            Bug => diagnostic::Severity::Bug,
+            Error => diagnostic::Severity::Error,
+            Warning => diagnostic::Severity::Warning,
+            Note => diagnostic::Severity::Note,
+        }
+    }
+}
+
+// -----------------------------------------------------------------------------
+
+#[derive(Debug, PartialEq, Clone)]
+pub enum Note {
+    ExpectedKind(Kind),
+    CoerceValue,
+    InfallibleAssignment {
+        ok: String,
+        err: String,
+    },
+    SeeFuncDocs(&'static str),
+    SeeErrDocs,
+
+    #[doc(hidden)]
+    SeeLangDocs,
+}
+
+impl fmt::Display for Note {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use Note::*;
+
+        match self {
+            ExpectedKind(kind) => write!(f, "expected: {}", kind),
+            CoerceValue => {
+                f.write_str("hint: coerce the value using one of the coercion functions")
+            }
+            InfallibleAssignment { ok, err } => {
+                write!(
+                    f,
+                    r#"hint: assign to "{}", without assigning to "{}""#,
+                    ok, err
+                )
+            }
+            SeeFuncDocs(func) => {
+                write!(f,
+                "see function documentation at: https://master.vector.dev/docs/reference/remap/#{}",
+                func
+            )
+            }
+            SeeErrDocs => f.write_str(
+                "see error handling documentation at: https://vector.dev/docs/reference/vrl/",
+            ),
+            SeeLangDocs => {
+                f.write_str("see language documentation at: https://vector.dev/docs/reference/vrl/")
+            }
+        }
+    }
+}
+
+// -----------------------------------------------------------------------------
+
+#[derive(Debug, PartialEq, Clone)]
+pub struct Label {
+    pub message: String,
+    pub primary: bool,
+    pub span: Span,
+}
+
+impl Label {
+    pub fn primary(message: impl ToString, span: impl Into<Span>) -> Self {
+        Self {
+            message: message.to_string(),
+            primary: true,
+            span: span.into(),
+        }
+    }
+
+    pub fn context(message: impl ToString, span: impl Into<Span>) -> Self {
+        Self {
+            message: message.to_string(),
+            primary: false,
+            span: span.into(),
+        }
+    }
+}
+
+impl Into<diagnostic::Label<()>> for Label {
+    fn into(self) -> diagnostic::Label<()> {
+        let style = match self.primary {
+            true => diagnostic::LabelStyle::Primary,
+            false => diagnostic::LabelStyle::Secondary,
+        };
+
+        diagnostic::Label {
+            style,
+            file_id: (),
+            range: self.span.into(),
+            message: self.message,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_span_from_range() {
+        let range = 10..20;
+        let span = Span::from(range);
+
+        assert_eq!(span.start, 10);
+        assert_eq!(span.end, 20);
+    }
+
+    #[test]
+    fn test_span_from_range_inclusive() {
+        let range = 10..=20;
+        let span = Span::from(range);
+
+        assert_eq!(span.start, 10);
+        assert_eq!(span.end, 21);
+    }
+}
diff --git a/lib/remap-lang/src/error.rs b/lib/remap-lang/src/error.rs
index afcc68523e451..c0ca09dc0701a 100644
--- a/lib/remap-lang/src/error.rs
+++ b/lib/remap-lang/src/error.rs
@@ -1,22 +1,9 @@
-use crate::{
-    expression, function,
-    parser::{self, Rule},
-    path, program, value,
-};
+use crate::{expression, function, parser::Rule, value};
 use std::error::Error as StdError;
 use std::fmt;
 
 #[derive(thiserror::Error, Clone, Debug, PartialEq)]
 pub enum Error {
-    #[error("parser error")]
-    Parser(#[from] parser::Error),
-
-    #[error("program error")]
-    Program(#[from] program::Error),
-
-    #[error("unexpected token sequence")]
-    Rule(#[from] Rule),
-
     #[error(transparent)]
     Expression(#[from] expression::Error),
 
@@ -31,12 +18,6 @@ pub enum Error {
 
     #[error("assertion failed: {0}")]
     Assert(String),
-
-    #[error("path error")]
-    Path(#[from] path::Error),
-
-    #[error("unknown error")]
-    Unknown,
 }
 
 impl From<String> for Error {
@@ -143,50 +124,3 @@ impl fmt::Display for Rule {
         ]
     }
 }
-
-#[derive(Debug, PartialEq)]
-pub struct RemapError(Error);
-
-impl StdError for RemapError {
-    fn source(&self) -> Option<&(dyn StdError + 'static)> {
-        Some(&self.0)
-    }
-}
-
-impl fmt::Display for RemapError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("remap error")?;
-
-        let mut error: &(dyn StdError + 'static) = self;
-        while let Some(current) = error.source() {
-            error = current;
-            write!(f, ": {}", error)?;
-        }
-
-        Ok(())
-    }
-}
-
-impl From<Error> for RemapError {
-    fn from(error: Error) -> Self {
-        RemapError(error)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn display_error() {
-        let error1 = expression::function::Error::Required("arg1".to_owned(), 0);
-        let error2 = expression::Error::Function("foo_func".to_owned(), error1);
-        let error3 = Error::Expression(error2);
-        let error = RemapError(error3);
-
-        assert_eq!(
-            r#"remap error: error for function "foo_func": missing required argument "arg1" (position 0)"#.to_owned(),
-            error.to_string(),
-        );
-    }
-}
diff --git a/lib/remap-lang/src/expression.rs b/lib/remap-lang/src/expression.rs
index 26628ec804192..de085d4fdb7f1 100644
--- a/lib/remap-lang/src/expression.rs
+++ b/lib/remap-lang/src/expression.rs
@@ -5,10 +5,10 @@ use std::fmt;
 mod argument;
 mod arithmetic;
 mod array;
-mod assignment;
+pub(crate) mod assignment;
 mod block;
 pub(crate) mod function;
-mod if_statement;
+pub(crate) mod if_statement;
 mod literal;
 mod map;
 mod noop;
@@ -41,15 +41,6 @@ pub enum Error {
     #[error("assignment error")]
     Assignment(#[from] assignment::Error),
 
-    #[error(r#"error for variable "{0}""#)]
-    Variable(String, #[source] variable::Error),
-
-    #[error("path error")]
-    Path(#[from] path::Error),
-
-    #[error("not operation error")]
-    Not(#[from] not::Error),
-
     #[error("if-statement error")]
     IfStatement(#[from] if_statement::Error),
 }
@@ -83,6 +74,7 @@ macro_rules! expression_dispatch {
         /// Any expression that stores other expressions internally will still
         /// have to box this enum, to avoid infinite recursion.
         #[derive(Clone, PartialEq)]
+        #[allow(clippy::large_enum_variant)] // TODO: investigate
         pub enum Expr {
             $($expr($expr)),+
         }
diff --git a/lib/remap-lang/src/expression/array.rs b/lib/remap-lang/src/expression/array.rs
index 6e5e3b6ce6445..61faf4738fd41 100644
--- a/lib/remap-lang/src/expression/array.rs
+++ b/lib/remap-lang/src/expression/array.rs
@@ -15,10 +15,6 @@ impl Array {
         Self { expressions }
     }
 
-    pub(crate) fn expressions(&self) -> &[Expr] {
-        &self.expressions
-    }
-
     pub fn boxed(self) -> Box<dyn Expression> {
         Box::new(self)
     }
diff --git a/lib/remap-lang/src/expression/assignment.rs b/lib/remap-lang/src/expression/assignment.rs
index f0bbc7257ad5b..b9f6197317470 100644
--- a/lib/remap-lang/src/expression/assignment.rs
+++ b/lib/remap-lang/src/expression/assignment.rs
@@ -5,16 +5,12 @@ use crate::{
     value::Kind,
     Expr, Expression, Object, Result, TypeDef, Value,
 };
+use std::fmt;
 
 #[derive(thiserror::Error, Clone, Debug, PartialEq)]
 pub enum Error {
     #[error("unable to insert value in path: {0}")]
     PathInsertion(String),
-
-    #[error(
-        r#"the {0} "{1}" does not need to handle the error-case, because its result is infallible"#
-    )]
-    UneededInfallibleAssignment(&'static str, String),
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -24,16 +20,16 @@ pub enum Target {
     Infallible { ok: Box<Target>, err: Box<Target> },
 }
 
-impl Target {
-    fn as_str(&self) -> &'static str {
+impl fmt::Display for Target {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Target::Path(_) => "path",
-            Target::Variable(_) => "variable",
-            Target::Infallible { ok, .. } => match ok.as_ref() {
-                Target::Path(_) => "infallible path",
-                Target::Variable(_) => "infallible variable",
-                Target::Infallible { .. } => unimplemented!("nested infallible target"),
-            },
+            Target::Path(path) => path.fmt(f),
+            Target::Variable(var) => var.fmt(f),
+            Target::Infallible { ok, err } => {
+                ok.as_ref().fmt(f)?;
+                f.write_str(", ")?;
+                err.as_ref().fmt(f)
+            }
         }
     }
 }
@@ -45,7 +41,7 @@ pub struct Assignment {
 }
 
 impl Assignment {
-    pub fn new(target: Target, value: Box<Expr>, state: &mut state::Compiler) -> Result<Self> {
+    pub fn new(target: Target, value: Box<Expr>, state: &mut state::Compiler) -> Self {
         let type_def = value.type_def(state);
 
         let var_type_def = |state: &mut state::Compiler, var: &Variable, type_def| {
@@ -64,20 +60,11 @@ impl Assignment {
             Target::Variable(var) => var_type_def(state, var, type_def),
             Target::Path(path) => path_type_def(state, path, type_def),
             Target::Infallible { ok, err } => {
-                // if the type definition of the rhs expression is infallible,
-                // then an infallible assignment is redundant, and we provide a
-                // compile-time error.
-                if !type_def.is_fallible() {
-                    return Err(E::from(Error::UneededInfallibleAssignment(
-                        ok.as_str(),
-                        match ok.as_ref() {
-                            Target::Variable(v) => v.ident().to_owned(),
-                            Target::Path(v) => v.to_string(),
-                            Target::Infallible { .. } => unimplemented!("nested infallible target"),
-                        },
-                    ))
-                    .into());
-                }
+                // If the type definition of the rhs expression is infallible,
+                // then an infallible assignment is redundant.
+                //
+                // This invariant is upheld (for now) by the parser.
+                assert!(type_def.is_fallible());
 
                 // "ok" target takes on the type definition of the value, but is
                 // set to being infallible, as the error will be captured by the
@@ -105,7 +92,7 @@ impl Assignment {
             }
         }
 
-        Ok(Self { target, value })
+        Self { target, value }
     }
 }
 
@@ -226,7 +213,7 @@ mod tests {
                 let target = Target::Variable(Variable::new("foo".to_owned(), None));
                 let value = Box::new(Literal::from(true).into());
 
-                Assignment::new(target, value, state).unwrap()
+                Assignment::new(target, value, state)
             },
             def: TypeDef {
                 kind: Kind::Boolean,
@@ -239,7 +226,7 @@ mod tests {
                 let target = Target::Path(Path::from("foo"));
                 let value = Box::new(Literal::from("foo").into());
 
-                Assignment::new(target, value, state).unwrap()
+                Assignment::new(target, value, state)
             },
             def: TypeDef {
                 kind: Kind::Bytes,
@@ -259,7 +246,7 @@ mod tests {
                     Operator::Multiply,
                 ).into());
 
-                Assignment::new(target, value, state).unwrap()
+                Assignment::new(target, value, state)
             },
             def: TypeDef {
                 fallible: false,
diff --git a/lib/remap-lang/src/expression/function.rs b/lib/remap-lang/src/expression/function.rs
index e4168ac80564b..bc5c1e5fe9b01 100644
--- a/lib/remap-lang/src/expression/function.rs
+++ b/lib/remap-lang/src/expression/function.rs
@@ -1,7 +1,6 @@
-use super::Error as E;
 use crate::{
-    expression, function::ArgumentList, state, Expr, Expression, Function as Fn, Object, Result,
-    TypeDef, Value,
+    expression, function::ArgumentList, state, Expr, Expression, Function as Fn, Object, TypeDef,
+    Value,
 };
 
 #[derive(thiserror::Error, Clone, Debug, PartialEq)]
@@ -9,17 +8,20 @@ pub enum Error {
     #[error("undefined")]
     Undefined,
 
-    #[error("invalid argument count (expected at most {0}, got {0})")]
-    Arity(usize, usize),
+    #[error("invalid argument count (expected at most {max}, got {got})")]
+    ArityMismatch { max: usize, got: usize },
 
     #[error(r#"unknown argument keyword "{0}""#)]
-    Keyword(String),
+    UnknownKeyword(String),
 
-    #[error(r#"missing required argument "{0}" (position {1})"#)]
-    Required(String, usize),
+    #[error(r#"missing required argument "{argument}" (position {position})"#)]
+    MissingArg {
+        argument: &'static str,
+        position: usize,
+    },
 
-    #[error(r#"unknown keyword "{0}""#)]
-    Unknown(&'static str),
+    #[error("compilation error: {0}")]
+    Compile(String),
 
     #[error(r#"error for argument "{0}""#)]
     Argument(String, #[source] expression::argument::Error),
@@ -47,27 +49,26 @@ impl PartialEq for Function {
 
 impl Function {
     pub fn new(
-        ident: String,
+        ident: &str,
         abort_on_error: bool,
         arguments: Vec<(Option<String>, Expr)>,
         definitions: &[Box<dyn Fn>],
         state: &state::Compiler,
-    ) -> Result<Self> {
+    ) -> Result<Self, Error> {
         let definition = definitions
             .iter()
             .find(|b| b.identifier() == ident)
-            .ok_or_else(|| E::Function(ident.clone(), Error::Undefined))?;
+            .ok_or(Error::Undefined)?;
 
         let ident = definition.identifier();
         let parameters = definition.parameters();
 
         // check function arity
         if arguments.len() > parameters.len() {
-            return Err(E::Function(
-                ident.to_owned(),
-                Error::Arity(parameters.len(), arguments.len()),
-            )
-            .into());
+            return Err(Error::ArityMismatch {
+                max: parameters.len(),
+                got: arguments.len(),
+            });
         }
 
         // Keeps track of positional argument indices.
@@ -99,12 +100,7 @@ impl Function {
                         param
                     }),
             }
-            .ok_or_else(|| {
-                E::Function(
-                    ident.to_owned(),
-                    Error::Keyword(keyword.expect("arity checked")),
-                )
-            })?;
+            .ok_or_else(|| Error::UnknownKeyword(keyword.expect("arity checked")))?;
 
             let argument =
                 expression::Argument::new(Box::new(argument), param.accepts, param.keyword, ident)
@@ -119,18 +115,23 @@ impl Function {
             .enumerate()
             .filter(|(_, p)| p.required)
             .filter(|(_, p)| !list.keywords().contains(&p.keyword))
-            .try_for_each(|(i, p)| -> Result<_> {
-                Err(E::Function(ident.to_owned(), Error::Required(p.keyword.to_owned(), i)).into())
+            .try_for_each(|(i, p)| -> Result<_, _> {
+                Err(Error::MissingArg {
+                    argument: p.keyword,
+                    position: i,
+                })
             })?;
 
-        let function = definition.compile(list)?;
+        let function = definition
+            .compile(list)
+            .map_err(|err| Error::Compile(err.to_string()))?;
 
         // Asking for an infallible function to abort on error makes no sense.
         // We consider this an error at compile-time, because it makes the
         // resulting program incorrectly convey this function call might fail.
         let type_def = function.type_def(state);
         if abort_on_error && !type_def.is_fallible() {
-            return Err(E::Function(ident.to_owned(), Error::AbortInfallible).into());
+            return Err(Error::AbortInfallible);
         }
 
         Ok(Self {
@@ -144,10 +145,14 @@ impl Function {
     pub fn abort_on_error(&self) -> bool {
         self.abort_on_error
     }
+
+    pub fn ident(&self) -> &'static str {
+        self.ident
+    }
 }
 
 impl Expression for Function {
-    fn execute(&self, state: &mut state::Program, object: &mut dyn Object) -> Result<Value> {
+    fn execute(&self, state: &mut state::Program, object: &mut dyn Object) -> crate::Result<Value> {
         self.function.execute(state, object)
     }
 
diff --git a/lib/remap-lang/src/expression/if_statement.rs b/lib/remap-lang/src/expression/if_statement.rs
index cd48cfbfe1ada..bf517b16b08be 100644
--- a/lib/remap-lang/src/expression/if_statement.rs
+++ b/lib/remap-lang/src/expression/if_statement.rs
@@ -1,12 +1,49 @@
-use super::Error as E;
-use crate::{state, value, Expr, Expression, Object, Result, TypeDef, Value};
+use crate::{state, value, Diagnostic, Expr, Expression, Object, Span, TypeDef, Value};
 
 #[derive(thiserror::Error, Clone, Debug, PartialEq)]
 pub enum Error {
-    #[error("conditional error")]
+    #[error("invalid if-condition type")]
     Conditional(#[from] value::Error),
 }
 
+impl From<(Span, Error)> for Diagnostic {
+    fn from((span, err): (Span, Error)) -> Self {
+        use crate::diagnostic::Note;
+
+        let message = err.to_string();
+
+        match err {
+            Error::Conditional(err) => match err {
+                value::Error::Expected(got, want) => Self::error(message)
+                    .with_primary(format!("got: {}", want), span)
+                    .with_context(format!("expected: {}", got), span)
+                    .with_note(Note::CoerceValue),
+                _ => Self::error(message).with_primary("unexpected value", span),
+            },
+        }
+    }
+}
+
+/// Wrapper type for an if condition.
+///
+/// The initializer of this type errors if the condition doesn't resolve to a
+/// boolean.
+pub struct IfCondition(Box<Expr>);
+
+impl IfCondition {
+    pub fn new(expression: Box<Expr>, state: &state::Compiler) -> Result<Self, Error> {
+        let kind = expression.type_def(state).kind;
+        if !kind.is_boolean() {
+            return Err(Error::Conditional(value::Error::Expected(
+                value::Kind::Boolean,
+                kind,
+            )));
+        }
+
+        Ok(Self(expression))
+    }
+}
+
 #[derive(Debug, Clone, PartialEq)]
 pub struct IfStatement {
     conditional: Box<Expr>,
@@ -16,30 +53,20 @@ pub struct IfStatement {
 
 impl IfStatement {
     pub fn new(
-        conditional: Box<Expr>,
+        conditional: IfCondition,
         true_expression: Box<Expr>,
         false_expression: Box<Expr>,
-        state: &state::Compiler,
-    ) -> Result<Self> {
-        let type_def = conditional.type_def(state);
-        if !type_def.kind.is_boolean() {
-            return Err(E::from(Error::Conditional(value::Error::Expected(
-                value::Kind::Boolean,
-                type_def.kind,
-            )))
-            .into());
-        }
-
-        Ok(Self {
-            conditional,
+    ) -> Self {
+        Self {
+            conditional: conditional.0,
             true_expression,
             false_expression,
-        })
+        }
     }
 }
 
 impl Expression for IfStatement {
-    fn execute(&self, state: &mut state::Program, object: &mut dyn Object) -> Result<Value> {
+    fn execute(&self, state: &mut state::Program, object: &mut dyn Object) -> crate::Result<Value> {
         let condition = self.conditional.execute(state, object)?.unwrap_boolean();
 
         match condition {
@@ -58,20 +85,16 @@ impl Expression for IfStatement {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{
-        expression::{Literal, Noop},
-        test_type_def,
-        value::Kind,
-    };
+    use crate::{expression::Noop, lit, test_type_def, value::Kind};
 
     test_type_def![
         concrete_type_def {
-            expr: |state: &mut state::Compiler| {
-                let conditional = Box::new(Literal::from(true).into());
-                let true_expression = Box::new(Literal::from(true).into());
-                let false_expression = Box::new(Literal::from(true).into());
+            expr: |_| {
+                let conditional = IfCondition(Box::new(lit!(true).into()));
+                let true_expression = Box::new(lit!(true).into());
+                let false_expression = Box::new(lit!(true).into());
 
-                IfStatement::new(conditional, true_expression, false_expression, &state).unwrap()
+                IfStatement::new(conditional, true_expression, false_expression)
             },
             def: TypeDef {
                 kind: Kind::Boolean,
@@ -80,12 +103,12 @@ mod tests {
         }
 
         optional_null {
-            expr: |state: &mut state::Compiler| {
-                let conditional = Box::new(Literal::from(true).into());
-                let true_expression = Box::new(Literal::from(true).into());
+            expr: |_| {
+                let conditional = IfCondition(Box::new(lit!(true).into()));
+                let true_expression = Box::new(lit!(true).into());
                 let false_expression = Box::new(Noop.into());
 
-                IfStatement::new(conditional, true_expression, false_expression, &state).unwrap()
+                IfStatement::new(conditional, true_expression, false_expression)
             },
             def: TypeDef {
                 kind: Kind::Boolean | Kind::Null,
diff --git a/lib/remap-lang/src/expression/not.rs b/lib/remap-lang/src/expression/not.rs
index 42e5090d63c14..2a8a0470cc372 100644
--- a/lib/remap-lang/src/expression/not.rs
+++ b/lib/remap-lang/src/expression/not.rs
@@ -1,11 +1,5 @@
 use crate::{state, value, Expr, Expression, Object, Result, TypeDef, Value};
 
-#[derive(thiserror::Error, Clone, Debug, PartialEq)]
-pub enum Error {
-    #[error("invalid value kind")]
-    Value(#[from] value::Error),
-}
-
 #[derive(Debug, Clone, PartialEq)]
 pub struct Not {
     expression: Box<Expr>,
diff --git a/lib/remap-lang/src/expression/path.rs b/lib/remap-lang/src/expression/path.rs
index d4461f6917706..42ea5c02e2c0d 100644
--- a/lib/remap-lang/src/expression/path.rs
+++ b/lib/remap-lang/src/expression/path.rs
@@ -1,16 +1,6 @@
-use super::Error as E;
 use crate::{path, state, Expression, Object, Result, TypeDef, Value};
 use std::fmt;
 
-#[derive(thiserror::Error, Clone, Debug, PartialEq)]
-pub enum Error {
-    #[error("missing path: {0}")]
-    Missing(String),
-
-    #[error("unable to resolve path: {0}")]
-    Resolve(String),
-}
-
 #[derive(Debug, Clone, PartialEq)]
 pub struct Path {
     path: path::Path,
@@ -62,10 +52,7 @@ impl Path {
 
 impl Expression for Path {
     fn execute(&self, _: &mut state::Program, object: &mut dyn Object) -> Result<Value> {
-        let value = object
-            .get(&self.path)
-            .map_err(|e| E::from(Error::Resolve(e)))?
-            .unwrap_or(Value::Null);
+        let value = object.get(&self.path).ok().flatten().unwrap_or(Value::Null);
 
         Ok(value)
     }
@@ -74,10 +61,11 @@ impl Expression for Path {
     /// specific values to paths during its execution, which increases our exact
     /// understanding of the value kind the path contains.
     fn type_def(&self, state: &state::Compiler) -> TypeDef {
-        state.path_query_type(self).cloned().unwrap_or(TypeDef {
-            fallible: true,
-            ..Default::default()
-        })
+        state
+            .path_query_type(self)
+            .cloned()
+            .unwrap_or_default()
+            .into_fallible(false)
     }
 }
 
@@ -98,7 +86,6 @@ mod tests {
         exact_match {
             expr: |state: &mut state::Compiler| {
                 state.path_query_types_mut().insert(Path::from("foo").into(), TypeDef {
-                    fallible: true,
                     kind: Kind::Bytes,
                     ..Default::default()
                 });
@@ -106,7 +93,6 @@ mod tests {
                 Path::from("foo")
             },
             def: TypeDef {
-                fallible: true,
                 kind: Kind::Bytes,
                 ..Default::default()
             },
@@ -114,25 +100,16 @@ mod tests {
 
         ident_mismatch {
             expr: |state: &mut state::Compiler| {
-                state.path_query_types_mut().insert(Path::from("foo").into(), TypeDef {
-                    fallible: true,
-                    ..Default::default()
-                });
+                state.path_query_types_mut().insert(Path::from("foo").into(), TypeDef::default());
 
                 Path::from("bar")
             },
-            def: TypeDef {
-                fallible: true,
-                ..Default::default()
-            },
+            def: TypeDef::default(),
         }
 
         empty_state {
             expr: |_| Path::from("foo"),
-            def: TypeDef {
-                fallible: true,
-                ..Default::default()
-            },
+            def: TypeDef::default(),
         }
     ];
 }
diff --git a/lib/remap-lang/src/expression/variable.rs b/lib/remap-lang/src/expression/variable.rs
index aae29831a1ba6..40bf0cdd1e85b 100644
--- a/lib/remap-lang/src/expression/variable.rs
+++ b/lib/remap-lang/src/expression/variable.rs
@@ -1,16 +1,5 @@
-use crate::{
-    expression::{path, Error as ExprErr, Path},
-    state, Error as E, Expression, Object, Result, TypeDef, Value,
-};
-
-#[derive(thiserror::Error, Clone, Debug, PartialEq)]
-pub enum Error {
-    #[error(transparent)]
-    Query(#[from] path::Error),
-
-    #[error("unknown error: {0}")]
-    Unknown(String),
-}
+use crate::{expression::Path, state, value::Kind, Expression, Object, Result, TypeDef, Value};
+use std::fmt;
 
 #[derive(Debug, Clone, PartialEq)]
 pub struct Variable {
@@ -18,6 +7,18 @@ pub struct Variable {
     path: Option<Path>,
 }
 
+impl fmt::Display for Variable {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(&self.ident)?;
+
+        if let Some(path) = &self.path {
+            path.fmt(f)?;
+        }
+
+        Ok(())
+    }
+}
+
 impl Variable {
     pub fn new(ident: String, path: Option<Path>) -> Self {
         Self { ident, path }
@@ -41,14 +42,7 @@ impl Expression for Variable {
         let mut value = state.variable(&self.ident).cloned().unwrap_or(Value::Null);
 
         if let Some(path) = &self.path {
-            return path.execute(state, &mut value).map_err(|err| {
-                let err = match err {
-                    E::Expression(ExprErr::Path(err)) => Error::Query(err),
-                    _ => Error::Unknown(err.to_string()),
-                };
-
-                ExprErr::Variable(self.ident.clone(), err).into()
-            });
+            return path.execute(state, &mut value);
         }
 
         Ok(value)
@@ -61,7 +55,7 @@ impl Expression for Variable {
             // TODO: we can make it so this can never happen, by making it a
             // compile-time error to reference a variable before it is assigned.
             .unwrap_or(TypeDef {
-                fallible: true,
+                kind: Kind::Null,
                 ..Default::default()
             })
     }
@@ -70,7 +64,7 @@ impl Expression for Variable {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{test_type_def, value::Kind};
+    use crate::test_type_def;
 
     test_type_def![
         ident_match {
@@ -108,7 +102,7 @@ mod tests {
                 Variable::new("bar".to_owned(), None)
             },
             def: TypeDef {
-                fallible: true,
+                kind: Kind::Null,
                 ..Default::default()
             },
         }
@@ -116,7 +110,7 @@ mod tests {
         empty_state {
             expr: |_| Variable::new("foo".to_owned(), None),
             def: TypeDef {
-                fallible: true,
+                kind: Kind::Null,
                 ..Default::default()
             },
         }
diff --git a/lib/remap-lang/src/lib.rs b/lib/remap-lang/src/lib.rs
index b559a2983be34..40da1a980a22a 100644
--- a/lib/remap-lang/src/lib.rs
+++ b/lib/remap-lang/src/lib.rs
@@ -7,6 +7,7 @@ mod runtime;
 mod test_util;
 mod type_def;
 
+pub mod diagnostic;
 pub mod expression;
 pub mod function;
 pub mod object;
@@ -14,14 +15,15 @@ pub mod prelude;
 pub mod state;
 pub mod value;
 
-pub use error::{Error, RemapError};
+pub use diagnostic::{Diagnostic, DiagnosticList, Formatter, Span};
+pub use error::Error;
 pub use expression::{Expr, Expression};
 pub use function::{Function, Parameter};
 pub use object::Object;
 pub use operator::Operator;
 pub use path::{Field, Path, Segment};
 pub use program::{Program, TypeConstraint};
-pub use runtime::Runtime;
+pub use runtime::{Runtime, RuntimeResult};
 pub use type_def::TypeDef;
 pub use value::Value;
 
@@ -42,11 +44,6 @@ mod tests {
             (r#".foo = null || "bar""#, Ok(()), Ok("bar".into())),
             (r#"foo = null || "bar""#, Ok(()), Ok("bar".into())),
             (r#".qux == .quux"#, Ok(()), Ok(true.into())),
-            (
-                r#"if "foo" { "bar" }"#,
-                Err(r#"remap error: if-statement error: conditional error: expected "boolean", got "string""#),
-                Ok(().into()),
-            ),
             (r#".foo = (null || "bar")"#, Ok(()), Ok("bar".into())),
             (r#"!false"#, Ok(()), Ok(true.into())),
             (r#"!!false"#, Ok(()), Ok(false.into())),
@@ -131,11 +128,12 @@ mod tests {
                 Ok(()),
                 Ok("valid: bar".into()),
             ),
-            (
-                r#"enum_validator("baz")"#,
-                Err("remap error: function error: unknown enum variant: baz, must be one of: foo, bar"),
-                Ok(().into()),
-            ),
+            // TODO: move to `remap-tests`
+            // (
+            //     r#"enum_validator("baz")"#,
+            //     Err("remap error: function error: unknown enum variant: baz, must be one of: foo, bar"),
+            //     Ok(().into()),
+            // ),
             (r#"false || true"#, Ok(()), Ok(true.into())),
             (r#"false || false"#, Ok(()), Ok(false.into())),
             (r#"true || false"#, Ok(()), Ok(true.into())),
@@ -177,11 +175,12 @@ mod tests {
             ("foo = .foo\nfoo.bar", Ok(()), Ok("baz".into())),
             ("foo = .foo.qux\nfoo[1]", Ok(()), Ok(2.into())),
             ("foo = .foo.qux\nfoo[2].quux", Ok(()), Ok(true.into())),
-            (
-                "foo[0] = true",
-                Err(r#"remap error: parser error: path in variable assignment unsupported, use "foo" without ".[0]""#),
-                Ok(().into()),
-            ),
+            // TODO: move to `remap-tests`
+            // (
+            //     "foo[0] = true",
+            //     Err(r#"remap error: parser error: path in variable assignment unsupported, use "foo" without ".[0]""#),
+            //     Ok(().into()),
+            // ),
             (r#"["foo", "bar", "baz"]"#, Ok(()), Ok(value!(["foo", "bar", "baz"]))),
             (
                 r#"
@@ -208,14 +207,15 @@ mod tests {
                     r#"{"1": Integer(1), "true": Boolean(true)}"#,
                 ])),
             ),
-            (
-                r#"
-                    .foo = ["foo", "bar"]
-                    array_printer(.foo)
-                "#,
-                Err("remap error: unexpected expression: expected Array, got Path"),
-                Ok(().into()),
-            ),
+            // TODO: move to `remap-tests`
+            // (
+            //     r#"
+            //         .foo = ["foo", "bar"]
+            //         array_printer(.foo)
+            //     "#,
+            //     Err("remap error: unexpected expression: expected Array, got Path"),
+            //     Ok(().into()),
+            // ),
             (
                 r#"enum_list_validator(["foo"])"#,
                 Ok(()),
@@ -226,16 +226,17 @@ mod tests {
                 Ok(()),
                 Ok(r#"valid: ["bar", "foo"]"#.into()),
             ),
-            (
-                r#"enum_list_validator(["qux"])"#,
-                Err("remap error: function error: unknown enum variant: qux, must be one of: foo, bar, baz"),
-                Ok(().into()),
-            ),
-            (
-                r#"enum_list_validator("qux")"#,
-                Err("remap error: unexpected expression: expected Array, got Literal"),
-                Ok(().into()),
-            ),
+            // TODO: move to `remap-tests`
+            // (
+            //     r#"enum_list_validator(["qux"])"#,
+            //     Err("remap error: function error: unknown enum variant: qux, must be one of: foo, bar, baz"),
+            //     Ok(().into()),
+            // ),
+            // (
+            //     r#"enum_list_validator("qux")"#,
+            //     Err("remap error: unexpected expression: expected Array, got Literal"),
+            //     Ok(().into()),
+            // ),
             (
                 r#"
                     .foo        \
@@ -285,31 +286,34 @@ mod tests {
             ("5 * 5 ?? true * 5", Ok(()), Ok(value!(25))),
             ("false * 5 ?? true * 5 ?? 5 * 5", Ok(()), Ok(value!(25))),
             ("false * 5 ?? 5 * 5 ?? true * 5", Ok(()), Ok(value!(25))),
-            ("false * 5 ?? true * 5", Ok(()), Err("remap error: value error: unable to multiply value type boolean by integer")),
+            // TODO: move to `remap-tests`
+            // ("false * 5 ?? true * 5", Ok(()), Err("remap error: value error: unable to multiply value type boolean by integer")),
             ("5 + (true * 5 ?? 0)", Ok(()), Ok(value!(5))),
-            ("fallible_func!()", Ok(()), Err("remap error: function call error: failed!")),
-            ("fallible_func()", Ok(()), Err("remap error: function call error: failed!")),
-            (
-                "map_printer!({})",
-                Err(r#"remap error: error for function "map_printer": cannot mark infallible function as "abort on error", remove the "!" signature"#),
-                Ok(().into()),
-            ),
-            (
-                "foo, err = fallible_func!()",
-                Err(r#"remap error: assignment error: the variable "foo" does not need to handle the error-case, because its result is infallible"#),
-                Ok(().into()),
-            ),
+            ("fallible_func!()", Ok(()), Err("function call error: failed!")),
+            // TODO: move to `remap-tests`
+            // ("fallible_func()", Ok(()), Err("remap error: function call error: failed!")),
+            // (
+            //     "map_printer!({})",
+            //     Err(r#"remap error: error for function "map_printer": cannot mark infallible function as "abort on error", remove the "!" signature"#),
+            //     Ok(().into()),
+            // ),
+            // (
+            //     "foo, err = fallible_func!()",
+            //     Err(r#"remap error: assignment error: the variable "foo" does not need to handle the error-case, because its result is infallible"#),
+            //     Ok(().into()),
+            // ),
             ("foo, err = fallible_func()", Ok(()), Ok(value!("function call error: failed!"))),
-            (
-                "foo, err = map_printer({})",
-                Err(r#"remap error: assignment error: the variable "foo" does not need to handle the error-case, because its result is infallible"#),
-                Ok(().into()),
-            ),
-            (
-                ".foo.bar, err = map_printer({})",
-                Err(r#"remap error: assignment error: the path ".foo.bar" does not need to handle the error-case, because its result is infallible"#),
-                Ok(().into()),
-            ),
+            // TODO: move to `remap-tests`
+            // (
+            //     "foo, err = map_printer({})",
+            //     Err(r#"remap error: assignment error: the variable "foo" does not need to handle the error-case, because its result is infallible"#),
+            //     Ok(().into()),
+            // ),
+            // (
+            //     ".foo.bar, err = map_printer({})",
+            //     Err(r#"remap error: assignment error: the path ".foo.bar" does not need to handle the error-case, because its result is infallible"#),
+            //     Ok(().into()),
+            // ),
             (
                 "
                     foo, err = fallible_func()
@@ -346,7 +350,7 @@ mod tests {
 
         for (script, compile_expected, runtime_expected) in cases {
             let program = Program::new(
-                script,
+                script.to_owned(),
                 &[
                     Box::new(test_functions::RegexPrinter),
                     Box::new(test_functions::EnumValidator),
@@ -361,7 +365,10 @@ mod tests {
             );
 
             assert_eq!(
-                program.as_ref().map(|_| ()).map_err(|e| e.to_string()),
+                program
+                    .as_ref()
+                    .map(|_| ())
+                    .map_err(|e| { Formatter::new(script, e.to_owned()).to_string() }),
                 compile_expected.map_err(|e: &str| e.to_string())
             );
 
@@ -369,13 +376,11 @@ mod tests {
                 continue;
             }
 
-            let program = program.unwrap();
+            let program = program.unwrap().0;
             let mut runtime = Runtime::new(state::Program::default());
             let mut event = value!({"foo": {"bar": "baz", "qux": [1, 2, {"quux": true}]}});
 
-            let result = runtime
-                .execute(&mut event, &program)
-                .map_err(|e| e.to_string());
+            let result = runtime.run(&mut event, &program).map_err(|e| e.to_string());
 
             assert_eq!(result, runtime_expected.map_err(|e: &str| e.to_string()));
         }
diff --git a/lib/remap-lang/src/parser.rs b/lib/remap-lang/src/parser.rs
index a91acb8f789c2..68761eface369 100644
--- a/lib/remap-lang/src/parser.rs
+++ b/lib/remap-lang/src/parser.rs
@@ -1,93 +1,261 @@
 #![allow(clippy::or_fun_call)]
 
 use crate::{
+    diagnostic::{self, Diagnostic, DiagnosticList, Label, Note, Span},
     expression::{
-        self, Arithmetic, Array, Assignment, Block, Function, IfStatement, Literal, Map, Noop, Not,
-        Path, Target, Variable,
+        self, function, if_statement::IfCondition, Arithmetic, Array, Assignment, Block, Function,
+        IfStatement, Literal, Map, Noop, Not, Path, Target, Variable,
     },
-    path, state, Error as E, Expr, Expression, Function as Fn, Operator, Result, Value,
+    path, state, Expr, Expression, Function as Fn, Operator, Value,
 };
+use pest::error::InputLocation;
 use pest::iterators::{Pair, Pairs};
 use regex::{Regex, RegexBuilder};
 use std::collections::BTreeMap;
+use std::ops::{Deref, DerefMut};
 use std::str::FromStr;
 
-#[derive(pest_derive::Parser, Default)]
+pub(crate) type R = Rule;
+type IResult<T> = Result<ParsedNode<T>, ParserBug>;
+type PestError = pest::error::Error<R>;
+
+#[derive(pest_derive::Parser)]
 #[grammar = "../grammar.pest"]
 pub(super) struct Parser<'a> {
     pub function_definitions: &'a [Box<dyn Fn>],
     pub allow_regex_return: bool,
-    pub compiler_state: state::Compiler,
+    pub compiler_state: &'a mut state::Compiler,
+
+    /// This field keeps track of the *recoverable* errors the parser
+    /// encountered while parsing a program source.
+    ///
+    /// If the parser can continue after an error occurs, it is collected in
+    /// this field. If a *fatal* error is encountered, the parses tries to move
+    /// on to the next expression and records the failed expression as a
+    /// `ParserBug`.
+    ///
+    /// The field is added to the `ParseError` return value once parsing is
+    /// finished.
+    ///
+    /// All parsing functions take `self` such that this state cannot leak into
+    /// subsequent parsing calls.
+    diagnostics: DiagnosticList,
+}
+
+impl<'a> From<&Pair<'a, R>> for Span {
+    fn from(pair: &Pair<R>) -> Self {
+        pair.as_span().into()
+    }
+}
+
+impl From<pest::Span<'_>> for Span {
+    fn from(span: pest::Span) -> Self {
+        (span.start()..span.end()).into()
+    }
+}
+
+impl From<PestError> for Diagnostic {
+    fn from(err: PestError) -> Self {
+        let msg = "syntax error";
+
+        let span = match err.location {
+            InputLocation::Pos(start) => start..start,
+            InputLocation::Span((start, end)) => start..end,
+        };
+
+        let label = Label::primary("invalid token", span.clone());
+
+        match err.variant {
+            pest::error::ErrorVariant::ParsingError {
+                positives,
+                negatives,
+            } => {
+                let expected = if positives.len() == 1 {
+                    Label::context(format!("expected: {}", positives[0]), span.clone())
+                } else {
+                    Label::context(
+                        format!(
+                            "expected one of: {}",
+                            positives
+                                .iter()
+                                .map(|r| r.to_string())
+                                .collect::<Vec<_>>()
+                                .join(", ")
+                        ),
+                        span.clone(),
+                    )
+                };
+
+                let unexpected = Label::primary(
+                    format!(
+                        "unexpected: {}",
+                        negatives
+                            .iter()
+                            .map(|r| r.to_string())
+                            .collect::<Vec<_>>()
+                            .join(", ")
+                    ),
+                    span.clone(),
+                );
+
+                match () {
+                    _ if !positives.is_empty() => Diagnostic::error(msg)
+                        .with_label(label)
+                        .with_label(expected),
+                    _ if !negatives.is_empty() => Diagnostic::error(msg)
+                        .with_label(label)
+                        .with_label(unexpected),
+                    _ => Diagnostic::error(msg).with_primary("unexpected token", span),
+                }
+            }
+            pest::error::ErrorVariant::CustomError { message } => {
+                Diagnostic::error(msg).with_primary(message, span)
+            }
+        }
+    }
+}
+
+// -----------------------------------------------------------------------------
+
+/// A non-recoverable error raised by the parser.
+///
+/// The parser tries to recover the next expression it tries to parse, if
+/// possible.
+#[derive(Debug, Clone)]
+pub(crate) struct ParserBug(Span, R);
+
+impl From<ParserBug> for Diagnostic {
+    fn from(err: ParserBug) -> Self {
+        Diagnostic::bug("unexpected token").with_primary(err.1.to_string(), err.0)
+    }
 }
 
-type R = Rule;
+// -----------------------------------------------------------------------------
 
-#[derive(thiserror::Error, Clone, Debug, PartialEq)]
-pub enum Error {
-    #[error("cannot assign regex to object")]
-    RegexAssignment,
+/// A container type that wraps an [`Expression`] and adds a span pointing to
+/// the expression position within the parsed source.
+#[derive(Clone, Debug, PartialEq)]
+pub struct ParsedExpression {
+    span: Span,
+    expr: Expr,
+}
 
-    #[error("cannot return regex from program")]
-    RegexResult,
+impl ParsedExpression {
+    pub fn span(&self) -> Span {
+        self.span
+    }
+}
 
-    #[error(r#"path in variable assignment unsupported, use "{0}" without "{1}""#)]
-    VariableAssignmentPath(String, String),
+impl Deref for ParsedExpression {
+    type Target = Expr;
 
-    #[error("regex error")]
-    Regex(#[from] regex::Error),
+    fn deref(&self) -> &Self::Target {
+        &self.expr
+    }
+}
 
-    #[error(transparent)]
-    Pest(pest::error::Error<R>),
+impl DerefMut for ParsedExpression {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.expr
+    }
 }
 
-impl From<pest::error::Error<R>> for Error {
-    fn from(mut error: pest::error::Error<R>) -> Self {
-        use pest::error::ErrorVariant;
-
-        if let ErrorVariant::ParsingError {
-            ref mut positives,
-            negatives: _,
-        } = error.variant
-        {
-            *positives = positives
-                .clone()
-                .into_iter()
-                .filter(|rule| !rule.to_string().is_empty())
-                .collect::<Vec<_>>();
+impl<T: Into<Expr>> From<ParsedNode<T>> for ParsedExpression {
+    fn from(node: ParsedNode<T>) -> Self {
+        Self {
+            span: node.span,
+            expr: node.inner.into(),
         }
+    }
+}
+
+// -----------------------------------------------------------------------------
+
+/// Similar to [`ParsedExpression`] except that it is private, generic over `T`
+/// and has an expanded API used within the parser.
+#[derive(Clone, Debug, PartialEq)]
+struct ParsedNode<T> {
+    span: Span,
+    inner: T,
+}
+
+impl<T> Deref for ParsedNode<T> {
+    type Target = T;
 
-        error = error.renamed_rules(|rule| rule.to_string());
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+impl<T> DerefMut for ParsedNode<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+
+impl<T> ParsedNode<T> {
+    fn into_inner(self) -> T {
+        self.inner
+    }
 
-        Error::Pest(error)
+    fn take(self) -> (Span, T) {
+        (self.span, self.inner)
+    }
+
+    #[allow(clippy::wrong_self_convention)]
+    fn to_expr(self) -> ParsedNode<Expr>
+    where
+        T: Into<Expr>,
+    {
+        let (span, inner) = self.take();
+
+        ParsedNode {
+            span,
+            inner: inner.into(),
+        }
     }
 }
 
+impl<T, U: Into<T>, S: Into<Span>> From<(S, U)> for ParsedNode<T> {
+    fn from((span, node): (S, U)) -> Self {
+        Self {
+            span: span.into(),
+            inner: node.into(),
+        }
+    }
+}
+
+// -----------------------------------------------------------------------------
+
 // Auto-generate a set of parser functions to parse different operations.
 macro_rules! operation_fns {
     (@impl $($rule:tt => { op: [$head_op:path, $($tail_op:path),+ $(,)?], next: $next:tt, })+) => (
         $(
             paste::paste! {
-                fn [<$rule _from_pairs>](&mut self, mut pairs: Pairs<R>) -> Result<Expr> {
-                    let inner = pairs.next().ok_or(e(R::$rule))?.into_inner();
-                    let mut lhs = self.[<$next _from_pairs>](inner)?;
+                fn [<$rule _from_pair>](&mut self, pair: Pair<R>) -> IResult<Expr> {
+                    let span = Span::from(&pair);
+                    let mut pairs = pair.into_inner();
+
+                    let next = pairs.next().ok_or(e(R::$rule, span))?;
+                    let (span, mut lhs) = self.[<$next _from_pair>](next)?.take();
                     let mut op = Operator::$head_op;
 
                     for pair in pairs {
                         match pair.as_rule() {
                             R::[<operator_ $rule>] => {
-                                op = Operator::from_str(pair.as_str()).map_err(|_| e(R::$rule))?;
+                                op = Operator::from_str(pair.as_str()).map_err(|_| e(R::$rule, span))?;
                             }
                             _ => {
                                 lhs = Expr::from(Arithmetic::new(
                                     Box::new(lhs),
-                                    Box::new(self.[<$next _from_pairs>](pair.into_inner())?),
+                                    Box::new(self.[<$next _from_pair>](pair)?.into_inner()),
                                     op.clone(),
                                 ));
                             }
                         }
                     }
 
-                    Ok(lhs)
+                    Ok((span, lhs).into())
                 }
             }
         )+
@@ -99,31 +267,52 @@ macro_rules! operation_fns {
 }
 
 impl<'a> Parser<'a> {
-    pub fn new(function_definitions: &'a [Box<dyn Fn>], allow_regex_return: bool) -> Self {
+    pub fn new(
+        function_definitions: &'a [Box<dyn Fn>],
+        compiler_state: &'a mut state::Compiler,
+        allow_regex_return: bool,
+    ) -> Self {
         Self {
             function_definitions,
             allow_regex_return,
-            ..Default::default()
+            compiler_state,
+            diagnostics: DiagnosticList::default(),
         }
     }
 
-    pub fn program_from_str(&mut self, source: &str) -> Result<Vec<Expr>> {
-        let pairs = self.pairs_from_str(R::program, source)?;
-        self.pairs_to_expressions(pairs)
+    /// Parse a source string into a valid [`Program`].
+    pub(crate) fn program_from_str(
+        mut self,
+        source: &'a str,
+    ) -> diagnostic::Result<Vec<ParsedExpression>> {
+        let expressions = self
+            .pairs_from_str(R::program, source)
+            .and_then(|pairs| self.pairs_to_expressions(pairs.into_inner()))
+            .map(|node| node.into_inner())
+            .map(|nodes| nodes.into_iter().map(Into::into).collect::<Vec<_>>())
+            .map_err(|err| self.diagnostics.push(err.into()));
+
+        match expressions {
+            Err(_) => Err(self.diagnostics),
+            Ok(_) if self.diagnostics.is_err() => Err(self.diagnostics),
+            Ok(expressions) => Ok((expressions, self.diagnostics)),
+        }
     }
 
     /// Parse a string path into a [`path::Path`] wrapper with easy access to
     /// individual path [`path::Segment`]s.
-    ///
-    /// This function fails if the provided path is invalid, as defined by the
-    /// parser grammar.
-    pub(crate) fn path_from_str(&mut self, path: &str) -> Result<path::Path> {
-        let mut pairs = self.pairs_from_str(R::rule_path, path)?;
-        let pair = pairs.next().ok_or(e(R::rule_path))?;
-
-        match pair.as_rule() {
-            R::path => self.path_from_pair(pair),
-            _ => unreachable!(),
+    pub(crate) fn path_from_str(mut self, path: &'a str) -> diagnostic::Result<path::Path> {
+        let path = self
+            .pairs_from_str(R::rule_path, path)
+            .and_then(|pairs| pairs.into_inner().next().ok_or(e(R::rule_path, path)))
+            .and_then(|pair| self.path_from_pair(pair))
+            .map(|node| node.into_inner())
+            .map_err(|err| self.diagnostics.push(err.into()));
+
+        match path {
+            Err(_) => Err(self.diagnostics),
+            Ok(_) if self.diagnostics.is_err() => Err(self.diagnostics),
+            Ok(path) => Ok((path, self.diagnostics)),
         }
     }
 
@@ -136,169 +325,231 @@ impl<'a> Parser<'a> {
     /// - An error if neither is true.
     ///
     /// These rules are defined by the Remap parser.
-    pub(crate) fn path_field_from_str(&mut self, field: &str) -> Result<path::Field> {
-        use pest::Parser;
-
-        if let Ok(mut pairs) = Self::parse(R::rule_ident, field) {
-            let field = pairs.next().ok_or(e(R::rule_ident))?.as_str().to_owned();
-
-            return Ok(path::Field::Regular(field));
-        }
-
+    pub(crate) fn path_field_from_str(mut self, field: &'a str) -> diagnostic::Result<path::Field> {
         let field = self
-            .pairs_from_str(R::rule_string_inner, field)?
-            .next()
-            .ok_or(e(R::rule_string_inner))?
-            .as_str()
-            .to_owned();
+            .pairs_from_str(R::rule_ident, field)
+            .and_then(|pairs| pairs.into_inner().next().ok_or(e(R::rule_ident, field)))
+            .map(|pair| path::Field::Regular(pair.as_str().to_owned()))
+            .or_else(|_| {
+                self.diagnostics.clear();
+
+                self.pairs_from_str(R::rule_string_inner, field)
+                    .map(|node| node.into_inner())
+                    .and_then(|mut pairs| pairs.next().ok_or(e(R::rule_string_inner, field)))
+                    .map(|pair| path::Field::Quoted(pair.as_str().to_owned()))
+            })
+            .map_err(|err| self.diagnostics.push(err.into()));
 
-        Ok(path::Field::Quoted(field))
+        match field {
+            Err(_) => Err(self.diagnostics),
+            Ok(_) if self.diagnostics.is_err() => Err(self.diagnostics),
+            Ok(field) => Ok((field, self.diagnostics)),
+        }
     }
 
     /// Converts the set of known "root" rules into boxed [`Expression`] trait
     /// objects.
-    fn pairs_to_expressions(&mut self, pairs: Pairs<R>) -> Result<Vec<Expr>> {
-        let mut expressions = vec![];
+    fn pairs_to_expressions(&mut self, pairs: Pairs<'a, R>) -> IResult<Vec<ParsedNode<Expr>>> {
+        let mut nodes = vec![];
 
         for pair in pairs {
             match pair.as_rule() {
                 R::assignment | R::boolean_expr | R::block | R::if_statement => {
-                    expressions.push(self.expression_from_pair(pair)?)
+                    nodes.push(self.expression_from_pair(pair)?)
                 }
                 R::EOI => (),
-                _ => return Err(e(R::expression)),
+                _ => return Err(e(R::expression, &pair)),
             }
         }
 
-        if let Some(expression) = expressions.last() {
-            let type_def = expression.type_def(&self.compiler_state);
+        if let Some(node) = nodes.last() {
+            let td = node.type_def(&self.compiler_state);
 
-            if !self.allow_regex_return
-                && !type_def.kind.is_all()
-                && type_def.scalar_kind().contains_regex()
-            {
-                return Err(Error::RegexResult.into());
+            if !self.allow_regex_return && !td.kind.is_all() && td.scalar_kind().contains_regex() {
+                self.diagnostics.push(
+                    Diagnostic::error("invalid return value")
+                        .with_primary("regex return value not allowed", node.span),
+                );
             }
         }
 
-        Ok(expressions)
+        let start = nodes.first().map(|n| n.span.start).unwrap_or_default();
+        let end = nodes.last().map(|n| n.span.end).unwrap_or_default();
+
+        Ok((start..end, nodes).into())
     }
 
-    fn pairs_from_str<'b>(&mut self, rule: R, s: &'b str) -> Result<Pairs<'b, R>> {
+    fn pairs_from_str<'b>(&mut self, rule: R, source: &'b str) -> IResult<Pairs<'b, R>> {
         use pest::Parser;
-        Self::parse(rule, s).map_err(|err| E::from(Error::from(err)))
+
+        let span = Span::from(source);
+        let pairs = match Self::parse(rule, source) {
+            Ok(pairs) => pairs,
+            Err(err) => {
+                self.diagnostics.push(err.into());
+                pest::state("", Ok).unwrap()
+            }
+        };
+
+        Ok((span, pairs).into())
     }
 
     /// Given a `Pair`, build a boxed [`Expression`] trait object from it.
-    fn expression_from_pair(&mut self, pair: Pair<R>) -> Result<Expr> {
+    fn expression_from_pair(&mut self, pair: Pair<R>) -> IResult<Expr> {
         match pair.as_rule() {
-            R::assignment => self.assignment_from_pairs(pair.into_inner()),
-            R::boolean_expr => self.boolean_expr_from_pairs(pair.into_inner()),
-            R::block => self.block_from_pairs(pair.into_inner()),
-            R::if_statement => self.if_statement_from_pairs(pair.into_inner()),
-            _ => Err(e(R::expression)),
+            R::assignment => self.assignment_from_pair(pair),
+            R::boolean_expr => self.boolean_expr_from_pair(pair),
+            R::block => self.block_from_pair(pair),
+            R::if_statement => self.if_statement_from_pair(pair),
+            _ => Err(e(R::expression, &pair)),
         }
     }
 
-    fn assignment_from_pairs(&mut self, mut pairs: Pairs<R>) -> Result<Expr> {
-        let target = self.target_from_pair(pairs.next().ok_or(e(R::assignment))?)?;
-        let expression = self.expression_from_pair(pairs.next().ok_or(e(R::assignment))?)?;
+    fn assignment_from_pair(&mut self, pair: Pair<R>) -> IResult<Expr> {
+        let span = Span::from(&pair);
+        let mut pairs = pair.into_inner();
 
-        // We explicitly reject assigning `Value::Regex` to an object.
-        //
-        // This makes it easier to implement `trait Object`, as you don't need
-        // to convert `Value::Regex` to a compatible type, such as a map in
-        // JSON.
-        if matches!(target, Target::Path(_)) {
-            match &expression {
-                Expr::Literal(literal) if !self.allow_regex_return && literal.is_regex() => {
-                    return Err(Error::RegexAssignment.into())
-                }
-                Expr::Literal(literal) => {
-                    if let Some(array) = literal.as_array() {
-                        array.iter().try_for_each(|value| {
-                            if !self.allow_regex_return && value.is_regex() {
-                                Err(E::from(Error::RegexAssignment))
-                            } else {
-                                Ok(())
-                            }
-                        })?
-                    }
-                }
-                Expr::Array(array)
-                    if array.expressions().iter().any(|expr| match expr {
-                        Expr::Literal(literal) if !self.allow_regex_return => literal.is_regex(),
-                        _ => false,
-                    }) =>
-                {
-                    return Err(Error::RegexAssignment.into())
-                }
-                _ => {}
+        let (target_span, mut target) = self
+            .target_from_pair(pairs.next().ok_or(e(R::assignment, span))?)?
+            .take();
+        let (expression_span, expression) = self
+            .expression_from_pair(pairs.next().ok_or(e(R::assignment, span))?)?
+            .take();
+
+        let assignment_span = target_span.start..expression_span.end;
+
+        if let Target::Infallible { ok, err } = &target {
+            if !expression.type_def(&self.compiler_state).is_fallible() {
+                self.diagnostics.push(
+                    Diagnostic::error("unneeded error assignment")
+                        .with_primary("this error assignment is unneeded", target_span)
+                        .with_context("because this expression cannot fail", expression_span)
+                        .with_note(Note::InfallibleAssignment {
+                            ok: ok.to_string(),
+                            err: err.to_string(),
+                        }),
+                );
+
+                target = Target::Variable(Variable::new("_".to_owned(), None));
             }
         }
 
-        Assignment::new(target, Box::new(expression), &mut self.compiler_state).map(Into::into)
+        let assignment = Assignment::new(target, Box::new(expression), &mut self.compiler_state);
+
+        Ok((assignment_span, assignment).into())
     }
 
     /// Return the target type to which a value is being assigned.
     ///
     /// This can either return a `variable` or a `target_path` target, depending
     /// on the parser rule being processed.
-    fn target_from_pair(&mut self, pair: Pair<R>) -> Result<Target> {
+    fn target_from_pair(&mut self, pair: Pair<R>) -> IResult<Target> {
         match pair.as_rule() {
-            R::variable => self.variable_from_pair(pair).and_then(|variable| {
+            R::variable => self.variable_from_pair(pair).map(|node| {
+                let (span, mut variable) = node.take();
+
+                // track an error diagnostic and re-assign variable to a
+                // variable without a path, since we don't support this
+                // currently.
                 if let Some(path) = variable.path() {
-                    return Err(Error::VariableAssignmentPath(
-                        variable.ident().to_owned(),
-                        path.to_string(),
-                    )
-                    .into());
+                    let path_span = span.end - path.to_string().bytes().len()..span.end;
+                    let variable_span = span.start..path_span.start;
+
+                    self.diagnostics.push(
+                        Diagnostic::error("path-based variable assignment")
+                            .with_primary(
+                                "assignment to variable path currently unsupported",
+                                path_span,
+                            )
+                            .with_context(
+                                format!(r#"assign to "{}" instead"#, variable.ident()),
+                                variable_span,
+                            ),
+                    );
+
+                    variable = Variable::new("_".to_owned(), None);
                 }
 
-                Ok(Target::Variable(variable))
+                (span, Target::Variable(variable)).into()
             }),
-            R::path => Ok(Target::Path(Path::new(self.path_from_pair(pair)?))),
-            R::target_infallible => self.target_infallible_from_pairs(pair.into_inner()),
-            _ => Err(e(R::target)),
+            R::path => {
+                let (span, path) = self.path_from_pair(pair)?.take();
+                Ok((span, Target::Path(Path::new(path))).into())
+            }
+            R::target_infallible => self
+                .target_infallible_from_pair(pair)
+                .map(|node| node.take().into()),
+            _ => Err(e(R::target, &pair)),
         }
     }
 
-    fn target_infallible_from_pairs(&mut self, mut pairs: Pairs<R>) -> Result<Target> {
-        let ok = pairs
+    fn target_infallible_from_pair(&mut self, pair: Pair<R>) -> IResult<Target> {
+        let span = Span::from(&pair);
+        let mut pairs = pair.into_inner();
+
+        let (ok_span, ok) = pairs
             .next()
-            .ok_or(e(R::target_infallible))
-            .and_then(|pair| Ok(Box::new(self.target_from_pair(pair)?)))?;
+            .ok_or(e(R::target_infallible, span))
+            .and_then(|pair| Ok(self.target_from_pair(pair)?))?
+            .take();
 
-        let err = pairs
+        let (err_span, err) = pairs
             .next()
-            .ok_or(e(R::target_infallible))
-            .and_then(|pair| Ok(Box::new(self.target_from_pair(pair)?)))?;
+            .ok_or(e(R::target_infallible, span))
+            .and_then(|pair| Ok(self.target_from_pair(pair)?))?
+            .take();
+
+        let (ok, err) = (Box::new(ok), Box::new(err));
 
-        Ok(Target::Infallible { ok, err })
+        Ok((
+            Span::new(ok_span.start, err_span.end),
+            Target::Infallible { ok, err },
+        )
+            .into())
     }
 
     /// Parse block expressions.
-    fn block_from_pairs(&mut self, pairs: Pairs<R>) -> Result<Expr> {
+    fn block_from_pair(&mut self, pair: Pair<R>) -> IResult<Expr> {
+        let span = Span::from(&pair);
         let mut expressions = vec![];
 
-        for pair in pairs {
-            expressions.push(self.expression_from_pair(pair)?);
+        for pair in pair.into_inner() {
+            expressions.push(self.expression_from_pair(pair)?.into_inner());
         }
 
-        Ok(Block::new(expressions).into())
+        Ok((span, Block::new(expressions)).into())
     }
 
     /// Parse if-statement expressions.
-    fn if_statement_from_pairs(&mut self, mut pairs: Pairs<R>) -> Result<Expr> {
+    fn if_statement_from_pair(&mut self, pair: Pair<R>) -> IResult<Expr> {
+        self.compiler_state.track_changes();
+
+        let span = Span::from(&pair);
+        let mut pairs = pair.into_inner();
+
         // if condition
-        let conditional = self.if_condition_from_pair(pairs.next().ok_or(e(R::if_statement))?)?;
-        let true_expression = self.expression_from_pair(pairs.next().ok_or(e(R::if_statement))?)?;
+        let conditional = self
+            .if_condition_from_pair(pairs.next().ok_or(e(R::if_statement, span))?)?
+            .into_inner();
+
+        // If the conditional failed to parse, it has created an error
+        // diagnostic. We return a no-op expression. This allows us to continue
+        // parsing.
+        let conditional = match self.try_or_noop(conditional, span) {
+            Ok(conditional) => conditional,
+            Err(noop) => return noop,
+        };
+
+        let true_expression = self
+            .expression_from_pair(pairs.next().ok_or(e(R::if_statement, span))?)?
+            .into_inner();
 
         // else condition
         let mut false_expression = pairs
             .next_back()
             .map(|pair| self.expression_from_pair(pair))
             .transpose()?
+            .map(ParsedNode::into_inner)
             .unwrap_or_else(|| Expr::from(Noop));
 
         let mut pairs = pairs.rev().peekable();
@@ -307,60 +558,83 @@ impl<'a> Parser<'a> {
         while let Some(pair) = pairs.next() {
             let (conditional, true_expression) = match pairs.peek().map(Pair::as_rule) {
                 Some(R::block) | None => {
-                    let conditional = self.if_condition_from_pair(pair)?;
+                    let conditional = self.if_condition_from_pair(pair)?.into_inner();
+                    let conditional = match self.try_or_noop(conditional, span) {
+                        Ok(conditional) => conditional,
+                        Err(noop) => return noop,
+                    };
+
                     let true_expression = false_expression;
-                    false_expression = Expr::from(Noop);
+                    false_expression = Noop.into();
 
                     (conditional, true_expression)
                 }
                 Some(R::if_condition) => {
-                    let next_pair = pairs.next().ok_or(e(R::if_statement))?;
-                    let conditional = self.if_condition_from_pair(next_pair)?;
-                    let true_expression = self.expression_from_pair(pair)?;
+                    let next_pair = pairs.next().ok_or(e(R::if_statement, span))?;
+
+                    let conditional = self.if_condition_from_pair(next_pair)?.into_inner();
+                    let conditional = match self.try_or_noop(conditional, span) {
+                        Ok(conditional) => conditional,
+                        Err(noop) => return noop,
+                    };
+
+                    let true_expression = self.expression_from_pair(pair)?.into_inner();
 
                     (conditional, true_expression)
                 }
-                _ => return Err(e(R::if_statement)),
+                _ => return Err(e(R::if_statement, span)),
             };
 
-            false_expression = Expr::from(IfStatement::new(
-                Box::new(conditional),
+            false_expression = IfStatement::new(
+                conditional,
                 Box::new(true_expression),
                 Box::new(false_expression),
-                &self.compiler_state,
-            )?);
+            )
+            .into();
         }
 
-        IfStatement::new(
-            Box::new(conditional),
+        let node = IfStatement::new(
+            conditional,
             Box::new(true_expression),
             Box::new(false_expression),
-            &self.compiler_state,
-        )
-        .map(Into::into)
+        );
+
+        Ok((span, node).into())
     }
 
-    fn if_condition_from_pair(&mut self, pair: Pair<R>) -> Result<Expr> {
-        let mut pairs = pair.into_inner();
+    fn if_condition_from_pair(&mut self, pair: Pair<R>) -> IResult<Result<IfCondition, ()>> {
+        let span = Span::from(&pair);
+        let mut pairs = pair.clone().into_inner();
 
-        if let Some(R::boolean_expr) = pairs.peek().map(|p| p.as_rule()) {
-            return self.expression_from_pair(pairs.next().ok_or(e(R::if_condition))?);
-        }
+        let (span, expression) = if let Some(R::boolean_expr) = pairs.peek().map(|p| p.as_rule()) {
+            let pair = pairs.next().ok_or(e(R::if_condition, span))?;
+            self.expression_from_pair(pair)?.take()
+        } else {
+            self.block_from_pair(pair)?.take()
+        };
+
+        // If the condition is invalid, we add a diagnostic error. We also let
+        // the callee know parsing the condition failed.
+        let result = IfCondition::new(Box::new(expression), &self.compiler_state)
+            .map_err(|err| self.diagnostics.push((span, err).into()));
 
-        self.block_from_pairs(pairs)
+        Ok((span, result).into())
     }
 
     /// Parse not operator, or fall-through to primary values or function calls.
-    fn not_from_pairs(&mut self, pairs: Pairs<R>) -> Result<Expr> {
+    fn not_from_pair(&mut self, pair: Pair<R>) -> IResult<Expr> {
+        let span = Span::from(&pair);
+        let pairs = pair.into_inner();
+
         let mut count = 0;
         let mut expression = Expr::from(Noop);
 
         for pair in pairs {
             match pair.as_rule() {
                 R::operator_not => count += 1,
-                R::primary => expression = self.primary_from_pair(pair)?,
-                R::call => expression = self.call_from_pair(pair)?,
-                _ => return Err(e(R::not)),
+                R::primary => expression = self.primary_from_pair(pair)?.into_inner(),
+                R::call => expression = self.call_from_pair(pair)?.into_inner(),
+                _ => return Err(e(R::not, &pair)),
             }
         }
 
@@ -368,76 +642,106 @@ impl<'a> Parser<'a> {
             expression = Expr::from(Not::new(Box::new(expression)))
         }
 
-        Ok(expression)
+        Ok((span, expression).into())
     }
 
     /// Parse one of possible primary expressions.
-    fn primary_from_pair(&mut self, pair: Pair<R>) -> Result<Expr> {
-        let pair = pair.into_inner().next().ok_or(e(R::primary))?;
+    fn primary_from_pair(&mut self, pair: Pair<R>) -> IResult<Expr> {
+        let span = Span::from(&pair);
+        let pair = pair.into_inner().next().ok_or(e(R::primary, span))?;
 
         match pair.as_rule() {
-            R::value => self.literal_from_pair(pair.into_inner().next().ok_or(e(R::value))?),
-            R::variable => self.variable_from_pair(pair).map(Into::into),
-            R::path => Ok(Path::new(self.path_from_pair(pair)?).into()),
-            R::group => self.expression_from_pair(pair.into_inner().next().ok_or(e(R::group))?),
-            _ => Err(e(R::primary)),
+            R::value => self.literal_from_pair(pair.into_inner().next().ok_or(e(R::value, span))?),
+            R::variable => self.variable_from_pair(pair).map(ParsedNode::to_expr),
+            R::path => self.path_from_pair(pair).map(|node| {
+                let (span, path) = node.take();
+                (span, Path::new(path)).into()
+            }),
+            R::group => {
+                self.expression_from_pair(pair.into_inner().next().ok_or(e(R::group, span))?)
+            }
+            _ => Err(e(R::primary, &pair)),
         }
     }
 
     /// Parse a [`Value`] into a [`Literal`] expression.
-    fn literal_from_pair(&mut self, pair: Pair<R>) -> Result<Expr> {
-        Ok(match pair.as_rule() {
-            R::string => self.string_from_pair(pair)?.into(),
-            R::null => Literal::from(Value::Null).into(),
-            R::boolean => Literal::from(pair.as_str() == "true").into(),
-            R::integer => {
-                Literal::from(pair.as_str().parse::<i64>().map_err(|_| e(R::integer))?).into()
-            }
-            R::float => {
-                Literal::from(pair.as_str().parse::<f64>().map_err(|_| e(R::float))?).into()
-            }
-            R::array => self.array_from_pair(pair)?.into(),
-            R::map => self.map_from_pair(pair)?.into(),
-            R::regex => Literal::from(self.regex_from_pair(pair)?).into(),
-            _ => return Err(e(R::value)),
-        })
+    fn literal_from_pair(&mut self, pair: Pair<R>) -> IResult<Expr> {
+        let span = Span::from(&pair);
+
+        match pair.as_rule() {
+            R::string => self.string_from_pair(pair).map(ParsedNode::to_expr),
+            R::null => Ok((span, Literal::from(Value::Null)).into()),
+            R::boolean => Ok((span, Literal::from(pair.as_str() == "true")).into()),
+            R::integer => Ok((
+                span,
+                Literal::from(
+                    pair.as_str()
+                        .parse::<i64>()
+                        .map_err(|_| e(R::integer, &pair))?,
+                ),
+            )
+                .into()),
+            R::float => Ok((
+                span,
+                Literal::from(
+                    pair.as_str()
+                        .parse::<f64>()
+                        .map_err(|_| e(R::float, &pair))?,
+                ),
+            )
+                .into()),
+            R::array => self.array_from_pair(pair).map(ParsedNode::to_expr),
+            R::map => self.map_from_pair(pair).map(ParsedNode::to_expr),
+            R::regex => self.regex_from_pair(pair).map(ParsedNode::to_expr),
+            _ => Err(e(R::value, &pair)),
+        }
     }
 
-    fn array_from_pair(&mut self, pair: Pair<R>) -> Result<Array> {
+    fn array_from_pair(&mut self, pair: Pair<R>) -> IResult<Array> {
+        let span = Span::from(&pair);
+
         let expressions = pair
             .into_inner()
-            .map(|pair| self.expression_from_pair(pair))
-            .collect::<Result<Vec<_>>>()?;
+            .map(|pair| self.expression_from_pair(pair).map(ParsedNode::into_inner))
+            .collect::<Result<Vec<_>, _>>()?;
 
-        Ok(Array::new(expressions))
+        Ok((span, Array::new(expressions)).into())
     }
 
-    fn map_from_pair(&mut self, pair: Pair<R>) -> Result<Map> {
+    fn map_from_pair(&mut self, pair: Pair<R>) -> IResult<Map> {
+        let span = Span::from(&pair);
+
         let map = pair
             .into_inner()
-            .map(|pair| self.kv_from_pair(pair))
-            .collect::<Result<BTreeMap<_, _>>>()?;
+            .map(|pair| self.kv_from_pair(pair).map(ParsedNode::into_inner))
+            .collect::<Result<BTreeMap<_, _>, _>>()?;
 
-        Ok(Map::new(map))
+        Ok((span, Map::new(map)).into())
     }
 
-    fn kv_from_pair(&mut self, pair: Pair<R>) -> Result<(String, Expr)> {
+    fn kv_from_pair(&mut self, pair: Pair<R>) -> IResult<(String, Expr)> {
+        let span = Span::from(&pair);
         let mut inner = pair.into_inner();
 
-        let pair = inner.next().ok_or(e(R::kv_pair))?;
-        let key = self.string_from_pair(pair)?;
+        let pair = inner.next().ok_or(e(R::kv_pair, span))?;
+        let (key_span, key) = self.string_from_pair(pair)?.take();
 
-        let pair = inner.next().ok_or(e(R::kv_pair))?;
-        let expr = self.expression_from_pair(pair)?;
+        let pair = inner.next().ok_or(e(R::kv_pair, span))?;
+        let (expr_span, expr) = self.expression_from_pair(pair)?.take();
 
-        Ok((key, expr))
+        Ok((key_span.start..expr_span.end, (key, expr)).into())
     }
 
     /// Parse function call expressions.
-    fn call_from_pair(&mut self, pair: Pair<R>) -> Result<Expr> {
+    fn call_from_pair(&mut self, pair: Pair<R>) -> IResult<Expr> {
+        self.compiler_state.track_changes();
+
+        let span = Span::from(&pair);
         let mut inner = pair.into_inner();
 
-        let ident = inner.next().ok_or(e(R::call))?.as_str().to_owned();
+        let ident = inner.next().ok_or(e(R::call, span))?.as_str();
+        let ident_span = span.start..=ident.bytes().len();
+
         let abort_on_error = match inner.peek().map(|p| p.as_rule()) {
             Some(R::bang) => {
                 inner.next();
@@ -446,51 +750,107 @@ impl<'a> Parser<'a> {
             _ => false,
         };
 
-        let arguments = inner
+        let (arguments_span, arguments) = inner
             .next()
             .map(|pair| self.arguments_from_pair(pair))
             .transpose()?
-            .unwrap_or_default();
+            .map(|s| s.take())
+            .unwrap_or_else(|| (Span::default(), vec![]));
 
-        Function::new(
+        let function = Function::new(
             ident,
             abort_on_error,
             arguments,
             &self.function_definitions,
             &self.compiler_state,
-        )
-        .map(Expr::from)
+        );
+
+        let expression: Expr = match function {
+            Ok(function) => function.into(),
+            Err(err) => {
+                self.compiler_state.revert_changes();
+
+                self.diagnostics.push(match err {
+                    function::Error::Undefined => Diagnostic::error("call to undefined function")
+                        .with_primary("undefined function", ident_span),
+                    function::Error::ArityMismatch { max, got } => {
+                        Diagnostic::error("function argument arity mismatch")
+                            .with_primary(format!("got: {}", got), arguments_span)
+                            .with_context(format!("expected: {} (at most)", max), arguments_span)
+                    }
+                    // TODO: have spans for each individual keyword
+                    function::Error::UnknownKeyword(kw) => {
+                        Diagnostic::error("unknown function argument keyword")
+                            .with_primary(format!("unknown keyword: {}", kw), arguments_span)
+                    }
+                    function::Error::AbortInfallible => {
+                        let bang_span = *ident_span.end() + 1..*ident_span.end() + 1;
+
+                        Diagnostic::error("cannot abort function that never fails")
+                            .with_primary("this function cannot fail", ident_span)
+                            .with_context("remove this abort-instruction", bang_span)
+                            .with_note(Note::SeeErrDocs)
+                    }
+                    function::Error::MissingArg { argument, .. } => {
+                        Diagnostic::error("function argument missing")
+                            .with_primary(format!("required argument missing: {}", argument), span)
+                    }
+                    function::Error::Compile(message) => {
+                        Diagnostic::error("unable to parse function").with_primary(message, span)
+                    }
+                    function::Error::Argument(arg, err) => {
+                        Diagnostic::error("function argument error")
+                            .with_primary(format!("{}: {}", arg, err), arguments_span)
+                    }
+                });
+
+                Noop.into()
+            }
+        };
+
+        Ok((span, expression).into())
     }
 
     /// Parse into a vector of argument properties.
-    fn arguments_from_pair(&mut self, pair: Pair<R>) -> Result<Vec<(Option<String>, Expr)>> {
-        pair.into_inner()
-            .map(|pair| self.argument_from_pair(pair))
-            .collect::<Result<_>>()
+    fn arguments_from_pair(&mut self, pair: Pair<R>) -> IResult<Vec<(Option<String>, Expr)>> {
+        let span = Span::from(&pair);
+
+        let arguments = pair
+            .into_inner()
+            .map(|pair| self.argument_from_pair(pair).map(ParsedNode::into_inner))
+            .collect::<Result<Vec<_>, _>>()?;
+
+        Ok((span, arguments).into())
     }
 
     /// Parse optional argument keyword and [`Argument`] value.
-    fn argument_from_pair(&mut self, pair: Pair<R>) -> Result<(Option<String>, Expr)> {
+    fn argument_from_pair(&mut self, pair: Pair<R>) -> IResult<(Option<String>, Expr)> {
+        let span = Span::from(&pair);
         let mut ident = None;
 
         for pair in pair.into_inner() {
             match pair.as_rule() {
                 // This matches first, if a keyword is provided.
                 R::ident => ident = Some(pair.as_str().to_owned()),
-                _ => return Ok((ident, self.expression_from_pair(pair)?)),
+                _ => {
+                    return Ok(
+                        (span, (ident, self.expression_from_pair(pair)?.into_inner())).into(),
+                    )
+                }
             }
         }
 
-        Err(e(R::argument))
+        Err(e(R::argument, span))
     }
 
     /// Parse a [`Regex`] value
-    fn regex_from_pair(&self, pair: Pair<R>) -> Result<Regex> {
+    fn regex_from_pair(&mut self, pair: Pair<R>) -> IResult<Regex> {
+        let span = Span::from(&pair);
         let mut inner = pair.into_inner();
 
         let pattern = inner
             .next()
-            .ok_or(e(R::regex_inner))?
+            .ok_or(e(R::regex_inner, span))?
             .as_str()
             .replace("\\/", "/");
 
@@ -509,95 +869,143 @@ impl<'a> Parser<'a> {
             })
             .unwrap_or_default();
 
-        RegexBuilder::new(&pattern)
+        #[allow(clippy::trivial_regex)]
+        let regex = RegexBuilder::new(&pattern)
             .case_insensitive(i)
             .multi_line(m)
             .ignore_whitespace(x)
             .build()
-            .map_err(|err| Error::from(err).into())
+            .map_err(|err| {
+                let error = err
+                    .to_string()
+                    .split("error: ")
+                    .last()
+                    .unwrap_or("unknown error")
+                    .to_owned();
+
+                // Record error diagnostic for invalid regex.
+                self.diagnostics.push(
+                    Diagnostic::error("regex parsing unsuccessful")
+                        .with_primary("invalid regex", span)
+                        .with_primary(format!("error: {}", error), span),
+                )
+            })
+            .unwrap_or_else(|_| Regex::new("").unwrap());
+
+        Ok((span, regex).into())
     }
 
     /// Parse a [`Path`] value, e.g. ".foo.bar"
-    fn path_from_pair(&self, pair: Pair<R>) -> Result<path::Path> {
+    fn path_from_pair(&self, pair: Pair<R>) -> IResult<path::Path> {
+        let span = Span::from(&pair);
+        let mut pairs = pair.into_inner();
+
         // If no segments are provided, it's the root path (e.g. `.`).
-        let path_segments = match pair.into_inner().next() {
+        let path_segments = match pairs.next() {
             Some(path_segments) => path_segments,
-            None => return Ok(path::Path::root()),
+            None => return Ok((span, path::Path::root()).into()),
         };
 
         let segments = match path_segments.as_rule() {
             R::path_segments => self.path_segments_from_pair(path_segments)?,
-            _ => return Err(e(R::path)),
+            _ => return Err(e(R::path, &path_segments)),
         };
 
-        Ok(path::Path::new_unchecked(segments))
+        Ok((span, path::Path::new_unchecked(segments.into_inner())).into())
     }
 
-    fn path_segments_from_pair(&self, pair: Pair<R>) -> Result<Vec<path::Segment>> {
-        pair.into_inner()
+    fn path_segments_from_pair(&self, pair: Pair<R>) -> IResult<Vec<path::Segment>> {
+        let span = Span::from(&pair);
+
+        let segments: Vec<path::Segment> = pair
+            .into_inner()
             .map(|pair| match pair.as_rule() {
-                R::path_index => self.path_index_from_pair(pair),
-                R::path_segment => self.path_segment_from_pair(pair),
-                _ => Err(e(R::path_segments)),
+                R::path_index => self.path_index_from_pair(pair).map(ParsedNode::into_inner),
+                R::path_segment => self
+                    .path_segment_from_pair(pair)
+                    .map(ParsedNode::into_inner),
+                _ => Err(e(R::path_segments, &pair)),
             })
-            .collect::<Result<_>>()
+            .collect::<Result<_, _>>()?;
+
+        Ok((span, segments).into())
     }
 
-    fn path_segment_from_pair(&self, pair: Pair<R>) -> Result<path::Segment> {
-        let segment = pair.into_inner().next().ok_or(e(R::path_segment))?;
+    fn path_segment_from_pair(&self, pair: Pair<R>) -> IResult<path::Segment> {
+        let span = Span::from(&pair);
+        let segment = pair.into_inner().next().ok_or(e(R::path_segment, span))?;
 
         match segment.as_rule() {
             R::path_field => self.path_field_segment_from_pair(segment),
             R::path_coalesce => self.path_coalesce_segment_from_pair(segment),
-            _ => Err(e(R::path_segment)),
+            _ => Err(e(R::path_segment, &segment)),
         }
     }
 
-    fn path_field_segment_from_pair(&self, pair: Pair<R>) -> Result<path::Segment> {
-        self.path_field_from_pair(pair).map(path::Segment::Field)
+    fn path_field_segment_from_pair(&self, pair: Pair<R>) -> IResult<path::Segment> {
+        self.path_field_from_pair(pair).map(|node| {
+            let (span, field) = node.take();
+            (span, path::Segment::Field(field)).into()
+        })
     }
 
-    fn path_coalesce_segment_from_pair(&self, pair: Pair<R>) -> Result<path::Segment> {
+    fn path_coalesce_segment_from_pair(&self, pair: Pair<R>) -> IResult<path::Segment> {
+        let span = Span::from(&pair);
+
         let fields = pair
             .into_inner()
-            .map(|pair| self.path_field_from_pair(pair))
-            .collect::<Result<Vec<_>>>()?;
+            .map(|pair| self.path_field_from_pair(pair).map(ParsedNode::into_inner))
+            .collect::<Result<Vec<_>, _>>()?;
 
-        Ok(path::Segment::Coalesce(fields))
+        Ok((span, path::Segment::Coalesce(fields)).into())
     }
 
-    fn path_field_from_pair(&self, pair: Pair<R>) -> Result<path::Field> {
-        let field = pair.into_inner().next().ok_or(e(Rule::path_field))?;
+    fn path_field_from_pair(&self, pair: Pair<R>) -> IResult<path::Field> {
+        let span = Span::from(&pair);
+        let field = pair.into_inner().next().ok_or(e(Rule::path_field, span))?;
 
         match field.as_rule() {
-            R::string => Ok(path::Field::Quoted(self.string_from_pair(field)?)),
-            R::field => Ok(path::Field::Regular(field.as_str().to_owned())),
-            _ => Err(e(R::path_field)),
+            R::string => Ok((
+                span,
+                path::Field::Quoted(self.string_from_pair(field)?.into_inner()),
+            )
+                .into()),
+            R::field => Ok((span, path::Field::Regular(field.as_str().to_owned())).into()),
+            _ => Err(e(R::path_field, &field)),
         }
     }
 
-    fn path_index_from_pair(&self, pair: Pair<R>) -> Result<path::Segment> {
+    fn path_index_from_pair(&self, pair: Pair<R>) -> IResult<path::Segment> {
+        let span = Span::from(&pair);
         let index = pair
             .into_inner()
             .next()
-            .ok_or(e(R::path_index))?
+            .ok_or(e(R::path_index, span))?
             .as_str()
             .parse::<usize>()
-            .map_err(|_| e(R::path_index_inner))?;
+            .map_err(|_| e(R::path_index_inner, span))?;
 
-        Ok(path::Segment::Index(index))
+        Ok((span, path::Segment::Index(index)).into())
     }
 
     /// Parse a [`Variable`] value, e.g. "$foo"
-    fn variable_from_pair(&self, pair: Pair<R>) -> Result<Variable> {
+    fn variable_from_pair(&self, pair: Pair<R>) -> IResult<Variable> {
+        let span = Span::from(&pair);
         let mut inner = pair.into_inner();
 
-        let ident = inner.next().ok_or(e(R::variable))?.as_str().to_owned();
+        let ident = inner
+            .next()
+            .ok_or(e(R::variable, span))?
+            .as_str()
+            .to_owned();
+
         let segments = inner.try_fold(vec![], |mut segments, pair| {
             match pair.as_rule() {
-                R::path_index => segments.push(self.path_index_from_pair(pair)?),
-                R::path_segments => segments.append(&mut self.path_segments_from_pair(pair)?),
-                _ => return Err(e(R::variable)),
+                R::path_index => segments.push(self.path_index_from_pair(pair)?.into_inner()),
+                R::path_segments => {
+                    segments.append(&mut self.path_segments_from_pair(pair)?.into_inner())
+                }
+                _ => return Err(e(R::variable, &pair)),
             };
 
             Ok(segments)
@@ -611,15 +1019,18 @@ impl<'a> Parser<'a> {
             }
         };
 
-        Ok(Variable::new(ident, expr))
+        Ok((span, Variable::new(ident, expr)).into())
     }
 
-    fn string_from_pair(&self, pair: Pair<R>) -> Result<String> {
-        let string = pair.into_inner().next().ok_or(e(R::string))?;
+    fn string_from_pair(&self, pair: Pair<R>) -> IResult<String> {
+        let span = Span::from(&pair);
+        let string = pair.into_inner().next().ok_or(e(R::string, span))?;
         self.escaped_string_from_pair(string)
     }
 
-    fn escaped_string_from_pair(&self, pair: Pair<R>) -> Result<String> {
+    fn escaped_string_from_pair(&self, pair: Pair<R>) -> IResult<String> {
+        let span = Span::from(&pair);
+
         // This is only executed once per string at parse time, and so I'm not
         // losing sleep over the reallocation. However, if we want to mutate the
         // underlying string then we can take some inspiration from:
@@ -637,7 +1048,7 @@ impl<'a> Parser<'a> {
                     'n' => escaped_chars.push('\n'),
                     't' => escaped_chars.push('\t'),
                     '"' => escaped_chars.push('"'),
-                    _ => return Err(e(Rule::char)),
+                    _ => return Err(e(Rule::char, &pair)),
                 }
                 is_escaped = false;
             } else if c == '\\' {
@@ -647,7 +1058,23 @@ impl<'a> Parser<'a> {
             }
         }
 
-        Ok(escaped_chars.into_iter().collect())
+        Ok((span, escaped_chars.into_iter().collect::<String>()).into())
+    }
+
+    /// Allows you to check if a result passed. If it did, the compiler starts
+    /// tracking new changes, if it didn't, the existing state is overwritten
+    /// with the previously recorded changes (if any).
+    fn try_or_noop<T, E>(&mut self, value: Result<T, E>, span: Span) -> Result<T, IResult<Expr>> {
+        match value {
+            Ok(value) => {
+                self.compiler_state.track_changes();
+                Ok(value)
+            }
+            Err(_) => {
+                self.compiler_state.revert_changes();
+                Err(Ok((span, Noop).into()))
+            }
+        }
     }
 
     // The operations are defined in reverse order, meaning boolean expressions are
@@ -682,15 +1109,16 @@ impl<'a> Parser<'a> {
     }
 }
 
+// -----------------------------------------------------------------------------
+
 #[inline]
-fn e(rule: R) -> E {
-    E::Rule(rule)
+fn e(rule: R, span: impl Into<Span>) -> ParserBug {
+    ParserBug(span.into(), rule)
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::RemapError;
 
     #[test]
     fn rule_root_path() {
@@ -720,30 +1148,36 @@ mod tests {
                 vec![],
                 Ok(vec![Path::new(path::Path::new_unchecked(vec![])).into()]),
             ),
-            ("..", vec![" 1:2\n", "= expected path segment"], Ok(vec![])),
-            (". bar", vec![" 1:3\n", "= expected operator"], Ok(vec![])),
-            (
-                r#". "bar""#,
-                vec![" 1:2\n", "= expected path segment"], // TODO: improve error message
-                Ok(vec![]),
-            ),
+            // TODO: move to `remap-tests`
+            // ("..", vec![" 1:2\n", "= expected path segment"], Ok(vec![])),
+            // (". bar", vec![" 1:3\n", "= expected operator"], Ok(vec![])),
+            // (
+            //     r#". "bar""#,
+            //     vec![" 1:2\n", "= expected path segment"], // TODO: improve error message
+            //     Ok(vec![]),
+            // ),
         ];
 
         validate_rule(cases);
     }
 
     #[allow(clippy::type_complexity)]
-    fn validate_rule(cases: Vec<(&str, Vec<&str>, Result<Vec<Expr>>)>) {
+    fn validate_rule(cases: Vec<(&str, Vec<&str>, Result<Vec<Expr>, ()>)>) {
         for (mut i, (source, compile_check, run_check)) in cases.into_iter().enumerate() {
             let compile_check: Vec<&str> = compile_check;
             i += 1;
 
-            let mut parser = Parser::new(&[], true);
-            let pairs = parser.program_from_str(source).map_err(RemapError::from);
+            let mut state = state::Compiler::default();
+            let parser = Parser::new(&[], &mut state, true);
+            let pairs = parser
+                .program_from_str(source)
+                .map_err(|err| diagnostic::Formatter::new(source, err).to_string());
 
             match pairs {
-                Ok(got) => {
+                Ok((got, _)) => {
                     if compile_check.is_empty() {
+                        let got = got.into_iter().map(|e| e.expr).collect();
+
                         assert_eq!(Ok(got), run_check, "test case: {}", i)
                     } else {
                         for exp in compile_check {
@@ -761,7 +1195,7 @@ mod tests {
                 Err(err) if !compile_check.is_empty() => {
                     for exp in compile_check {
                         assert!(
-                            err.to_string().contains(exp),
+                            err.contains(exp),
                             "expected: {}\nwith source: {}\nfull error message: {}\n test case {}",
                             exp,
                             source,
@@ -775,177 +1209,178 @@ mod tests {
         }
     }
 
-    #[test]
-    fn check_parser_errors() {
-        let cases = vec![
-            (
-                ".foo bar",
-                vec![
-                    " 1:6\n",
-                    "= expected operator",
-                ],
-            ),
-            (
-                ".=",
-                vec![
-                    " 1:3\n",
-                    "= expected assignment, if-statement, query, or block",
-                ],
-            ),
-            (
-                ".foo = !",
-                vec![
-                    " 1:9\n",
-                    "= expected value, variable, path, group or function call, value, variable, path, group, !",
-                ],
-            ),
-            (
-                r#".foo.bar = "baz" and this"#,
-                vec![
-                    " 1:18\n",
-                    "= expected operator",
-                ],
-            ),
-            (r#".foo.bar = "baz" +"#, vec![" 1:19", "= expected query"]),
-            (
-                ".foo.bar = .foo.(bar |)",
-                vec![" 1:23\n", "= expected path field"],
-            ),
-            (
-                r#"if .foo > 0 { .foo = "bar" } else"#,
-                vec![" 1:34\n", "= expected block"],
-            ),
-            (
-                "if .foo { }",
-                vec![
-                    " 1:11\n",
-                    "= expected assignment, if-statement, query, or block",
-                ],
-            ),
-            (
-                "if { del(.foo) } else { del(.bar) }",
-                vec![" 1:6\n", "= expected string"],
-            ),
-            (
-                "if .foo > .bar { del(.foo) } else { .bar = .baz",
-                // This message isn't great, ideally I'd like "expected closing bracket"
-                vec![
-                    " 1:48\n",
-                    "= expected operator or path index",
-                ],
-            ),
-            ("only_fields(.foo,)", vec![" 1:18\n", "= expected argument or path"]),
-            ("only_fields(,)", vec![" 1:13\n", "= expected argument"]),
-            (
-                // Due to the explicit list of allowed escape chars our grammar
-                // doesn't actually recognize this as a string literal.
-                r#".foo = "invalid escape \k sequence""#,
-                vec![
-                    " 1:8\n",
-                    "= expected assignment, if-statement, query, or block",
-                ],
-            ),
-            (
-                // Same here as above.
-                r#".foo."invalid \k escape".sequence = "foo""#,
-                vec![" 1:6\n", "= expected path segment"],
-            ),
-            (
-                // Regexes can't be parsed as part of a path
-                r#".foo = split(.foo, ./[aa]/)"#,
-                vec![
-                    " 1:27\n",
-                    "= expected query",
-                ],
-            ),
-            (
-                // we cannot assign a regular expression to a field.
-                r#".foo = /ab/i"#,
-                vec!["remap error: parser error: cannot assign regex to object"],
-            ),
-            (
-                // we cannot assign an array containing a regular expression to a field.
-                r#".foo = ["ab", /ab/i]"#,
-                vec!["remap error: parser error: cannot assign regex to object"],
-            ),
-            (
-                // We cannot assign to a regular expression.
-                r#"/ab/ = .foo"#,
-                vec![
-                    " 1:6\n",
-                    "= expected operator",
-                ],
-            ),
-            (
-                r#"/ab/"#,
-                vec!["remap error: parser error: cannot return regex from program"],
-            ),
-            (
-                r#"foo = /ab/"#,
-                vec!["remap error: parser error: cannot return regex from program"],
-            ),
-            (
-                r#"[/ab/]"#,
-                vec!["remap error: parser error: cannot return regex from program"],
-            ),
-            (
-                r#"
-                    foo = /ab/
-                    [foo]
-                "#,
-                vec!["remap error: parser error: cannot return regex from program"],
-            ),
-            (
-                r#"
-                    foo = [/ab/]
-                    foo
-                "#,
-                vec!["remap error: parser error: cannot return regex from program"],
-            ),
-            ("foo bar", vec![" 1:5\n", "= expected operator"]),
-            ("[true] [false]", vec![" 1:8\n", "= expected operator"]),
-
-            // reserved keywords
-            ("if = true", vec![" 1:4\n", "= expected query"]),
-            ("else = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
-            ("for = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
-            ("while = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
-            ("loop = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
-            ("abort = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
-            ("break = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
-            ("continue = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
-            ("return = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
-            ("as = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
-            ("type = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
-            ("let = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
-            ("until = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
-            ("then = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
-            ("impl = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
-            ("in = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
-            ("self = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
-            ("this = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
-            ("use = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
-            ("std = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
-        ];
-
-        for (source, exp_expressions) in cases {
-            let mut parser = Parser::new(&[], false);
-            let err = parser
-                .program_from_str(source)
-                .err()
-                .map(RemapError::from)
-                .unwrap()
-                .to_string();
-
-            for exp in exp_expressions {
-                assert!(
-                    err.contains(exp),
-                    "expected: {}\nwith source: {}\nfull error message: {}",
-                    exp,
-                    source,
-                    err
-                );
-            }
-        }
-    }
+    // TODO: move to `remap-tests`
+    // #[test]
+    // fn check_parser_errors() {
+    //     let cases = vec![
+    //         (
+    //             ".foo bar",
+    //             vec![
+    //                 " 1:6\n",
+    //                 "= expected operator",
+    //             ],
+    //         ),
+    //         (
+    //             ".=",
+    //             vec![
+    //                 " 1:3\n",
+    //                 "= expected assignment, if-statement, query, or block",
+    //             ],
+    //         ),
+    //         (
+    //             ".foo = !",
+    //             vec![
+    //                 " 1:9\n",
+    //                 "= expected value, variable, path, group or function call, value, variable, path, group, !",
+    //             ],
+    //         ),
+    //         (
+    //             r#".foo.bar = "baz" and this"#,
+    //             vec![
+    //                 " 1:18\n",
+    //                 "= expected operator",
+    //             ],
+    //         ),
+    //         (r#".foo.bar = "baz" +"#, vec![" 1:19", "= expected query"]),
+    //         (
+    //             ".foo.bar = .foo.(bar |)",
+    //             vec![" 1:23\n", "= expected path field"],
+    //         ),
+    //         (
+    //             r#"if .foo > 0 { .foo = "bar" } else"#,
+    //             vec![" 1:34\n", "= expected block"],
+    //         ),
+    //         (
+    //             "if .foo { }",
+    //             vec![
+    //                 " 1:11\n",
+    //                 "= expected assignment, if-statement, query, or block",
+    //             ],
+    //         ),
+    //         (
+    //             "if { del(.foo) } else { del(.bar) }",
+    //             vec![" 1:6\n", "= expected string"],
+    //         ),
+    //         (
+    //             "if .foo > .bar { del(.foo) } else { .bar = .baz",
+    //             // This message isn't great, ideally I'd like "expected closing bracket"
+    //             vec![
+    //                 " 1:48\n",
+    //                 "= expected operator or path index",
+    //             ],
+    //         ),
+    //         ("only_fields(.foo,)", vec![" 1:18\n", "= expected argument or path"]),
+    //         ("only_fields(,)", vec![" 1:13\n", "= expected argument"]),
+    //         (
+    //             // Due to the explicit list of allowed escape chars our grammar
+    //             // doesn't actually recognize this as a string literal.
+    //             r#".foo = "invalid escape \k sequence""#,
+    //             vec![
+    //                 " 1:8\n",
+    //                 "= expected assignment, if-statement, query, or block",
+    //             ],
+    //         ),
+    //         (
+    //             // Same here as above.
+    //             r#".foo."invalid \k escape".sequence = "foo""#,
+    //             vec![" 1:6\n", "= expected path segment"],
+    //         ),
+    //         (
+    //             // Regexes can't be parsed as part of a path
+    //             r#".foo = split(.foo, ./[aa]/)"#,
+    //             vec![
+    //                 " 1:27\n",
+    //                 "= expected query",
+    //             ],
+    //         ),
+    //         (
+    //             // we cannot assign a regular expression to a field.
+    //             r#".foo = /ab/i"#,
+    //             vec!["remap error: parser error: cannot assign regex to object"],
+    //         ),
+    //         (
+    //             // we cannot assign an array containing a regular expression to a field.
+    //             r#".foo = ["ab", /ab/i]"#,
+    //             vec!["remap error: parser error: cannot assign regex to object"],
+    //         ),
+    //         (
+    //             // We cannot assign to a regular expression.
+    //             r#"/ab/ = .foo"#,
+    //             vec![
+    //                 " 1:6\n",
+    //                 "= expected operator",
+    //             ],
+    //         ),
+    //         (
+    //             r#"/ab/"#,
+    //             vec!["remap error: parser error: cannot return regex from program"],
+    //         ),
+    //         (
+    //             r#"foo = /ab/"#,
+    //             vec!["remap error: parser error: cannot return regex from program"],
+    //         ),
+    //         (
+    //             r#"[/ab/]"#,
+    //             vec!["remap error: parser error: cannot return regex from program"],
+    //         ),
+    //         (
+    //             r#"
+    //                 foo = /ab/
+    //                 [foo]
+    //             "#,
+    //             vec!["remap error: parser error: cannot return regex from program"],
+    //         ),
+    //         (
+    //             r#"
+    //                 foo = [/ab/]
+    //                 foo
+    //             "#,
+    //             vec!["remap error: parser error: cannot return regex from program"],
+    //         ),
+    //         ("foo bar", vec![" 1:5\n", "= expected operator"]),
+    //         ("[true] [false]", vec![" 1:8\n", "= expected operator"]),
+
+    //         // reserved keywords
+    //         ("if = true", vec![" 1:4\n", "= expected query"]),
+    //         ("else = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
+    //         ("for = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
+    //         ("while = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
+    //         ("loop = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
+    //         ("abort = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
+    //         ("break = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
+    //         ("continue = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
+    //         ("return = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
+    //         ("as = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
+    //         ("type = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
+    //         ("let = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
+    //         ("until = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
+    //         ("then = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
+    //         ("impl = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
+    //         ("in = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
+    //         ("self = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
+    //         ("this = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
+    //         ("use = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
+    //         ("std = true", vec![" 1:1\n", "= expected assignment, if-statement, query, or block"]),
+    //     ];
+
+    //     for (source, exp_expressions) in cases {
+    //         let mut state = state::Compiler::default();
+    //         let parser = Parser::new(&[], &mut state, false);
+    //         let err = parser
+    //             .program_from_str(source)
+    //             .err()
+    //             .map(|err| diagnostic::Formatter::new(source, err).to_string())
+    //             .unwrap();
+
+    //         for exp in exp_expressions {
+    //             assert!(
+    //                 err.contains(exp),
+    //                 "expected: {}\nwith source: {}\nfull error message: {}",
+    //                 exp,
+    //                 source,
+    //                 err
+    //             );
+    //         }
+    //     }
+    // }
 }
diff --git a/lib/remap-lang/src/path.rs b/lib/remap-lang/src/path.rs
index a6f12d5719783..a0624207d04b8 100644
--- a/lib/remap-lang/src/path.rs
+++ b/lib/remap-lang/src/path.rs
@@ -1,4 +1,4 @@
-use crate::{parser::Parser, Error as E};
+use crate::{diagnostic::Formatter, parser::Parser, state};
 use std::fmt;
 use std::str::FromStr;
 
@@ -6,6 +6,9 @@ use std::str::FromStr;
 pub enum Error {
     #[error("unable to create path from alternative string: {0}")]
     Alternative(String),
+
+    #[error("unable to parse path")]
+    Parse(String),
 }
 
 /// Provide easy access to individual [`Segment`]s of a path.
@@ -15,7 +18,7 @@ pub struct Path {
 }
 
 impl FromStr for Path {
-    type Err = E;
+    type Err = Error;
 
     /// Parse a string path into a [`Path`] wrapper with easy access to
     /// individual path [`Segment`]s.
@@ -23,12 +26,19 @@ impl FromStr for Path {
     /// This function fails if the provided path is invalid, as defined by the
     /// parser grammar.
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let mut parser = Parser::default();
+        let mut state = state::Compiler::default();
+        let parser = Parser::new(&[], &mut state, false);
         if s.starts_with('.') {
-            parser.path_from_str(s)
+            parser
+                .path_from_str(s)
+                .map(|(path, _)| path)
+                .map_err(|diagnostics| Error::Parse(Formatter::new(s, diagnostics).to_string()))
         } else {
             let s = format!(".{}", s);
-            parser.path_from_str(&s)
+            parser
+                .path_from_str(&s)
+                .map(|(path, _)| path)
+                .map_err(|diagnostics| Error::Parse(Formatter::new(&s, diagnostics).to_string()))
         }
     }
 }
@@ -138,12 +148,12 @@ impl Path {
     /// path.
     ///
     /// This will be replaced once better path handling lands.
-    pub fn from_alternative_string(path: String) -> Result<Self, E> {
+    pub fn from_alternative_string(path: String) -> Result<Self, Error> {
         let mut segments = vec![];
         let mut chars = path.chars().peekable();
         let mut part = String::new();
 
-        let handle_field = |part: &mut String, segments: &mut Vec<Segment>| -> Result<(), E> {
+        let handle_field = |part: &mut String, segments: &mut Vec<Segment>| -> Result<(), Error> {
             let string = part.replace("\\.", ".");
             let field = Field::from_str(&string)?;
             segments.push(Segment::Field(field));
@@ -154,7 +164,7 @@ impl Path {
         let mut handle_char = |c: char,
                                chars: &mut std::iter::Peekable<std::str::Chars>,
                                part: &mut String|
-         -> Result<(), E> {
+         -> Result<(), Error> {
             match c {
                 '\\' if chars.peek() == Some(&'.') || chars.peek() == Some(&'[') => {
                     part.push(c);
@@ -169,7 +179,7 @@ impl Path {
                         if c == ']' {
                             let index = part
                                 .parse::<usize>()
-                                .map_err(|err| E::Path(Error::Alternative(err.to_string())))?;
+                                .map_err(|err| Error::Alternative(err.to_string()))?;
 
                             segments.push(Segment::Index(index));
                             part.clear();
@@ -273,7 +283,7 @@ impl Field {
 }
 
 impl FromStr for Field {
-    type Err = E;
+    type Err = Error;
 
     /// Parse a string path into a [`Path`] wrapper with easy access to
     /// individual path [`Segment`]s.
@@ -281,7 +291,11 @@ impl FromStr for Field {
     /// This function fails if the provided path is invalid, as defined by the
     /// parser grammar.
     fn from_str(field: &str) -> Result<Self, Self::Err> {
-        Parser::default().path_field_from_str(field)
+        let mut state = state::Compiler::default();
+        Parser::new(&[], &mut state, false)
+            .path_field_from_str(field)
+            .map(|(field, _)| field)
+            .map_err(|diagnostics| Error::Parse(Formatter::new(field, diagnostics).to_string()))
     }
 }
 
diff --git a/lib/remap-lang/src/program.rs b/lib/remap-lang/src/program.rs
index 9f7fc1614e15c..bf86afb5df67c 100644
--- a/lib/remap-lang/src/program.rs
+++ b/lib/remap-lang/src/program.rs
@@ -1,57 +1,8 @@
-use crate::{parser::Parser, value, Error as E, Expr, Expression, Function, RemapError, TypeDef};
-use std::fmt;
-
-#[derive(thiserror::Error, Clone, Debug, PartialEq)]
-pub enum Error {
-    #[error(transparent)]
-    ResolvesTo(#[from] ResolvesToError),
-
-    #[error("expected to be infallible, but is not")]
-    Fallible,
-}
-
-#[derive(thiserror::Error, Clone, Debug, PartialEq)]
-pub struct ResolvesToError(TypeDef, TypeDef);
-
-impl fmt::Display for ResolvesToError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let want = &self.0;
-        let got = &self.1;
-
-        let mut want_str = "".to_owned();
-        let mut got_str = "".to_owned();
-
-        if want.is_fallible() != got.is_fallible() {
-            if want.is_fallible() {
-                want_str.push_str("an error, or ");
-            }
-
-            if got.is_fallible() {
-                got_str.push_str("an error, or ");
-            }
-        }
-
-        want_str.push_str(&format!("{} value", want.kind));
-        got_str.push_str(&format!("{} value", got.kind));
-
-        let want_kinds: Vec<_> = want.kind.into_iter().collect();
-        let got_kinds: Vec<_> = got.kind.into_iter().collect();
-
-        if !want.kind.is_all() && want_kinds.len() > 1 {
-            want_str.push('s');
-        }
-
-        if !got.kind.is_all() && got_kinds.len() > 1 {
-            got_str.push('s');
-        }
-
-        write!(
-            f,
-            "expected to resolve to {}, but instead resolves to {}",
-            want_str, got_str
-        )
-    }
-}
+use crate::{
+    diagnostic::{self, Note},
+    parser::{ParsedExpression, Parser},
+    state, value, Diagnostic, Expression, Function, TypeDef,
+};
 
 /// The constraint applied to the result of a program.
 pub struct TypeConstraint {
@@ -81,24 +32,27 @@ pub struct TypeConstraint {
 /// will be parsed. If parsing fails, an [`Error`] is returned.
 #[derive(Debug, Clone)]
 pub struct Program {
-    pub(crate) expressions: Vec<Expr>,
+    pub(crate) source: String,
+    pub(crate) expressions: Vec<ParsedExpression>,
 }
 
 impl Program {
-    pub fn new(
-        source: &str,
+    pub fn new_with_state(
+        source: String,
         function_definitions: &[Box<dyn Function>],
         constraint: Option<TypeConstraint>,
         allow_regex_return: bool, // TODO: move this into a builder pattern
-    ) -> Result<Self, RemapError> {
-        let mut parser = Parser::new(function_definitions, allow_regex_return);
-        let expressions = parser.program_from_str(source)?;
+        state: &mut state::Compiler,
+    ) -> diagnostic::Result<Self> {
+        let parser = Parser::new(function_definitions, state, allow_regex_return);
+
+        let (expressions, mut diagnostics) = parser.program_from_str(&source)?;
 
         // optional type constraint checking
         if let Some(constraint) = constraint {
             let mut type_defs = expressions
                 .iter()
-                .map(|e| e.type_def(&parser.compiler_state))
+                .map(|e| e.type_def(&state))
                 .collect::<Vec<_>>();
 
             let program_def = type_defs.pop().unwrap_or(TypeDef {
@@ -110,17 +64,59 @@ impl Program {
             if !constraint.type_def.contains(&program_def)
                 && (!program_def.kind.is_all() || !constraint.allow_any)
             {
-                return Err(RemapError::from(E::from(Error::ResolvesTo(
-                    ResolvesToError(constraint.type_def, program_def),
-                ))));
-            }
+                let want = constraint.type_def.kind;
+                let got = program_def.kind;
+
+                let span = expressions.last().map(|e| e.span()).unwrap_or_default();
 
-            if !constraint.type_def.is_fallible() && type_defs.iter().any(TypeDef::is_fallible) {
-                return Err(RemapError::from(E::from(Error::Fallible)));
+                diagnostics.push(
+                    Diagnostic::error("unexpected return value")
+                        .with_primary(format!("got: {}", got), span)
+                        .with_context(format!("expected: {}", want), span),
+                );
             }
         }
 
-        Ok(Self { expressions })
+        expressions
+            .iter()
+            .filter(|e| e.type_def(&state).is_fallible())
+            .for_each(|e| {
+                diagnostics.push(
+                    Diagnostic::error("unhandled error")
+                        .with_primary("expression can result in runtime error", e.span())
+                        .with_context("handle the error case to ensure runtime success", e.span())
+                        .with_note(Note::SeeErrDocs),
+                )
+            });
+
+        let program = Self {
+            source,
+            expressions,
+        };
+
+        diagnostics
+            .into_result()
+            .map(|diagnostics| (program, diagnostics))
+    }
+
+    pub fn new(
+        source: String,
+        function_definitions: &[Box<dyn Function>],
+        constraint: Option<TypeConstraint>,
+        allow_regex_return: bool, // TODO: move this into a builder pattern
+    ) -> diagnostic::Result<Self> {
+        let mut state = state::Compiler::default();
+        Self::new_with_state(
+            source,
+            function_definitions,
+            constraint,
+            allow_regex_return,
+            &mut state,
+        )
+    }
+
+    pub fn expressions(&self) -> &[ParsedExpression] {
+        &self.expressions
     }
 }
 
@@ -128,18 +124,13 @@ impl Program {
 mod tests {
     use super::*;
     use crate::value;
-    use std::error::Error;
 
     #[test]
     fn program_test() {
         use value::Kind;
 
         let cases = vec![
-            (
-                ".foo",
-                None,
-                Ok(()),
-            ),
+            (".foo", None, Ok(())),
             // "any" value is allowed
             (
                 ".foo",
@@ -153,92 +144,89 @@ mod tests {
                 }),
                 Ok(()),
             ),
-            // "any" value is allowed, but resolves to non-allowed kind
-            (
-                "42",
-                Some(TypeConstraint {
-                    type_def: TypeDef {
-                        fallible: false,
-                        kind: Kind::Boolean,
-                        ..Default::default()
-                    },
-                    allow_any: true,
-                }),
-                Err("expected to resolve to boolean value, but instead resolves to integer value"),
-            ),
-            // "any" value is disallowed, and resolves to any
-            (
-                ".foo",
-                Some(TypeConstraint {
-                    type_def: TypeDef {
-                        fallible: true,
-                        kind: Kind::Boolean,
-                        ..Default::default()
-                    },
-                    allow_any: false,
-                }),
-                Err("expected to resolve to boolean value, but instead resolves to any value"),
-            ),
-            // The final expression is infallible, but the first one isn't, so
-            // this isn't allowed.
-            (
-                ".foo\ntrue",
-                Some(TypeConstraint {
-                    type_def: TypeDef {
-                        fallible: false,
-                        ..Default::default()
-                    },
-                    allow_any: false,
-                }),
-                Err("expected to be infallible, but is not"),
-            ),
-            (
-                ".foo",
-                Some(TypeConstraint {
-                    type_def: TypeDef {
-                        fallible: false,
-                        ..Default::default()
-                    },
-                    allow_any: false,
-                }),
-                Err("expected to resolve to any value, but instead resolves to an error, or any value"),
-            ),
-            (
-                ".foo",
-                Some(TypeConstraint {
-                    type_def: TypeDef {
-                        fallible: false,
-                        kind: Kind::Bytes,
-                        ..Default::default()
-                    },
-                    allow_any: false,
-                }),
-                Err("expected to resolve to string value, but instead resolves to an error, or any value"),
-            ),
-            (
-                "false || 2",
-                Some(TypeConstraint {
-                    type_def: TypeDef {
-                        fallible: false,
-                        kind: Kind::Bytes | Kind::Float,
-                        ..Default::default()
-                    },
-                    allow_any: false,
-                }),
-                Err("expected to resolve to string or float values, but instead resolves to integer or boolean values"),
-            ),
+            // TODO: move to `remap-tests`
+            // // "any" value is allowed, but resolves to non-allowed kind
+            // (
+            //     "42",
+            //     Some(TypeConstraint {
+            //         type_def: TypeDef {
+            //             fallible: false,
+            //             kind: Kind::Boolean,
+            //             ..Default::default()
+            //         },
+            //         allow_any: true,
+            //     }),
+            //     Err("expected to resolve to boolean value, but instead resolves to integer value"),
+            // ),
+            // // "any" value is disallowed, and resolves to any
+            // (
+            //     ".foo",
+            //     Some(TypeConstraint {
+            //         type_def: TypeDef {
+            //             fallible: true,
+            //             kind: Kind::Boolean,
+            //             ..Default::default()
+            //         },
+            //         allow_any: false,
+            //     }),
+            //     Err("expected to resolve to boolean value, but instead resolves to any value"),
+            // ),
+            // // The final expression is infallible, but the first one isn't, so
+            // // this isn't allowed.
+            // (
+            //     ".foo\ntrue",
+            //     Some(TypeConstraint {
+            //         type_def: TypeDef {
+            //             fallible: false,
+            //             ..Default::default()
+            //         },
+            //         allow_any: false,
+            //     }),
+            //     Err("expected to be infallible, but is not"),
+            // ),
+            // (
+            //     ".foo",
+            //     Some(TypeConstraint {
+            //         type_def: TypeDef {
+            //             fallible: false,
+            //             ..Default::default()
+            //         },
+            //         allow_any: false,
+            //     }),
+            //     Err("expected to resolve to any value, but instead resolves to an error, or any value"),
+            // ),
+            // (
+            //     ".foo",
+            //     Some(TypeConstraint {
+            //         type_def: TypeDef {
+            //             fallible: false,
+            //             kind: Kind::Bytes,
+            //             ..Default::default()
+            //         },
+            //         allow_any: false,
+            //     }),
+            //     Err("expected to resolve to string value, but instead resolves to an error, or any value"),
+            // ),
+            // (
+            //     "false || 2",
+            //     Some(TypeConstraint {
+            //         type_def: TypeDef {
+            //             fallible: false,
+            //             kind: Kind::Bytes | Kind::Float,
+            //             ..Default::default()
+            //         },
+            //         allow_any: false,
+            //     }),
+            //     Err("expected to resolve to string or float values, but instead resolves to integer or boolean values"),
+            // ),
         ];
 
         for (source, constraint, expect) in cases {
-            let program = Program::new(source, &[], constraint, false)
+            let program = Program::new(source.to_owned(), &[], constraint, false)
                 .map(|_| ())
-                .map_err(|e| {
-                    e.source()
-                        .and_then(|e| e.source().map(|e| e.to_string()))
-                        .unwrap()
-                });
+                .map_err(|err| diagnostic::Formatter::new(source, err).to_string());
 
-            assert_eq!(program, expect.map_err(ToOwned::to_owned));
+            assert_eq!(program, expect);
         }
     }
 }
diff --git a/lib/remap-lang/src/runtime.rs b/lib/remap-lang/src/runtime.rs
index aab36e352c640..267494b85b029 100644
--- a/lib/remap-lang/src/runtime.rs
+++ b/lib/remap-lang/src/runtime.rs
@@ -1,10 +1,29 @@
-use crate::{state, Expression, Object, Program, RemapError, Value};
+use crate::{state, Expression, Object, Program, Value};
+use std::{error::Error, fmt};
+
+pub type RuntimeResult = Result<Value, Abort>;
 
 #[derive(Debug, Default)]
 pub struct Runtime {
     state: state::Program,
 }
 
+/// The error raised if the runtime is aborted.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Abort(String);
+
+impl fmt::Display for Abort {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(&self.0)
+    }
+}
+
+impl Error for Abort {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        None
+    }
+}
+
 impl Runtime {
     pub fn new(state: state::Program) -> Self {
         Self { state }
@@ -12,16 +31,15 @@ impl Runtime {
 
     /// Given the provided [`Object`], run the provided [`Program`] to
     /// completion.
-    pub fn execute(
-        &mut self,
-        object: &mut impl Object,
-        program: &Program,
-    ) -> Result<Value, RemapError> {
+    pub fn run<'a>(&mut self, object: &mut impl Object, program: &'a Program) -> RuntimeResult {
         let mut values = program
             .expressions
             .iter()
-            .map(|expression| expression.execute(&mut self.state, object))
-            .collect::<crate::Result<Vec<Value>>>()?;
+            .map(|expr| {
+                expr.execute(&mut self.state, object)
+                    .map_err(|err| Abort(err.to_string()))
+            })
+            .collect::<Result<Vec<_>, _>>()?;
 
         Ok(values.pop().unwrap_or(Value::Null))
     }
diff --git a/lib/remap-lang/src/state.rs b/lib/remap-lang/src/state.rs
index 62b30725cced8..571be206b540a 100644
--- a/lib/remap-lang/src/state.rs
+++ b/lib/remap-lang/src/state.rs
@@ -37,6 +37,18 @@ pub struct Compiler {
     /// going to always return `Any` for coalesced paths. Either way, this is a
     /// known bug that we need to fix soon.
     path_query_types: HashMap<Path, TypeDef>,
+
+    /// On request, the compiler can store its state in this field, which can
+    /// later be used to revert the compiler state to the previously stored
+    /// state.
+    ///
+    /// This is used by the parser to try and parse part of an expression, but
+    /// back out of it if only part of the expression could be parsed. We still
+    /// want the parser to continue parsing, and so it can swap the failed
+    /// expression with a "no-op" one, but has to have a way for the compiler to
+    /// forget any state it started tracking while parsing the old, defunct
+    /// expression.
+    track_changes: Option<Box<Self>>,
 }
 
 impl Compiler {
@@ -55,4 +67,21 @@ impl Compiler {
     pub fn path_query_types_mut(&mut self) -> &mut HashMap<Path, TypeDef> {
         &mut self.path_query_types
     }
+
+    pub fn track_changes(&mut self) {
+        let variable_types = self.variable_types.clone();
+        let path_query_types = self.path_query_types.clone();
+
+        self.track_changes = Some(Box::new(Self {
+            variable_types,
+            path_query_types,
+            track_changes: None,
+        }));
+    }
+
+    pub fn revert_changes(&mut self) {
+        if let Some(state) = self.track_changes.take() {
+            *self = *state;
+        }
+    }
 }
diff --git a/lib/remap-lang/src/value.rs b/lib/remap-lang/src/value.rs
index fac595da86d6b..2938665f03d82 100644
--- a/lib/remap-lang/src/value.rs
+++ b/lib/remap-lang/src/value.rs
@@ -16,6 +16,7 @@ use std::str::FromStr;
 pub use kind::Kind;
 
 #[derive(Debug, Clone)]
+#[allow(clippy::large_enum_variant)] // TODO: investigate
 pub enum Value {
     Bytes(Bytes),
     Integer(i64),
diff --git a/lib/remap-tests/src/main.rs b/lib/remap-tests/src/main.rs
index c7c04b1cd424b..0c9ed7ba80d58 100644
--- a/lib/remap-tests/src/main.rs
+++ b/lib/remap-tests/src/main.rs
@@ -1,16 +1,21 @@
 use ansi_term::Colour;
-use remap::{prelude::*, Program, Runtime};
+use remap::{diagnostic::Formatter, prelude::*, Program, Runtime};
 use std::fs;
 use std::path::PathBuf;
 
 fn main() {
+    let verbose = std::env::args()
+        .nth(1)
+        .map(|s| s == "--verbose")
+        .unwrap_or_default();
+
     let mut failed_count = 0;
     let tests = fs::read_dir("tests").expect("dir exists");
 
     for file in tests {
         let mut test = Test::new(file.expect("file").path());
 
-        print!("{:.<30}", test.name);
+        print!("{:.<60}", test.name);
 
         if test.skip {
             println!("{}", Colour::Yellow.bold().paint("SKIPPED"));
@@ -18,12 +23,13 @@ fn main() {
 
         let state = state::Program::default();
         let mut runtime = Runtime::new(state);
-        let program = Program::new(&test.source, &remap_functions::all(), None, true);
+        let program = Program::new(test.source.clone(), &remap_functions::all(), None, true);
         let want = test.result.to_string();
 
         match program {
-            Ok(program) => {
-                let result = runtime.execute(&mut test.object, &program);
+            Ok((program, diagnostics)) => {
+                let mut formatter = Formatter::new(&test.source, diagnostics);
+                let result = runtime.run(&mut test.object, &program);
 
                 match result {
                     Ok(value) => {
@@ -35,34 +41,55 @@ fn main() {
                             println!("{} (expectation)", Colour::Red.bold().paint("FAILED"));
 
                             let diff =
-                                prettydiff::diff_chars(&got, &want).set_highlight_whitespace(true);
+                                prettydiff::diff_chars(&want, &got).set_highlight_whitespace(true);
                             println!("  {}", diff);
 
                             failed_count += 1;
                         }
+
+                        if verbose {
+                            formatter.enable_colors(true);
+                            println!("{}", formatter);
+                            println!("{}", value);
+                        }
                     }
                     Err(err) => {
-                        let got = err.to_string();
+                        let got = err.to_string().trim().to_owned();
+                        let want = want.trim().to_owned();
+
                         if got == want {
                             println!("{}", Colour::Green.bold().paint("OK"));
                         } else {
                             println!("{} (runtime)", Colour::Red.bold().paint("FAILED"));
-                            println!("{}", err);
+
+                            let diff = prettydiff::diff_lines(&want, &got);
+                            println!("{}", diff);
+                        }
+
+                        if verbose {
+                            println!("{:#}", err);
                         }
                     }
                 }
             }
-            Err(err) => {
-                let got = err.to_string().trim().to_owned();
+            Err(diagnostics) => {
+                let mut formatter = Formatter::new(&test.source, diagnostics);
+                let got = formatter.to_string().trim().to_owned();
                 let want = want.trim().to_owned();
+
                 if got == want {
                     println!("{}", Colour::Green.bold().paint("OK"));
                 } else {
                     println!("{} (compilation)", Colour::Red.bold().paint("FAILED"));
 
-                    let diff = prettydiff::diff_chars(&got, &want).set_highlight_whitespace(true);
+                    let diff = prettydiff::diff_lines(&want, &got);
                     println!("{}", diff);
                 }
+
+                if verbose {
+                    formatter.enable_colors(true);
+                    println!("{:#}", formatter);
+                }
             }
         }
     }
diff --git a/lib/remap-tests/tests/assignment_fallible_for_infallible_expression.vrl b/lib/remap-tests/tests/assignment_fallible_for_infallible_expression.vrl
new file mode 100644
index 0000000000000..e5eb70ea9c73b
--- /dev/null
+++ b/lib/remap-tests/tests/assignment_fallible_for_infallible_expression.vrl
@@ -0,0 +1,15 @@
+# object: { "bar": "bar" }
+# result:
+#
+# error: unneeded error assignment
+#   ┌─ :2:1
+#   │
+# 2 │ ok, err = 5;
+#   │ ^^^^^^^   - because this expression cannot fail
+#   │ │          
+#   │ this error assignment is unneeded
+#   │
+#   = hint: assign to "ok", without assigning to "err"
+#   = see language documentation at: https://vector.dev/docs/reference/vrl/
+
+ok, err = 5;
diff --git a/lib/remap-tests/tests/assignment_variable_with_path.vrl b/lib/remap-tests/tests/assignment_variable_with_path.vrl
new file mode 100644
index 0000000000000..54f764320b9a1
--- /dev/null
+++ b/lib/remap-tests/tests/assignment_variable_with_path.vrl
@@ -0,0 +1,14 @@
+# object: { "bar": "bar" }
+# result: 
+#
+# error: path-based variable assignment
+#   ┌─ :2:4
+#   │
+# 2 │ foo.bar = "baz"
+#   │ ---^^^^ assignment to variable path currently unsupported
+#   │ │   
+#   │ assign to "foo" instead
+#   │
+#   = see language documentation at: https://vector.dev/docs/reference/vrl/
+
+foo.bar = "baz"
diff --git a/lib/remap-tests/tests/fallible_root_expression.vrl b/lib/remap-tests/tests/fallible_root_expression.vrl
new file mode 100644
index 0000000000000..70fbb79380ad8
--- /dev/null
+++ b/lib/remap-tests/tests/fallible_root_expression.vrl
@@ -0,0 +1,16 @@
+# object: { "bar": "bar" }
+# result:
+#
+# error: unhandled error
+#   ┌─ :2:1
+#   │
+# 2 │ parse_json("true")
+#   │ ^^^^^^^^^^^^^^^^^^
+#   │ │
+#   │ expression can result in runtime error
+#   │ handle the error case to ensure runtime success
+#   │
+#   = see error handling documentation at: https://vector.dev/docs/reference/vrl/
+#   = see language documentation at: https://vector.dev/docs/reference/vrl/
+
+parse_json("true")
diff --git a/lib/remap-tests/tests/function_call_abort_infallible.vrl b/lib/remap-tests/tests/function_call_abort_infallible.vrl
new file mode 100644
index 0000000000000..2b3d7f62ea7ae
--- /dev/null
+++ b/lib/remap-tests/tests/function_call_abort_infallible.vrl
@@ -0,0 +1,15 @@
+# object: { "bar": "bar" }
+# result:
+#
+# error: cannot abort function that never fails
+#   ┌─ :2:1
+#   │
+# 2 │ now!()
+#   │ ^^^- remove this abort-instruction
+#   │ │   
+#   │ this function cannot fail
+#   │
+#   = see error handling documentation at: https://vector.dev/docs/reference/vrl/
+#   = see language documentation at: https://vector.dev/docs/reference/vrl/
+
+now!()
diff --git a/lib/remap-tests/tests/function_call_internal_error.vrl b/lib/remap-tests/tests/function_call_internal_error.vrl
new file mode 100644
index 0000000000000..1de287f94bb42
--- /dev/null
+++ b/lib/remap-tests/tests/function_call_internal_error.vrl
@@ -0,0 +1,16 @@
+# object: { "bar": "bar" }
+# result:
+#
+# error: program aborted
+#   ┌─ :2:1
+#   │
+# 2 │ parse_json!("{ INVALID }")
+#   │ ^^^^^^^^^^^^^^^^^^^^^^^^^^
+#   │ │
+#   │ function call error
+#   │ unable to parse json: key must be a string at line 1 column 3
+#   │
+#   = see function documentation at: https://master.vector.dev/docs/reference/remap/#parse_json
+#   = see language documentation at: https://vector.dev/docs/reference/vrl/
+
+parse_json!("{ INVALID }")
diff --git a/lib/remap-tests/tests/function_call_invalid_argument_type.vrl b/lib/remap-tests/tests/function_call_invalid_argument_type.vrl
new file mode 100644
index 0000000000000..a4d2419c79580
--- /dev/null
+++ b/lib/remap-tests/tests/function_call_invalid_argument_type.vrl
@@ -0,0 +1,16 @@
+# object: { "bar": "bar" }
+# result: 
+#
+# error: program aborted
+#   ┌─ :2:1
+#   │
+# 2 │ to_string!([])
+#   │ ^^^^^^^^^^^^^^
+#   │ │
+#   │ function call error
+#   │ unable to convert value to string
+#   │
+#   = see function documentation at: https://master.vector.dev/docs/reference/remap/#to_string
+#   = see language documentation at: https://vector.dev/docs/reference/vrl/
+
+to_string!([])
diff --git a/lib/remap-tests/tests/function_call_missing_argument.vrl b/lib/remap-tests/tests/function_call_missing_argument.vrl
new file mode 100644
index 0000000000000..70a2657019924
--- /dev/null
+++ b/lib/remap-tests/tests/function_call_missing_argument.vrl
@@ -0,0 +1,12 @@
+# object: { "bar": "bar" }
+# result: 
+#
+# error: function argument missing
+#   ┌─ :2:1
+#   │
+# 2 │ to_string()
+#   │ ^^^^^^^^^^^ required argument missing: value
+#   │
+#   = see language documentation at: https://vector.dev/docs/reference/vrl/
+
+to_string()
diff --git a/lib/remap-tests/tests/function_call_undefined.vrl b/lib/remap-tests/tests/function_call_undefined.vrl
new file mode 100644
index 0000000000000..48b4ab3ca9b59
--- /dev/null
+++ b/lib/remap-tests/tests/function_call_undefined.vrl
@@ -0,0 +1,12 @@
+# object: { "bar": "bar" }
+# result: 
+#
+# error: call to undefined function
+#   ┌─ :2:1
+#   │
+# 2 │ unknown_function(.foo, .bar)
+#   │ ^^^^^^^^^^^^^^^^ undefined function
+#   │
+#   = see language documentation at: https://vector.dev/docs/reference/vrl/
+
+unknown_function(.foo, .bar)
diff --git a/lib/remap-tests/tests/function_call_unknown_keyword.vrl b/lib/remap-tests/tests/function_call_unknown_keyword.vrl
new file mode 100644
index 0000000000000..bad8b872d17bd
--- /dev/null
+++ b/lib/remap-tests/tests/function_call_unknown_keyword.vrl
@@ -0,0 +1,12 @@
+# object: { "bar": "bar" }
+# result: 
+#
+# error: unknown function argument keyword
+#   ┌─ :2:11
+#   │
+# 2 │ to_string(foo: .bar)
+#   │           ^^^^^^^^^ unknown keyword: foo
+#   │
+#   = see language documentation at: https://vector.dev/docs/reference/vrl/
+
+to_string(foo: .bar)
diff --git a/lib/remap-tests/tests/funtion_call_arity_mismatch.vrl b/lib/remap-tests/tests/funtion_call_arity_mismatch.vrl
new file mode 100644
index 0000000000000..897f79d52b768
--- /dev/null
+++ b/lib/remap-tests/tests/funtion_call_arity_mismatch.vrl
@@ -0,0 +1,15 @@
+# object: { "bar": "bar" }
+# result: 
+#
+# error: function argument arity mismatch
+#   ┌─ :2:11
+#   │
+# 2 │ to_string(.foo, .bar)
+#   │           ^^^^^^^^^^
+#   │           │
+#   │           got: 2
+#   │           expected: 1 (at most)
+#   │
+#   = see language documentation at: https://vector.dev/docs/reference/vrl/
+
+to_string(.foo, .bar)
diff --git a/lib/remap-tests/tests/if_statement_non_boolean_condition.vrl b/lib/remap-tests/tests/if_statement_non_boolean_condition.vrl
new file mode 100644
index 0000000000000..3ca1425f6df97
--- /dev/null
+++ b/lib/remap-tests/tests/if_statement_non_boolean_condition.vrl
@@ -0,0 +1,18 @@
+# object: { "bar": "bar" }
+# result: 
+#
+# error: invalid if-condition type
+#   ┌─ :2:4
+#   │
+# 2 │ if "nope" {
+#   │    ^^^^^^
+#   │    │
+#   │    got: string
+#   │    expected: boolean
+#   │
+#   = hint: coerce the value using one of the coercion functions
+#   = see language documentation at: https://vector.dev/docs/reference/vrl/
+
+if "nope" {
+    true
+}
diff --git a/lib/remap-tests/tests/invalid_path.vrl b/lib/remap-tests/tests/invalid_path.vrl
index f31de7adfa9d0..d05fefe458d63 100644
--- a/lib/remap-tests/tests/invalid_path.vrl
+++ b/lib/remap-tests/tests/invalid_path.vrl
@@ -1,11 +1,15 @@
 # object: { "bar": "bar" }
 # result:
 #
-# remap error: parser error:  --> 2:6
-#   |
-# 2 | .foo.␊
-#   |      ^---
-#   |
-#   = expected path segment
+# error: syntax error
+#   ┌─ :2:6
+#   │
+# 2 │ .foo.
+#   │      ^
+#   │      
+#   │      invalid token
+#   │      expected: path segment
+#   │
+#   = see language documentation at: https://vector.dev/docs/reference/vrl/
 
 .foo.
diff --git a/lib/remap-tests/tests/regex_invalid.vrl b/lib/remap-tests/tests/regex_invalid.vrl
new file mode 100644
index 0000000000000..99485c37d17a2
--- /dev/null
+++ b/lib/remap-tests/tests/regex_invalid.vrl
@@ -0,0 +1,16 @@
+# object: { "bar": "bar" }
+# result:
+#
+# error: regex parsing unsuccessful
+#   ┌─ :2:11
+#   │
+# 2 │ invalid = /[/
+#   │           ^^^
+#   │           │
+#   │           invalid regex
+#   │           error: unclosed character class
+#   │
+#   = see language documentation at: https://vector.dev/docs/reference/vrl/
+
+invalid = /[/
+true
diff --git a/scripts/check-style.sh b/scripts/check-style.sh
index 995dc44e06678..a6a43f370f0a7 100755
--- a/scripts/check-style.sh
+++ b/scripts/check-style.sh
@@ -35,6 +35,7 @@ for FILE in $(git ls-files); do
     tests/data*) continue;;
     distribution/kubernetes/*/*.yaml) continue;;
     tests/helm-snapshots/*/snapshot.yaml) continue;;
+    lib/remap-tests/tests/*.vrl) continue;;
   esac
 
   # Skip all directories (usually theis only happens when we have symlinks).
diff --git a/src/conditions/remap.rs b/src/conditions/remap.rs
index c0f477b9306b9..16d8f7b5003c8 100644
--- a/src/conditions/remap.rs
+++ b/src/conditions/remap.rs
@@ -4,7 +4,7 @@ use crate::{
     internal_events::RemapConditionExecutionError,
     Event,
 };
-use remap::{value, Program, RemapError, Runtime, TypeConstraint, TypeDef, Value};
+use remap::{value, Program, Runtime, TypeConstraint, TypeDef, Value};
 use serde::{Deserialize, Serialize};
 
 #[derive(Deserialize, Serialize, Debug, Default, Clone)]
@@ -40,8 +40,12 @@ impl ConditionConfig for RemapConfig {
             .filter(|f| f.identifier() != "only_fields")
             .collect::<Vec<_>>();
 
-        let program = Program::new(&self.source, &functions, Some(constraint), false)
-            .map_err(|e| e.to_string())?;
+        let (program, _) = Program::new(self.source.clone(), &functions, Some(constraint), false)
+            .map_err(|diagnostics| {
+            remap::Formatter::new(&self.source, diagnostics)
+                .colored()
+                .to_string()
+        })?;
 
         Ok(Box::new(Remap { program }))
     }
@@ -55,7 +59,7 @@ pub struct Remap {
 }
 
 impl Remap {
-    fn execute(&self, event: &Event) -> Result<remap::Value, RemapError> {
+    fn run(&self, event: &Event) -> remap::RuntimeResult {
         // TODO(jean): This clone exists until remap-lang has an "immutable"
         // mode.
         //
@@ -69,15 +73,15 @@ impl Remap {
         //
         // see: https://github.com/timberio/vector/issues/4744
         match event {
-            Event::Log(event) => Runtime::default().execute(&mut event.clone(), &self.program),
-            Event::Metric(event) => Runtime::default().execute(&mut event.clone(), &self.program),
+            Event::Log(event) => Runtime::default().run(&mut event.clone(), &self.program),
+            Event::Metric(event) => Runtime::default().run(&mut event.clone(), &self.program),
         }
     }
 }
 
 impl Condition for Remap {
     fn check(&self, event: &Event) -> bool {
-        self.execute(&event)
+        self.run(&event)
             .map(|value| match value {
                 Value::Boolean(boolean) => boolean,
                 _ => unreachable!("boolean type constraint set"),
@@ -90,7 +94,7 @@ impl Condition for Remap {
 
     fn check_with_context(&self, event: &Event) -> Result<(), String> {
         let value = self
-            .execute(event)
+            .run(event)
             .map_err(|err| format!("source execution failed: {:#}", err))?;
 
         match value {
@@ -124,7 +128,7 @@ mod test {
             ),
             (
                 log_event!["foo" => true, "bar" => false],
-                "to_bool(.bar || .foo)",
+                "to_bool(.bar || .foo) ?? false",
                 Ok(()),
                 Ok(()),
             ),
@@ -134,24 +138,25 @@ mod test {
                 Ok(()),
                 Err("source execution resolved to false"),
             ),
-            (
-                log_event![],
-                "null",
-                Err("remap error: program error: expected to resolve to an error, or boolean value, but instead resolves to null value"),
-                Ok(()),
-            ),
-            (
-                log_event!["foo" => "string"],
-                ".foo",
-                Err("remap error: program error: expected to resolve to boolean value, but instead resolves to any value"),
-                Ok(()),
-            ),
-            (
-                log_event![],
-                ".",
-                Err("remap error: program error: expected to resolve to boolean value, but instead resolves to any value"),
-                Ok(()),
-            ),
+            // TODO: enable once we don't emit large diagnostics with colors when no tty is present.
+            // (
+            //     log_event![],
+            //     "null",
+            //     Err("\n\u{1b}[0m\u{1b}[1m\u{1b}[38;5;9merror\u{1b}[0m\u{1b}[1m: unexpected return value\u{1b}[0m\n  \u{1b}[0m\u{1b}[34m┌─\u{1b}[0m :1:1\n  \u{1b}[0m\u{1b}[34m│\u{1b}[0m\n\u{1b}[0m\u{1b}[34m1\u{1b}[0m \u{1b}[0m\u{1b}[34m│\u{1b}[0m \u{1b}[0m\u{1b}[31mnull\u{1b}[0m\n  \u{1b}[0m\u{1b}[34m│\u{1b}[0m \u{1b}[0m\u{1b}[31m^^^^\u{1b}[0m\n  \u{1b}[0m\u{1b}[34m│\u{1b}[0m \u{1b}[0m\u{1b}[31m│\u{1b}[0m\n  \u{1b}[0m\u{1b}[34m│\u{1b}[0m \u{1b}[0m\u{1b}[31mgot: null\u{1b}[0m\n  \u{1b}[0m\u{1b}[34m│\u{1b}[0m \u{1b}[0m\u{1b}[34mexpected: boolean\u{1b}[0m\n  \u{1b}[0m\u{1b}[34m│\u{1b}[0m\n  \u{1b}[0m\u{1b}[34m=\u{1b}[0m see language documentation at: https://vector.dev/docs/reference/vrl/\n\n"),
+            //     Ok(()),
+            // ),
+            // (
+            //     log_event!["foo" => "string"],
+            //     ".foo",
+            //     Err("\n\u{1b}[0m\u{1b}[1m\u{1b}[38;5;9merror\u{1b}[0m\u{1b}[1m: unexpected return value\u{1b}[0m\n  \u{1b}[0m\u{1b}[34m┌─\u{1b}[0m :1:1\n  \u{1b}[0m\u{1b}[34m│\u{1b}[0m\n\u{1b}[0m\u{1b}[34m1\u{1b}[0m \u{1b}[0m\u{1b}[34m│\u{1b}[0m \u{1b}[0m\u{1b}[31m.foo\u{1b}[0m\n  \u{1b}[0m\u{1b}[34m│\u{1b}[0m \u{1b}[0m\u{1b}[31m^^^^\u{1b}[0m\n  \u{1b}[0m\u{1b}[34m│\u{1b}[0m \u{1b}[0m\u{1b}[31m│\u{1b}[0m\n  \u{1b}[0m\u{1b}[34m│\u{1b}[0m \u{1b}[0m\u{1b}[31mgot: any\u{1b}[0m\n  \u{1b}[0m\u{1b}[34m│\u{1b}[0m \u{1b}[0m\u{1b}[34mexpected: boolean\u{1b}[0m\n  \u{1b}[0m\u{1b}[34m│\u{1b}[0m\n  \u{1b}[0m\u{1b}[34m=\u{1b}[0m see language documentation at: https://vector.dev/docs/reference/vrl/\n\n"),
+            //     Ok(()),
+            // ),
+            // (
+            //     log_event![],
+            //     ".",
+            //     Err("n\u{1b}[0m\u{1b}[1m\u{1b}[38;5;9merror\u{1b}[0m\u{1b}[1m: unexpected return value\u{1b}[0m\n  \u{1b}[0m\u{1b}[34m┌─\u{1b}[0m :1:1\n  \u{1b}[0m\u{1b}[34m│\u{1b}[0m\n\u{1b}[0m\u{1b}[34m1\u{1b}[0m \u{1b}[0m\u{1b}[34m│\u{1b}[0m \u{1b}[0m\u{1b}[31m.\u{1b}[0m\n  \u{1b}[0m\u{1b}[34m│\u{1b}[0m \u{1b}[0m\u{1b}[31m^\u{1b}[0m\n  \u{1b}[0m\u{1b}[34m│\u{1b}[0m \u{1b}[0m\u{1b}[31m│\u{1b}[0m\n  \u{1b}[0m\u{1b}[34m│\u{1b}[0m \u{1b}[0m\u{1b}[31mgot: any\u{1b}[0m\n  \u{1b}[0m\u{1b}[34m│\u{1b}[0m \u{1b}[0m\u{1b}[34mexpected: boolean\u{1b}[0m\n  \u{1b}[0m\u{1b}[34m│\u{1b}[0m\n  \u{1b}[0m\u{1b}[34m=\u{1b}[0m see language documentation at: https://vector.dev/docs/reference/vrl/\n\n"),
+            //     Ok(()),
+            // ),
             (
                 Event::Metric(Metric {
                     name: "zork".into(),
@@ -168,17 +173,14 @@ mod test {
                 r#".name == "zork" && .tags.host == "zoobub" && .kind == "incremental""#,
                 Ok(()),
                 Ok(()),
-            )
+            ),
         ];
 
         for (event, source, build, check) in checks {
             let source = source.to_owned();
             let config = RemapConfig { source };
 
-            assert_eq!(
-                config.build().map(|_| ()).map_err(|e| e.to_string()),
-                build.map_err(|e| e.to_string())
-            );
+            assert_eq!(config.build().map(|_| ()).map_err(|e| e.to_string()), build);
 
             if let Ok(cond) = config.build() {
                 assert_eq!(
diff --git a/src/mapping/query/query_value.rs b/src/mapping/query/query_value.rs
index eb53b4cb4c389..42c8ae4b7ce20 100644
--- a/src/mapping/query/query_value.rs
+++ b/src/mapping/query/query_value.rs
@@ -2,6 +2,7 @@ use super::regex::Regex;
 use crate::event::Value;
 
 #[derive(PartialEq, Debug, Clone)]
+#[allow(clippy::large_enum_variant)]
 pub(in crate::mapping) enum QueryValue {
     Value(Value),
 
diff --git a/src/transforms/remap.rs b/src/transforms/remap.rs
index 65411801c8357..d36d40bced700 100644
--- a/src/transforms/remap.rs
+++ b/src/transforms/remap.rs
@@ -49,7 +49,7 @@ pub struct Remap {
 }
 
 impl Remap {
-    pub fn new(config: RemapConfig) -> crate::Result<Remap> {
+    pub fn new(config: RemapConfig) -> crate::Result<Self> {
         let accepts = TypeConstraint {
             allow_any: true,
             type_def: TypeDef {
@@ -59,12 +59,17 @@ impl Remap {
             },
         };
 
-        let program = Program::new(
-            &config.source,
+        let (program, _) = Program::new(
+            config.source.clone(),
             &remap_functions::all(),
             Some(accepts),
             false,
-        )?;
+        )
+        .map_err(|diagnostics| {
+            remap::Formatter::new(&config.source, diagnostics)
+                .colored()
+                .to_string()
+        })?;
 
         Ok(Remap {
             program,
@@ -77,8 +82,8 @@ impl FunctionTransform for Remap {
     fn transform(&mut self, output: &mut Vec<Event>, mut event: Event) {
         let mut runtime = Runtime::default();
         let result = match event {
-            Event::Log(ref mut event) => runtime.execute(event, &self.program),
-            Event::Metric(ref mut event) => runtime.execute(event, &self.program),
+            Event::Log(ref mut event) => runtime.run(event, &self.program),
+            Event::Metric(ref mut event) => runtime.run(event, &self.program),
         };
 
         if let Err(error) = result {
diff --git a/tests/behavior/transforms/coercer.toml b/tests/behavior/transforms/coercer.toml
index 96180edae5d23..af548c73922b1 100644
--- a/tests/behavior/transforms/coercer.toml
+++ b/tests/behavior/transforms/coercer.toml
@@ -29,8 +29,8 @@
         .boolean_field == true && \
         .float_field == 3.1415926535 && \
         .string_field == "-1" && \
-        .timestamp_field == to_timestamp("2020-02-20T12:34:56.123456789Z") && \
-        .timestamp_field_formatted == to_timestamp("2020-02-20T12:34:56Z")
+        .timestamp_field == to_timestamp!("2020-02-20T12:34:56.123456789Z") && \
+        .timestamp_field_formatted == to_timestamp!("2020-02-20T12:34:56Z")
       '''
 
 [transforms.coercer_nested]
diff --git a/tests/behavior/transforms/filter.toml b/tests/behavior/transforms/filter.toml
index ee9ebebb9730c..882154fa1af8a 100644
--- a/tests/behavior/transforms/filter.toml
+++ b/tests/behavior/transforms/filter.toml
@@ -14,8 +14,8 @@
     type = "remap"
     source = '''
       message = if exists(.tags) { .tags.message } else { .message }
-      contains(message, "test filter") && \
-      contains(message, "2")
+      contains!(message, "test filter") && \
+      contains!(message, "2")
     '''
 [transforms.filter_c]
   inputs = ["ignored"]
diff --git a/tests/behavior/transforms/reduce.toml b/tests/behavior/transforms/reduce.toml
index 5864e5287c6fb..de3f001b66515 100644
--- a/tests/behavior/transforms/reduce.toml
+++ b/tests/behavior/transforms/reduce.toml
@@ -378,7 +378,7 @@
     type = "reduce"
     merge_strategies.message = "concat_newline"
     starts_when.type = "remap"
-    starts_when.source = "match(.message, /^\\w.*/)"
+    starts_when.source = "match!(.message, /^\\w.*/)"
 
 [[tests]]
   name = "reduce_ruby_exception"
@@ -437,7 +437,7 @@
     type = "reduce"
     merge_strategies.message = "concat"
     ends_when.type = "remap"
-    ends_when.source = """!ends_with(strip_whitespace(.message), "\\\\")"""
+    ends_when.source = """!ends_with(strip_whitespace!(.message), "\\\\")"""
 
 [[tests]]
   name = "reduce_line_continuation"
@@ -491,7 +491,7 @@
   type = "reduce"
   merge_strategies.message = "concat"
   ends_when.type = "remap"
-  ends_when.source = """ends_with(strip_whitespace(.message), ";")"""
+  ends_when.source = """ends_with(strip_whitespace!(.message), ";")"""
 
 [[tests]]
   name = "reduce_line_termination"
@@ -545,7 +545,7 @@
     type = "reduce"
     merge_strategies.message = "concat"
     starts_when.type = "remap"
-    starts_when.source = "match(.message, /^<\\d\\d> /)"
+    starts_when.source = "match!(.message, /^<\\d\\d> /)"
 
 [[tests]]
   name = "reduce_log_stream"
@@ -599,7 +599,7 @@
     type = "reduce"
     merge_strategies.message = "concat_newline"
     starts_when.type = "remap"
-    starts_when.source = "match(.message, /^\\d{4}-\\d{2}-\\d{2} .+/)"
+    starts_when.source = "match!(.message, /^\\d{4}-\\d{2}-\\d{2} .+/)"
 
 [[tests]]
   name = "reduce_java_exception"
@@ -669,6 +669,6 @@
     [[tests.outputs.conditions]]
       type = "remap"
       source = '''
-        starts_with(.message, "2020-10-19 04:34:15,389") && \
-        ends_with(.message, "\nat java.lang.Thread.run(Thread.java:748) ~[?:1.8.0_181]")
+        starts_with!(.message, "2020-10-19 04:34:15,389") && \
+        ends_with!(.message, "\nat java.lang.Thread.run(Thread.java:748) ~[?:1.8.0_181]")
       '''
diff --git a/tests/behavior/transforms/remap.toml b/tests/behavior/transforms/remap.toml
index 780dd2ec8d198..4a0e7ae732c20 100644
--- a/tests/behavior/transforms/remap.toml
+++ b/tests/behavior/transforms/remap.toml
@@ -51,12 +51,12 @@
   inputs = []
   type = "remap"
   source = """
-    .result_a = .a * .b + .c - .d
-    .result_b = .a * (.b + .c) - .d
-    .result_c = .a + .b * .c / .d
-    .result_d = (.a + .b) * (.c / .d)
-    .result_e = .e / .c
-    .result_f = .e // .c
+    .result_a, err = .a * .b + .c - .d
+    .result_b, err = .a * (.b + .c) - .d
+    .result_c, err = .a + .b * .c / .d
+    .result_d, err = (.a + .b) * (.c / .d)
+    .result_e, err = .e / .c
+    .result_f, err = .e // .c
   """
 [[tests]]
   name = "remap_arithmetic"
@@ -87,29 +87,30 @@
   type = "remap"
   drop_on_err = true
   source = """
-    .a / .b
+    a = 10
+    b = 0
+    .a, err = a / b
   """
 [[tests]]
   name = "remap_arithmetic_error"
-  no_outputs_from = ["remap_arithmetic_error"]
   [tests.input]
     insert_at = "remap_arithmetic_error"
-    type = "log"
-    [tests.input.log_fields]
+    type = "raw"
+    value = ""
+  [[tests.outputs]]
+    extract_from = "remap_arithmetic_error"
+    [[tests.outputs.conditions]]
       type = "remap"
-      source = '''
-        .a = 10 && \
-        .b = 0
-      '''
+      source = ".a == null"
 
 [transforms.remap_boolean_arithmetic]
   inputs = []
   type = "remap"
   source = """
-    .result_a = .a + .b > 9
-    .result_b = .a * .b < 20
-    .result_c = 1 >= .a / .b
-    .result_d = .a + .b > .c + .d
+    .result_a, err = .a + .b > 9
+    .result_b, err = .a * .b < 20
+    .result_c, err = 1 >= .a / .b
+    .result_d, err = .a + .b > .c + .d
   """
 [[tests]]
   name = "remap_boolean_arithmetic"
@@ -136,11 +137,11 @@
   inputs = []
   type = "remap"
   source = """
-    .foo = to_string(.foo)
-    .bar = to_int(.bar)
-    .baz = to_float(.baz)
-    .bev = to_bool(.bev)
-    .a = to_string(to_timestamp(.a))
+    .foo = to_string!(.foo)
+    .bar = to_int!(.bar)
+    .baz = to_float!(.baz)
+    .bev = to_bool!(.bev)
+    .a = to_string(to_timestamp!(.a))
   """
 [[tests]]
   name = "remap_coercion"
@@ -256,12 +257,12 @@
   inputs = []
   type = "remap"
   source = """
-    .a = to_string(.in)
-    .b = to_string(value: .in)
-    .c = to_string(.nope)
-    .d = to_string(value: .nope)
-    .e = to_string(.other)
-    .f = to_string(value: .other)
+    .a = to_string!(.in)
+    .b = to_string!(value: .in)
+    .c = to_string!(.nope)
+    .d = to_string!(value: .nope)
+    .e = to_string!(.other)
+    .f = to_string!(value: .other)
   """
 [[tests]]
   name = "remap_function_arguments"
@@ -288,11 +289,11 @@
   inputs = []
   type = "remap"
   source = """
-    .a = upcase(.a)
-    .b = upcase(.b)
-    .c.c = upcase(.c.c)
+    .a = upcase!(.a)
+    .b = upcase!(.b)
+    .c.c = upcase!(.c.c)
 
-    if upcase(.f) == "F" {
+    if upcase!(.f) == "F" {
       .f = "ff"
     }
   """
@@ -322,8 +323,8 @@
   type = "remap"
   drop_on_err = true
   source = """
-    .a = upcase(.a)
-    .b = upcase(.b)
+    .a = upcase!(.a)
+    .b = upcase!(.b)
   """
 [[tests]]
   name = "remap_function_upcase_error"
@@ -340,11 +341,11 @@
   type = "remap"
   drop_on_err = true
   source = """
-    .a = downcase(.a)
-    .b = downcase(.b)
-    .c.c = downcase(.c.c)
+    .a = downcase!(.a)
+    .b = downcase!(.b)
+    .c.c = downcase!(.c.c)
 
-    if downcase(.f) == "f" {
+    if downcase!(.f) == "f" {
       .f = "FF"
     }
   """
@@ -374,8 +375,8 @@
   type = "remap"
   drop_on_err = true
   source = """
-    .a = downcase(.a)
-    .b = downcase(.b)
+    .a = downcase!(.a)
+    .b = downcase!(.b)
   """
 [[tests]]
   name = "remap_function_downcase_error"
@@ -409,7 +410,7 @@
     [[tests.outputs.conditions]]
       type = "remap"
       source = '''
-        match(.a, /(?i)^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/) && \
+        match!(.a, /(?i)^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/) && \
         .b == "bar"
       '''
 
@@ -417,10 +418,10 @@
   inputs = []
   type = "remap"
   source = """
-    .a = sha1(.a)
+    .a = sha1!(.a)
 
-    if sha1(.b) == "62cdb7020ff920e5aa642c3d4066950dd1f01f4d" {
-      .b = sha1(.a + .b + "baz")
+    if sha1!(.b) == "62cdb7020ff920e5aa642c3d4066950dd1f01f4d" {
+      .b = sha1!(.a + .b + "baz")
     }
   """
 [[tests]]
@@ -445,8 +446,8 @@
   type = "remap"
   drop_on_err = true
   source = """
-    .a = sha1(.a)
-    .b = sha1(.b)
+    .a = sha1!(.a)
+    .b = sha1!(.b)
   """
 [[tests]]
   name = "remap_function_sha1_error"
@@ -462,10 +463,10 @@
   inputs = []
   type = "remap"
   source = """
-    .a = md5(.a)
+    .a = md5!(.a)
 
-    if md5(.b) == "37b51d194a7513e45b56f6524f2d51f2" {
-      .b = md5(.a + .b + "baz")
+    if md5!(.b) == "37b51d194a7513e45b56f6524f2d51f2" {
+      .b = md5!(.a + .b + "baz")
     }
   """
 [[tests]]
@@ -490,8 +491,8 @@
   type = "remap"
   drop_on_err = true
   source = """
-    .a = md5(.a)
-    .b = md5(.b)
+    .a = md5!(.a)
+    .b = md5!(.b)
   """
 [[tests]]
   name = "remap_function_md5_error"
@@ -520,14 +521,14 @@
     [[tests.outputs.conditions]]
       type = "remap"
       source = '''
-        ends_with(to_string(.a), "UTC")
+        ends_with!(to_string(.a), "UTC")
       '''
 
 [transforms.remap_function_format_timestamp]
   inputs = []
   type = "remap"
   source = """
-    .a = format_timestamp(to_timestamp(.foo), format: "%+")
+    .a = format_timestamp!(to_timestamp(.foo), format: "%+")
   """
 [[tests]]
   name = "remap_function_format_timestamp"
@@ -548,13 +549,13 @@
   inputs = []
   type = "remap"
   source = """
-    .a = contains(.foo, substring: .bar)
-    .b = contains(.bar, substring: "bar")
-    .c = contains(.bar, substring: "BAR", case_sensitive = true)
-    .d = contains(.bar, substring: "BAR", case_sensitive = false)
-    .e = contains(.foobar, substring: "oba")
-    .f = contains(.foobar, substring: "OBA", case_sensitive = true)
-    .g = contains(.foobar, substring: "OBA", case_sensitive = false)
+    .a = contains!(.foo, substring: .bar)
+    .b = contains!(.bar, substring: "bar")
+    .c = contains!(.bar, substring: "BAR", case_sensitive = true)
+    .d = contains!(.bar, substring: "BAR", case_sensitive = false)
+    .e = contains!(.foobar, substring: "oba")
+    .f = contains!(.foobar, substring: "OBA", case_sensitive = true)
+    .g = contains!(.foobar, substring: "OBA", case_sensitive = false)
   """
 [[tests]]
   name = "remap_function_contains"
@@ -583,11 +584,11 @@
   inputs = []
   type = "remap"
   source = """
-    .a = starts_with(.foobar, substring: .foo)
-    .b = starts_with(.foobar, substring: "foo")
-    .c = starts_with(.foobar, substring: "bar")
-    .d = starts_with(.foobar, substring: "FOO", case_sensitive: true)
-    .e = starts_with(.foobar, substring: "FOO", case_sensitive: false)
+    .a = starts_with!(.foobar, substring: .foo)
+    .b = starts_with!(.foobar, substring: "foo")
+    .c = starts_with!(.foobar, substring: "bar")
+    .d = starts_with!(.foobar, substring: "FOO", case_sensitive: true)
+    .e = starts_with!(.foobar, substring: "FOO", case_sensitive: false)
   """
 [[tests]]
   name = "remap_function_starts_with"
@@ -613,11 +614,11 @@
   inputs = []
   type = "remap"
   source = """
-    .a = ends_with(.foobar, substring: .bar)
-    .b = ends_with(.foobar, substring: "bar")
-    .c = ends_with(.foobar, substring: "foo")
-    .d = ends_with(.foobar, substring: "BAR", case_sensitive: true)
-    .e = ends_with(.foobar, substring: "BAR", case_sensitive: false)
+    .a = ends_with!(.foobar, substring: .bar)
+    .b = ends_with!(.foobar, substring: "bar")
+    .c = ends_with!(.foobar, substring: "foo")
+    .d = ends_with!(.foobar, substring: "BAR", case_sensitive: true)
+    .e = ends_with!(.foobar, substring: "BAR", case_sensitive: false)
   """
 [[tests]]
   name = "remap_function_ends_with"
@@ -643,10 +644,10 @@
   inputs = []
   type = "remap"
   source = """
-    .a = slice(.foo + .bar, 1)
-    .b = slice(.foo + .bar, 0, 1)
-    .c = slice(.foo + .bar, start: -2)
-    .d = slice(.foo + .bar, start: 1, end: -1)
+    .a = slice!(.foo + .bar, 1)
+    .b = slice!(.foo + .bar, 0, 1)
+    .c = slice!(.foo + .bar, start: -2)
+    .d = slice!(.foo + .bar, start: 1, end: -1)
   """
 [[tests]]
   name = "remap_function_slice"
@@ -671,8 +672,8 @@
   inputs = []
   type = "remap"
   source = '''
-    .a = parse_tokens(.a)
-    .b = parse_tokens(.b)
+    .a = parse_tokens!(.a)
+    .b = parse_tokens!(.b)
   '''
 [[tests]]
   name = "remap_function_parse_tokens"
@@ -700,10 +701,10 @@
   inputs = []
   type = "remap"
   source = """
-    .a = sha2(.a)
+    .a = sha2!(.a)
 
-    if sha2(.b) == "725eb523fe006a6ee0071380bd3b4c57590abd44b88614cd3eddf594e3afe1ac" {
-      .b = sha2(.a + .b + "baz")
+    if sha2!(.b) == "725eb523fe006a6ee0071380bd3b4c57590abd44b88614cd3eddf594e3afe1ac" {
+      .b = sha2!(.a + .b + "baz")
     }
   """
 [[tests]]
@@ -727,10 +728,10 @@
   inputs = []
   type = "remap"
   source = """
-    .a = sha3(.a)
+    .a = sha3!(.a)
 
-    if sha3(.b) == "03457d23880d7847fc3f58780dd58cda7237a7144ac6758e76d45cec0e06ba69440a855e913ef03790c618777f5b0ec25fc34c4b82d7538151745b120b4f8b37" {
-      .b = sha3(.a + .b + "baz")
+    if sha3!(.b) == "03457d23880d7847fc3f58780dd58cda7237a7144ac6758e76d45cec0e06ba69440a855e913ef03790c618777f5b0ec25fc34c4b82d7538151745b120b4f8b37" {
+      .b = sha3!(.a + .b + "baz")
     }
   """
 [[tests]]
@@ -754,8 +755,8 @@
   inputs = []
   type = "remap"
   source = """
-    .a = parse_duration(.a, "ms")
-    .b = parse_duration("100ms", output: .b)
+    .a = parse_duration!(.a, "ms")
+    .b = parse_duration!("100ms", output: .b)
   """
 [[tests]]
   name = "remap_function_parse_duration"
@@ -778,7 +779,7 @@
   inputs = []
   type = "remap"
   source = """
-    .a = format_number(.a, scale: 2, decimal_separator: ",", grouping_separator: ".")
+    .a = format_number!(.a, scale: 2, decimal_separator: ",", grouping_separator: ".")
   """
 [[tests]]
   name = "remap_function_format_number"
@@ -799,7 +800,7 @@
   inputs = []
   type = "remap"
   source = """
-    .parts = parse_url(.url)
+    .parts = parse_url!(.url)
   """
 [[tests]]
   name = "remap_function_parse_url"
@@ -828,9 +829,9 @@
   inputs = []
   type = "remap"
   source = """
-    .a = ceil(.num)
-    .b = ceil(.num, precision: 1)
-    .c = ceil(.num, precision: 2)
+    .a = ceil!(.num)
+    .b = ceil!(.num, precision: 1)
+    .c = ceil!(.num, precision: 2)
   """
 [[tests]]
   name = "remap_function_ceil"
@@ -853,9 +854,9 @@
   inputs = []
   type = "remap"
   source = """
-    .a = floor(.num)
-    .b = floor(.num, precision: 1)
-    .c = floor(.num, precision: 2)
+    .a = floor!(.num)
+    .b = floor!(.num, precision: 1)
+    .c = floor!(.num, precision: 2)
   """
 [[tests]]
   name = "remap_function_floor"
@@ -878,9 +879,9 @@
   inputs = []
   type = "remap"
   source = """
-    .a = round(.num)
-    .b = round(.num, precision: 1)
-    .c = round(.num, precision: 2)
+    .a = round!(.num)
+    .b = round!(.num, precision: 1)
+    .c = round!(.num, precision: 2)
   """
 [[tests]]
   name = "remap_function_round"
@@ -903,7 +904,7 @@
   inputs = []
   type = "remap"
   source = """
-     .a = parse_syslog(.a)
+     .a = parse_syslog!(.a)
    """
 [[tests]]
   name = "remap_function_parse_syslog"
@@ -919,7 +920,7 @@
     source = '''
       .a.facility == "daemon" && \
       .a.severity == "warning" && \
-      .a.timestamp == to_timestamp("2020-05-22T17:59:09.250Z") && \
+      .a.timestamp == to_timestamp!("2020-05-22T17:59:09.250Z") && \
       .a.hostname == "OX-XXX-MX204" && \
       .a.appname == "OX-XXX-CONTEUDO:rpd" && \
       .a.procid == 6589 && \
@@ -930,7 +931,7 @@
   inputs=[]
   type = "remap"
   source = """
-    .foo = split(.foo, /a.b/i, 3)
+    .foo = split!(.foo, /a.b/i, 3)
   """
 [[tests]]
   name = "remap_function_split_regex"
@@ -953,7 +954,7 @@
   inputs=[]
   type = "remap"
   source = """
-    .foo = split(.foo, " ", 3)
+    .foo = split!(.foo, " ", 3)
   """
 [[tests]]
   name = "remap_function_split_string"
@@ -976,7 +977,7 @@
   inputs = []
   type = "remap"
   source = """
-    .foo = parse_timestamp("10", "%s")
+    .foo = parse_timestamp!("10", "%s")
   """
 [[tests]]
   name = "remap_function_parse_timestamp"
@@ -989,7 +990,7 @@
     [[tests.outputs.conditions]]
       type = "remap"
       source = '''
-        .foo == to_timestamp("1970-01-01T00:00:10Z")
+        .foo == to_timestamp!("1970-01-01T00:00:10Z")
       '''
 
 [transforms.remap_function_truncate]
@@ -1038,8 +1039,8 @@
   inputs = []
   type = "remap"
   source = """
-    .grokked = parse_grok(.message, "%{TIMESTAMP_ISO8601:timestamp} (%{EMAILADDRESS:email}|%{LOGLEVEL:level}) %{GREEDYDATA:message}")
-    .grokked2 = parse_grok(.message, "%{TIMESTAMP_ISO8601:timestamp} (%{EMAILADDRESS:email}|%{LOGLEVEL:level}) %{GREEDYDATA:message}", remove_empty: true)
+    .grokked = parse_grok!(.message, "%{TIMESTAMP_ISO8601:timestamp} (%{EMAILADDRESS:email}|%{LOGLEVEL:level}) %{GREEDYDATA:message}")
+    .grokked2 = parse_grok!(.message, "%{TIMESTAMP_ISO8601:timestamp} (%{EMAILADDRESS:email}|%{LOGLEVEL:level}) %{GREEDYDATA:message}", remove_empty: true)
     """
 [[tests]]
   name = "remap_function_parse_grok"
@@ -1067,10 +1068,10 @@
   inputs = []
   type = "remap"
   source = """
-    .a = ip_subnet("192.168.10.23", "255.255.0.0")
-    .b = ip_subnet("192.168.10.23", "/8")
-    .c = ip_subnet("2404:6800:4003:c02::64", "ffff:ffff::")
-    .d = ip_subnet("2404:6800:4003:c02::64", "/16")
+    .a = ip_subnet!("192.168.10.23", "255.255.0.0")
+    .b = ip_subnet!("192.168.10.23", "/8")
+    .c = ip_subnet!("2404:6800:4003:c02::64", "ffff:ffff::")
+    .d = ip_subnet!("2404:6800:4003:c02::64", "/16")
   """
 [[tests]]
   name = "remap_function_ip_subnet"
@@ -1093,10 +1094,10 @@
   inputs = []
   type = "remap"
   source = """
-    .a = ip_cidr_contains(cidr: "192.168.0.0/16", value: "192.168.10.2")
-    .b = ip_cidr_contains(cidr: "192.168.0.0/16", value: "192.169.10.2")
-    .c = ip_cidr_contains(cidr: "2404:6800:4003:c02::/64", value: "2404:6800:4003:c02::aaaa")
-    .d = ip_cidr_contains("2404:6800:4003:c02::/64", "2404:6800:4004:c02::aaaa")
+    .a = ip_cidr_contains!(cidr: "192.168.0.0/16", value: "192.168.10.2")
+    .b = ip_cidr_contains!(cidr: "192.168.0.0/16", value: "192.169.10.2")
+    .c = ip_cidr_contains!(cidr: "2404:6800:4003:c02::/64", value: "2404:6800:4003:c02::aaaa")
+    .d = ip_cidr_contains!("2404:6800:4003:c02::/64", "2404:6800:4004:c02::aaaa")
   """
 [[tests]]
   name = "remap_function_ip_cidr_contains"
@@ -1119,7 +1120,7 @@
   inputs = []
   type = "remap"
   source = """
-    .a = ip_to_ipv6("192.168.10.2")
+    .a = ip_to_ipv6!("192.168.10.2")
   """
 [[tests]]
   name = "remap_function_ip_to_ipv6"
@@ -1139,7 +1140,7 @@
   inputs = []
   type = "remap"
   source = """
-    .a = ipv6_to_ipv4("::ffff:192.168.10.2")
+    .a = ipv6_to_ipv4!("::ffff:192.168.10.2")
   """
 [[tests]]
   name = "remap_function_ipv6_to_ipv4"
@@ -1159,7 +1160,7 @@
   inputs = []
   type = "remap"
   source = """
-    .data = parse_json(.data)
+    .data = parse_json!(.data)
     .a = exists(.foo)
     .b = exists(.bar)
     .c = exists(.data.child)
@@ -1182,15 +1183,15 @@
     [[tests.outputs.conditions]]
       type = "remap"
       source = '''
-        .a  && !.b  && .c && !.d  && .e && !.f
+        .a  && !.b  && .c && !.d  && .e && !.f ?? false
       '''
 
 [transforms.remap_function_compact]
   inputs = []
   type = "remap"
   source = """
-    .compactarr = compact(parse_json(.arr))
-    .compactmap = compact(parse_json(.map))
+    .compactarr = compact!(parse_json!(.arr))
+    .compactmap = compact!(parse_json!(.map))
     .a = exists(.compactmap.field1)
     .b = exists(.compactmap.field2)
     .c = exists(.compactmap.field3)
@@ -1231,7 +1232,7 @@
   type = "remap"
   drop_on_err = true
   source = """
-    assert(.foo, message: "assert failed")
+    assert!(.foo, message: "assert failed")
     .check = "checked"
   """
 [[tests]]
@@ -1254,7 +1255,7 @@
   type = "remap"
   drop_on_err = true
   source = """
-    assert(.foo, message: "assert failed")
+    assert!(.foo, message: "assert failed")
   """
 [[tests]]
   name = "remap_function_assert_fail"
@@ -1290,9 +1291,9 @@
   inputs=[]
   type = "remap"
   source = """
-    .foo = parse_json(.foo)
-    .bar = parse_json(.bar)
-    merge(.bar, .foo, deep: true)
+    .foo = parse_json!(.foo)
+    .bar = parse_json!(.bar)
+    merge!(.bar, .foo, deep: true)
   """
 [[tests]]
   name = "remap_function_merge"
@@ -1319,8 +1320,8 @@
   inputs = []
   type = "remap"
   source = """
-    .arr = flatten(parse_json(.arr))
-    .map = flatten(parse_json(.map))
+    .arr = flatten!(parse_json!(.arr))
+    .map = flatten!(parse_json!(.map))
     .a = .map."field1.field2"
     .b = .map."field1.field3"
   """
@@ -1353,11 +1354,11 @@
   inputs = []
   type = "remap"
   source = """
-    .a = redact(.input, filters: ["pattern"], patterns: ["hello"])
-    .b = redact(.input, filters: ["pattern"], patterns: ["hello", "wor"])
-    .c = redact(.input, filters: ["pattern"], patterns: [/world|universe/])
-    .d = redact(.input, filters: ["pattern"], patterns: [])
-    .e = redact(.input, filters: ["pattern"], patterns: ["hello", /[uieao]/])
+    .a = redact!(.input, filters: ["pattern"], patterns: ["hello"])
+    .b = redact!(.input, filters: ["pattern"], patterns: ["hello", "wor"])
+    .c = redact!(.input, filters: ["pattern"], patterns: [/world|universe/])
+    .d = redact!(.input, filters: ["pattern"], patterns: [])
+    .e = redact!(.input, filters: ["pattern"], patterns: ["hello", /[uieao]/])
   """
 [[tests]]
   name = "remap_function_redact"
@@ -1405,7 +1406,7 @@
   inputs = []
   type = "remap"
   source = """
-    .parts = parse_aws_alb_log(.log)
+    .parts = parse_aws_alb_log!(.log)
   """
 [[tests]]
   name = "remap_function_parse_aws_alb_log"
@@ -1454,8 +1455,8 @@
   inputs = []
   type = "remap"
   source = """
-    .a = parse_aws_vpc_flow_log(.a)
-    .b = parse_aws_vpc_flow_log(.b, format: "instance_id interface_id srcaddr dstaddr pkt_srcaddr pkt_dstaddr")
+    .a = parse_aws_vpc_flow_log!(.a)
+    .b = parse_aws_vpc_flow_log!(.b, format: "instance_id interface_id srcaddr dstaddr pkt_srcaddr pkt_dstaddr")
   """
 [[tests]]
   name = "remap_function_parse_aws_vpc_flow_log"
@@ -1526,8 +1527,8 @@
   inputs = []
   type = "remap"
   source = """
-    .a = encode_json(parse_json(.a))
-    .b = encode_json(parse_json(.b))
+    .a = encode_json!(parse_json(.a))
+    .b = encode_json!(parse_json(.b))
   """
 [[tests]]
   name = "remap_function_encode_json"
@@ -1550,10 +1551,10 @@
   inputs = []
   type = "remap"
   source = '''
-    . = parse_regex(.message, /^(?P<host>[\w\.]+) - (?P<user>[\w]+) (?P<bytes_in>[\d]+) \[(?P<timestamp>.*)\] "(?P<method>[\w]+) (?P<path>.*)" (?P<status>[\d]+) (?P<bytes_out>[\d]+)$/)
-    .bytes_in = to_int(.bytes_in)
-    .status = to_int(.status)
-    .bytes_out = to_int(.bytes_out)
+    . = parse_regex!(.message, /^(?P<host>[\w\.]+) - (?P<user>[\w]+) (?P<bytes_in>[\d]+) \[(?P<timestamp>.*)\] "(?P<method>[\w]+) (?P<path>.*)" (?P<status>[\d]+) (?P<bytes_out>[\d]+)$/)
+    .bytes_in = to_int!(.bytes_in)
+    .status = to_int!(.status)
+    .bytes_out = to_int!(.bytes_out)
   '''
 [[tests]]
   name = "remap_function_parse_regex"
@@ -1582,7 +1583,7 @@
   inputs = []
   type = "remap"
   source = '''
-    .result = parse_regex_all(.message, /(?P<fruit>[\w\.]+) and (?P<veg>[\w]+)/)
+    .result = parse_regex_all!(.message, /(?P<fruit>[\w\.]+) and (?P<veg>[\w]+)/)
   '''
 [[tests]]
   name = "remap_function_parse_regex_all"
@@ -1608,7 +1609,7 @@
   inputs = []
   type = "remap"
   source = '''
-    .result = parse_aws_cloudwatch_log_subscription_message(.message)
+    .result = parse_aws_cloudwatch_log_subscription_message!(.message)
   '''
 [[tests]]
   name = "remap_function_parse_aws_cloudwatch_log_subscription_message"
@@ -1628,7 +1629,7 @@
         .result.log_group == "" && \
         .result.log_stream == "" && \
         .result.log_events == [{ "id": "",
-                                 "timestamp": to_timestamp("2020-09-14T19:00:03.794Z"),
+                                 "timestamp": to_timestamp!("2020-09-14T19:00:03.794Z"),
                                  "message": "CWL CONTROL MESSAGE: Checking health of destination Firehose." }]
       '''
 
@@ -1636,7 +1637,7 @@
   inputs = []
   type = "remap"
   source = '''
-    . = parse_key_value(.message, key_value_delimiter: "=", field_delimiter: " ")
+    . = parse_key_value!(.message, key_value_delimiter: "=", field_delimiter: " ")
   '''
 [[tests]]
   name = "remap_function_parse_key_value"
@@ -1707,9 +1708,9 @@
   inputs = []
   type = "remap"
   source = """
-    .a = to_syslog_facility(.a)
-    .b = to_syslog_facility(.b)
-    .c = to_syslog_facility(.c)
+    .a = to_syslog_facility!(.a)
+    .b = to_syslog_facility!(.b)
+    .c = to_syslog_facility!(.c)
   """
 [[tests]]
   name = "remap_function_to_syslog_facility"
@@ -1734,9 +1735,9 @@
   inputs = []
   type = "remap"
   source = """
-    .secs = to_unix_timestamp(to_timestamp(.time))
-    .millis = to_unix_timestamp(to_timestamp(.time), unit: "milliseconds")
-    .nanos = to_unix_timestamp(to_timestamp(.time), unit: "nanoseconds")
+    .secs = to_unix_timestamp!(to_timestamp(.time))
+    .millis = to_unix_timestamp!(to_timestamp(.time), unit: "milliseconds")
+    .nanos = to_unix_timestamp!(to_timestamp(.time), unit: "nanoseconds")
   """
 [[tests]]
   name = "remap_function_to_unix_timestamp"
@@ -1759,7 +1760,7 @@
   inputs = []
   type = "remap"
   source = """
-    .result = push(parse_json(.fruits), .fruit)
+    .result = push!(parse_json(.fruits), .fruit)
   """
 [[tests]]
   name = "remap_function_push_to_array"
@@ -1784,7 +1785,7 @@
   inputs = []
   type = "remap"
   source = """
-    .result = append(parse_json(.fruits), parse_json(.other_fruits))
+    .result = append!(parse_json(.fruits), parse_json!(.other_fruits))
   """
 [[tests]]
   name = "remap_function_append_to_array"
@@ -1809,7 +1810,7 @@
   inputs = []
   type = "remap"
   source = '''
-    .result = encode_base64(.message)
+    .result = encode_base64!(.message)
   '''
 [[tests]]
   name = "remap_function_encode_base64"
@@ -1829,7 +1830,7 @@
   inputs = []
   type = "remap"
   source = '''
-    .result = decode_base64(.message)
+    .result = decode_base64!(.message)
   '''
 [[tests]]
   name = "remap_function_decode_base64"

From 02beb51a138fbd2b5561c8115345491d50376342 Mon Sep 17 00:00:00 2001
From: James Turnbull <james@lovedthanlost.net>
Date: Mon, 18 Jan 2021 17:51:09 -0500
Subject: [PATCH 06/19] fix(external docs): Added command: commands.configure
 to Homebrew cue (#6121)

Signed-off-by: James Turnbull <james@lovedthanlost.net>
---
 docs/reference/installation/_interfaces/homebrew.cue | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/reference/installation/_interfaces/homebrew.cue b/docs/reference/installation/_interfaces/homebrew.cue
index 6fddefd12c623..2a7cdbbe35ea8 100644
--- a/docs/reference/installation/_interfaces/homebrew.cue
+++ b/docs/reference/installation/_interfaces/homebrew.cue
@@ -37,7 +37,7 @@ installation: _interfaces: homebrew: {
 				},
 				{
 					title:   "Configure Vector"
-					command: "fix me"
+					command: commands.configure
 				},
 				{
 					title:   "Restart Vector"

From bf3401cf188aea7b4faff77b5a9050e5666461ab Mon Sep 17 00:00:00 2001
From: Luc Perkins <lucperkins@gmail.com>
Date: Mon, 18 Jan 2021 16:59:58 -0700
Subject: [PATCH 07/19] enhancement(remap): Update VRL CLI behavior (#6035)

* s/program/script

Signed-off-by: Luc Perkins <luc@timber.io>

* Change default behavior for REPL

Signed-off-by: Luc Perkins <luc@timber.io>

* Provide error on mixed args

Signed-off-by: Luc Perkins <luc@timber.io>

* Fix formatting

Signed-off-by: Luc Perkins <luc@timber.io>

* s/program/repl

Signed-off-by: Luc Perkins <luc@timber.io>

* Fix arg name

Signed-off-by: Luc Perkins <luc@timber.io>

* Manual cleanup

Signed-off-by: Luc Perkins <luc@timber.io>

* Fix description

Signed-off-by: Luc Perkins <luc@timber.io>

* One more formatting fix

Signed-off-by: Luc Perkins <luc@timber.io>

* s/PROGRAM/SCRIPT

Signed-off-by: Luc Perkins <luc@timber.io>

* Split out separate REPL function

Signed-off-by: Luc Perkins <luc@timber.io>

* s/script/program

Signed-off-by: Luc Perkins <luc@timber.io>

* Small fix in comment text

Signed-off-by: Luc Perkins <luc@timber.io>

* Reformat

Signed-off-by: Luc Perkins <luc@timber.io>

* Provide empty object as default for REPL

Signed-off-by: Luc Perkins <luc@timber.io>
---
 lib/remap-cli/src/cmd.rs  | 44 +++++++++++++++++++++++++--------------
 lib/remap-cli/src/repl.rs |  4 ++--
 2 files changed, 30 insertions(+), 18 deletions(-)

diff --git a/lib/remap-cli/src/cmd.rs b/lib/remap-cli/src/cmd.rs
index b8a8c5e1bf19c..0acc8c6541d54 100644
--- a/lib/remap-cli/src/cmd.rs
+++ b/lib/remap-cli/src/cmd.rs
@@ -10,25 +10,21 @@ use structopt::StructOpt;
 #[derive(Debug, StructOpt)]
 #[structopt(name = "VRL", about = "Vector Remap Language CLI")]
 pub struct Opts {
-    /// Program to execute
-    ///
-    /// For example, ".foo = true" will set the object's `foo` field to `true`.
+    /// The VRL program to execute. The program ".foo = true", for example, sets the event object's
+    /// `foo` field to `true`.
     #[structopt(name = "PROGRAM")]
     program: Option<String>,
 
-    /// File containing the object(s) to manipulate, leave empty to use stdin
+    /// The file containing the event object(s) to handle. The supported formats are JSON and jsonl.
     #[structopt(short, long = "input", parse(from_os_str))]
     input_file: Option<PathBuf>,
 
-    /// File containing the program to execute, can be used instead of
-    /// "PROGRAM"
+    /// The file containing the VRL program to execute. This can be used instead of `PROGRAM`.
     #[structopt(short, long = "program", conflicts_with("program"), parse(from_os_str))]
     program_file: Option<PathBuf>,
 
-    /// Print the (modified) object, instead of the result of the final
-    /// expression.
-    ///
-    /// The same result can be achieved by using `.` as the final expression.
+    /// Print the (modified) event object instead of the result of the final expression. Setting
+    /// this flag is equivalent to using `.` as the final expression.
     #[structopt(short = "o", long)]
     print_object: bool,
 }
@@ -44,12 +40,20 @@ pub fn cmd(opts: &Opts) -> exitcode::ExitCode {
 }
 
 fn run(opts: &Opts) -> Result<(), Error> {
-    let objects = read_into_objects(opts.input_file.as_ref())?;
-    let program = read_program(opts.program.as_deref(), opts.program_file.as_ref())?;
-
-    if program.is_empty() {
-        repl(objects)
+    // Run the REPL if no program or program file is specified
+    if should_open_repl(opts) {
+        // If an input file is provided, use that for the REPL objects, otherwise provide a
+        // generic default object.
+        let repl_objects = match &opts.input_file {
+            Some(file) => read_into_objects(Some(file))?,
+            None => default_objects(),
+        };
+
+        repl(repl_objects)
     } else {
+        let objects = read_into_objects(opts.input_file.as_ref())?;
+        let program = read_program(opts.program.as_deref(), opts.program_file.as_ref())?;
+
         for mut object in objects {
             let result = execute(&mut object, program.clone()).map(|v| {
                 if opts.print_object {
@@ -75,7 +79,7 @@ fn repl(objects: Vec<Value>) -> Result<(), Error> {
 }
 
 #[cfg(not(feature = "repl"))]
-fn repl(object: Vec<Value>) -> Result<(), Error> {
+fn repl(_: Vec<Value>) -> Result<(), Error> {
     Err(Error::ReplFeature)
 }
 
@@ -140,3 +144,11 @@ fn read<R: Read>(mut reader: R) -> Result<String, Error> {
 
     Ok(buffer)
 }
+
+fn should_open_repl(opts: &Opts) -> bool {
+    opts.program.is_none() && opts.program_file.is_none()
+}
+
+fn default_objects() -> Vec<Value> {
+    vec![Value::Map(BTreeMap::new())]
+}
diff --git a/lib/remap-cli/src/repl.rs b/lib/remap-cli/src/repl.rs
index 8a4a622db740d..e7391818aa94b 100644
--- a/lib/remap-cli/src/repl.rs
+++ b/lib/remap-cli/src/repl.rs
@@ -254,8 +254,8 @@ fn print_function_list() {
         .chunks(num_columns)
         .map(|funcs| {
             // Because it's possible that some chunks are only partial, e.g. have only two Some(_)
-            // values when num_columns is 3. And so this logic below is necessary to avoid panics
-            // caused by inappropriately calling funcs.get(_) on a None.
+            // values when num_columns is 3, this logic below is necessary to avoid panics caused
+            // by inappropriately calling funcs.get(_) on a None.
             let mut ids: Vec<Cell> = Vec::new();
 
             for n in 0..num_columns {

From a33537613404080d617aeafd117bd8ae53daad53 Mon Sep 17 00:00:00 2001
From: Luc Perkins <lucperkins@gmail.com>
Date: Mon, 18 Jan 2021 17:00:24 -0700
Subject: [PATCH 08/19] enhancement(remap): Add length function for VRL (#6088)

* Add length function

Signed-off-by: Luc Perkins <luc@timber.io>

* Add length function

Signed-off-by: Luc Perkins <luc@timber.io>

* Remove del from examples

Signed-off-by: Luc Perkins <luc@timber.io>

* Prevent potential i64 overflow

Signed-off-by: Luc Perkins <luc@timber.io>

* Fix formatting

Signed-off-by: Luc Perkins <luc@timber.io>

* Add behavior test

Signed-off-by: Luc Perkins <luc@timber.io>

* Fix CUE enum disjunction from merge

Signed-off-by: Luc Perkins <luc@timber.io>

* Add support for strings

Signed-off-by: Luc Perkins <luc@timber.io>

* Update CUE docs to mention string support

Signed-off-by: Luc Perkins <luc@timber.io>

* Fix CUE formatting

Signed-off-by: Luc Perkins <luc@timber.io>

* Add type clarification

Signed-off-by: Luc Perkins <luc@timber.io>

* Update tests

Signed-off-by: Luc Perkins <luc@timber.io>

* Add note on max value

Signed-off-by: Luc Perkins <luc@timber.io>

* Fix formatting

Signed-off-by: Luc Perkins <luc@timber.io>

* Add unit tests for is_scalar function

Signed-off-by: Luc Perkins <luc@timber.io>

* Fix merge issues

Signed-off-by: Luc Perkins <luc@timber.io>

* Update behavior test

Signed-off-by: Luc Perkins <luc@timber.io>

* Define max values for integers and floats in the CUE sources

Signed-off-by: Luc Perkins <luc@timber.io>

* Remove with_inner_type declaration

Signed-off-by: Luc Perkins <luc@timber.io>

* Set inner_type to None when Kind is a scalar

Signed-off-by: Luc Perkins <luc@timber.io>

* Remove redundant into() call

Signed-off-by: Luc Perkins <luc@timber.io>

* Fix docs issue

Signed-off-by: Luc Perkins <luc@timber.io>

* Fix with_constraint function

Signed-off-by: Luc Perkins <luc@timber.io>

* Add float and integer range to docs

Signed-off-by: Luc Perkins <luc@timber.io>
---
 docs/reference/remap/functions/length.cue |  60 ++++++++++
 docs/reference/remap/literals/float.cue   |   3 +
 docs/reference/remap/literals/integer.cue |   3 +
 lib/remap-functions/Cargo.toml            |   2 +
 lib/remap-functions/src/includes.rs       |   1 -
 lib/remap-functions/src/is_nullish.rs     |   9 +-
 lib/remap-functions/src/length.rs         | 136 ++++++++++++++++++++++
 lib/remap-functions/src/lib.rs            |   6 +
 lib/remap-lang/src/type_def.rs            |   5 +
 lib/remap-lang/src/value/kind.rs          |  37 ++++++
 tests/behavior/transforms/remap.toml      |  23 ++++
 11 files changed, 279 insertions(+), 6 deletions(-)
 create mode 100644 docs/reference/remap/functions/length.cue
 create mode 100644 lib/remap-functions/src/length.rs

diff --git a/docs/reference/remap/functions/length.cue b/docs/reference/remap/functions/length.cue
new file mode 100644
index 0000000000000..db4d250bad0de
--- /dev/null
+++ b/docs/reference/remap/functions/length.cue
@@ -0,0 +1,60 @@
+package metadata
+
+remap: functions: length: {
+	arguments: [
+		{
+			name:        "value"
+			description: "The array or map"
+			required:    true
+			type: ["array", "map", "string"]
+		},
+	]
+	internal_failure_reasons: []
+	return: ["integer"]
+	category: "Enumerate"
+	description: """
+		Returns the length of the input:
+
+		* If an array, the size of the array
+		* If a string, the number of bytes in the string
+		* If a map, the number of keys in the map (nested keys are ignored)
+		"""
+	examples: [
+		{
+			title: "Standard map"
+			input: log: teams: {
+				portland: "Trail Blazers"
+				seattle:  "Supersonics"
+			}
+			source: ".num_teams = length(.teams)"
+			output: input & {log: num_teams: 2}
+		},
+		{
+			title: "Array"
+			input: log: teams: ["Trail Blazers", "Supersonics", "Grizzlies"]
+			source: ".num_teams = length(.teams)"
+			output: input & {log: num_teams: 3}
+		},
+		{
+			title: "Nested map"
+			input: log: team: {
+				home: {
+					city:  "Portland"
+					state: "Oregon"
+				}
+				name: "Trail Blazers"
+				mascot: {
+					name: "Blaze the Trail Cat"
+				}
+			}
+			source: ".num_attrs = length(.team)"
+			output: input & {log: num_attrs: 3}
+		},
+		{
+			title: "String"
+			input: log: message: "The Planet of the Apes Musical"
+			source: ".str_len = length(.message)"
+			output: input & {log: str_len: 30}
+		},
+	]
+}
diff --git a/docs/reference/remap/literals/float.cue b/docs/reference/remap/literals/float.cue
index 6d49761f028e0..f82604e54ba29 100644
--- a/docs/reference/remap/literals/float.cue
+++ b/docs/reference/remap/literals/float.cue
@@ -8,6 +8,9 @@ remap: literals: float: {
 
 		A decimal floating-point literal consists of an integer part (decimal digits), a decimal point, a fractional
 		part (decimal digits).
+
+		Floats in VRL can range from -1.7976931348623157E+308f64 to 1.7976931348623157E+308f64. Floats outside that
+		range are wrapped.
 		"""
 
 	examples: [
diff --git a/docs/reference/remap/literals/integer.cue b/docs/reference/remap/literals/integer.cue
index 1627fba7ccf5d..83b7ecef13d79 100644
--- a/docs/reference/remap/literals/integer.cue
+++ b/docs/reference/remap/literals/integer.cue
@@ -4,6 +4,9 @@ remap: literals: integer: {
 	title: "Integer"
 	description: """
 		An _integer_ literal is a sequence of digits representing a 64-bit signed integer type.
+
+		Integers in VRL can range from -9223372036854775807 to 9223372036854775807. Integers outside that range are
+		wrapped.
 		"""
 
 	examples: [
diff --git a/lib/remap-functions/Cargo.toml b/lib/remap-functions/Cargo.toml
index 8d3e7366aa46d..6e267e99d3b9c 100644
--- a/lib/remap-functions/Cargo.toml
+++ b/lib/remap-functions/Cargo.toml
@@ -60,6 +60,7 @@ default = [
     "ip_to_ipv6",
     "ipv6_to_ipv4",
     "is_nullish",
+    "length",
     "log",
     "match",
     "md5",
@@ -127,6 +128,7 @@ ip_subnet = ["lazy_static", "regex"]
 ip_to_ipv6 = []
 ipv6_to_ipv4 = []
 is_nullish = []
+length = []
 log = ["tracing"]
 match = ["regex"]
 md5 = ["md-5", "hex"]
diff --git a/lib/remap-functions/src/includes.rs b/lib/remap-functions/src/includes.rs
index d0fbe8f08e3bc..6dafafe47da73 100644
--- a/lib/remap-functions/src/includes.rs
+++ b/lib/remap-functions/src/includes.rs
@@ -55,7 +55,6 @@ impl Expression for IncludesFn {
             .fallible_unless(Kind::Array)
             .merge(self.item.type_def(state))
             .with_constraint(Kind::Boolean)
-            .with_inner_type(None)
     }
 }
 
diff --git a/lib/remap-functions/src/is_nullish.rs b/lib/remap-functions/src/is_nullish.rs
index c26f2a2165cb6..e407a289b6304 100644
--- a/lib/remap-functions/src/is_nullish.rs
+++ b/lib/remap-functions/src/is_nullish.rs
@@ -56,7 +56,7 @@ mod tests {
                 value: Literal::from("some string").boxed(),
             },
             def: TypeDef {
-                kind: value::Kind::Boolean,
+                kind: Kind::Boolean,
                 ..Default::default()
             },
         }
@@ -66,7 +66,7 @@ mod tests {
                 value: Literal::from(()).boxed(),
             },
             def: TypeDef {
-                kind: value::Kind::Boolean,
+                kind: Kind::Boolean,
                 ..Default::default()
             },
         }
@@ -77,7 +77,7 @@ mod tests {
                 value: lit!(42).boxed(),
             },
             def: TypeDef {
-                kind: value::Kind::Boolean,
+                kind: Kind::Boolean,
                 ..Default::default()
             },
         }
@@ -88,8 +88,7 @@ mod tests {
                 value: array!["foo"].boxed(),
             },
             def: TypeDef {
-                kind: value::Kind::Boolean,
-                inner_type_def: Some(TypeDef { kind: Kind::Bytes, ..Default::default() }.boxed()),
+                kind: Kind::Boolean,
                 ..Default::default()
             },
         }
diff --git a/lib/remap-functions/src/length.rs b/lib/remap-functions/src/length.rs
new file mode 100644
index 0000000000000..d81f5b0652dd9
--- /dev/null
+++ b/lib/remap-functions/src/length.rs
@@ -0,0 +1,136 @@
+use remap::prelude::*;
+
+#[derive(Clone, Copy, Debug)]
+pub struct Length;
+
+impl Function for Length {
+    fn identifier(&self) -> &'static str {
+        "length"
+    }
+
+    fn parameters(&self) -> &'static [Parameter] {
+        &[Parameter {
+            keyword: "value",
+            accepts: |v| matches!(v, Value::Array(_) | Value::Map(_) | Value::Bytes(_)),
+            required: true,
+        }]
+    }
+
+    fn compile(&self, mut arguments: ArgumentList) -> Result<Box<dyn Expression>> {
+        let value = arguments.required("value")?.boxed();
+
+        Ok(Box::new(LengthFn { value }))
+    }
+}
+
+#[derive(Debug, Clone)]
+struct LengthFn {
+    value: Box<dyn Expression>,
+}
+
+impl Expression for LengthFn {
+    fn execute(&self, state: &mut state::Program, object: &mut dyn Object) -> Result<Value> {
+        use Value::*;
+
+        let value = self.value.execute(state, object)?;
+
+        match value {
+            Array(v) => Ok(Value::from(v.len() as i64)),
+            Map(v) => Ok(Value::from(v.len() as i64)),
+            Bytes(v) => Ok(Value::from(v.len() as i64)),
+            _ => Err("unsupported type".into()),
+        }
+    }
+
+    fn type_def(&self, state: &state::Compiler) -> TypeDef {
+        use value::Kind;
+
+        self.value
+            .type_def(state)
+            .fallible_unless(Kind::Bytes | Kind::Array | Kind::Map)
+            .with_constraint(Kind::Integer)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use value::Kind;
+
+    test_type_def![
+        value_map_infallible {
+            expr: |_| LengthFn {
+                value: map! {"foo": "bar", "baz": 27, "baq": false}.boxed()
+            },
+            def: TypeDef {
+                kind: Kind::Integer,
+                ..Default::default()
+            },
+        }
+
+        value_array_infallible {
+            expr: |_| LengthFn {
+                value: array!["foo", 127, false].boxed()
+            },
+            def: TypeDef {
+                kind: Kind::Integer,
+                ..Default::default()
+            },
+        }
+
+        value_string_infallible {
+            expr: |_| LengthFn {
+                value: lit!("this is infallible").boxed()
+            },
+            def: TypeDef {
+                kind: Kind::Integer,
+                ..Default::default()
+            },
+        }
+
+        value_integer_fallible {
+            expr: |_| LengthFn {
+                value: lit!(127).boxed()
+            },
+            def: TypeDef {
+                fallible: true,
+                kind: Kind::Integer,
+                ..Default::default()
+            },
+        }
+    ];
+
+    test_function![
+        length => Length;
+
+        non_empty_map_value {
+            args: func_args![value: map!["foo": "bar", "baz": true, "baq": array![1, 2, 3]]],
+            want: Ok(value!(3)),
+        }
+
+        empty_map_value {
+            args: func_args![value: map![]],
+            want: Ok(value!(0)),
+        }
+
+        nested_map_value {
+            args: func_args![value: map!["nested": map!["foo": "bar"]]],
+            want: Ok(value!(1)),
+        }
+
+        non_empty_array_value {
+            args: func_args![value: array![1, 2, 3, 4, true, "hello"]],
+            want: Ok(value!(6)),
+        }
+
+        empty_array_value {
+            args: func_args![value: array![]],
+            want: Ok(value!(0)),
+        }
+
+        string_value {
+            args: func_args![value: value!("hello world")],
+            want: Ok(value!(11))
+        }
+    ];
+}
diff --git a/lib/remap-functions/src/lib.rs b/lib/remap-functions/src/lib.rs
index 6da260a5590c2..39d68ba0f07fa 100644
--- a/lib/remap-functions/src/lib.rs
+++ b/lib/remap-functions/src/lib.rs
@@ -46,6 +46,8 @@ mod ip_to_ipv6;
 mod ipv6_to_ipv4;
 #[cfg(feature = "is_nullish")]
 mod is_nullish;
+#[cfg(feature = "length")]
+mod length;
 #[cfg(feature = "log")]
 mod log;
 #[cfg(feature = "match")]
@@ -183,6 +185,8 @@ pub use ip_to_ipv6::IpToIpv6;
 pub use ipv6_to_ipv4::Ipv6ToIpV4;
 #[cfg(feature = "is_nullish")]
 pub use is_nullish::IsNullish;
+#[cfg(feature = "length")]
+pub use length::Length;
 #[cfg(feature = "log")]
 pub use log::Log;
 #[cfg(feature = "merge")]
@@ -316,6 +320,8 @@ pub fn all() -> Vec<Box<dyn remap::Function>> {
         Box::new(Ipv6ToIpV4),
         #[cfg(feature = "is_nullish")]
         Box::new(IsNullish),
+        #[cfg(feature = "length")]
+        Box::new(Length),
         #[cfg(feature = "log")]
         Box::new(Log),
         #[cfg(feature = "md5")]
diff --git a/lib/remap-lang/src/type_def.rs b/lib/remap-lang/src/type_def.rs
index 9e3a4e3e057d4..dffd550ff775a 100644
--- a/lib/remap-lang/src/type_def.rs
+++ b/lib/remap-lang/src/type_def.rs
@@ -168,6 +168,11 @@ impl TypeDef {
 
     pub fn with_constraint(mut self, kind: impl Into<value::Kind>) -> Self {
         self.kind = kind.into();
+
+        if self.kind.is_scalar() {
+            self.inner_type_def = None;
+        }
+
         self
     }
 
diff --git a/lib/remap-lang/src/value/kind.rs b/lib/remap-lang/src/value/kind.rs
index cdd2fe36f89bb..d5e13a8710ac2 100644
--- a/lib/remap-lang/src/value/kind.rs
+++ b/lib/remap-lang/src/value/kind.rs
@@ -29,6 +29,12 @@ impl Kind {
     pub fn scalar(self) -> Self {
         self & !(Kind::Array | Kind::Map)
     }
+
+    /// Returns `true` if the [`value::Kind`] is a scalar and `false` if it's
+    /// map or array.
+    pub fn is_scalar(self) -> bool {
+        self == self.scalar()
+    }
 }
 
 macro_rules! impl_kind {
@@ -145,3 +151,34 @@ impl From<&Value> for Kind {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::Kind;
+
+    #[test]
+    fn kind_is_scalar() {
+        let scalars = vec![
+            Kind::Integer,
+            Kind::Bytes,
+            Kind::Null | Kind::Regex,
+            Kind::Timestamp | Kind::Float | Kind::Null,
+        ];
+
+        let non_scalars = vec![
+            Kind::Array,
+            Kind::Map,
+            Kind::Array | Kind::Integer,
+            Kind::Map | Kind::Bytes,
+            Kind::Boolean | Kind::Null | Kind::Array,
+        ];
+
+        for kind in scalars {
+            assert!(kind.is_scalar());
+        }
+
+        for kind in non_scalars {
+            assert!(!kind.is_scalar());
+        }
+    }
+}
diff --git a/tests/behavior/transforms/remap.toml b/tests/behavior/transforms/remap.toml
index 4a0e7ae732c20..e4726fde373fd 100644
--- a/tests/behavior/transforms/remap.toml
+++ b/tests/behavior/transforms/remap.toml
@@ -1895,3 +1895,26 @@
     [[tests.outputs.conditions]]
       type = "remap"
       source = '.a == "A long multiline string"'
+
+[transforms.remap_function_length]
+  inputs = []
+  type = "remap"
+  source = '''
+    .a = length(parse_json(.a))
+    .b = length(parse_json(.b))
+    .c = length(parse_json(.c))
+  '''
+[[tests]]
+  name = "remap_function_length"
+  [tests.input]
+    insert_at = "remap_function_length"
+    type = "log"
+    [tests.input.log_fields]
+    a = '[1, 2, 3]'
+    b = '{"foo":"bar","lorem":{"ipsum": "sicut dolor"}}'
+    c = '[[1, 2, 3], [4, 5, 6], []]'
+  [[tests.outputs]]
+    extract_from = "remap_function_length"
+    [[tests.outputs.conditions]]
+      type = "remap"
+      source = '[.a, .b, .c] == [3, 2, 3]'

From 0e248d4103ba169cf15dafadd3daf45c0d2980d2 Mon Sep 17 00:00:00 2001
From: Raphael Taylor-Davies <1781103+tustvold@users.noreply.github.com>
Date: Tue, 19 Jan 2021 00:02:51 +0000
Subject: [PATCH 09/19] fix(prometheus_exporter sink): Fix Metrics not Updating
 (#5917)

Signed-off-by: Raphael Taylor-Davies <r.taylordavies@googlemail.com>
---
 src/sinks/prometheus/exporter.rs | 66 ++++++++++++++++++++++++++++++++
 1 file changed, 66 insertions(+)

diff --git a/src/sinks/prometheus/exporter.rs b/src/sinks/prometheus/exporter.rs
index c521cb64b444f..272c716a91338 100644
--- a/src/sinks/prometheus/exporter.rs
+++ b/src/sinks/prometheus/exporter.rs
@@ -321,6 +321,7 @@ impl StreamSink for PrometheusExporter {
                 }
                 MetricKind::Absolute => {
                     let new = MetricEntry(item);
+                    metrics.map.remove(&new);
                     metrics.map.insert(new, false);
                 }
             };
@@ -415,6 +416,71 @@ mod tests {
         .into();
         (name, event)
     }
+
+    #[tokio::test]
+    async fn sink_absolute() {
+        let config = PrometheusExporterConfig {
+            address: PROMETHEUS_ADDRESS_TLS.parse().unwrap(),
+            tls: None,
+            ..Default::default()
+        };
+        let cx = SinkContext::new_test();
+
+        let mut sink = PrometheusExporter::new(config, cx.acker());
+
+        let m1 = Metric {
+            name: "absolute".to_string(),
+            namespace: None,
+            timestamp: None,
+            tags: Some(
+                vec![("tag1".to_owned(), "value1".to_owned())]
+                    .into_iter()
+                    .collect(),
+            ),
+            kind: MetricKind::Absolute,
+            value: MetricValue::Counter { value: 32. },
+        };
+
+        let m2 = Metric {
+            tags: Some(
+                vec![("tag1".to_owned(), "value2".to_owned())]
+                    .into_iter()
+                    .collect(),
+            ),
+            ..m1.clone()
+        };
+
+        let metrics = vec![
+            Event::Metric(Metric {
+                value: MetricValue::Counter { value: 32. },
+                ..m1.clone()
+            }),
+            Event::Metric(Metric {
+                value: MetricValue::Counter { value: 33. },
+                ..m2.clone()
+            }),
+            Event::Metric(Metric {
+                value: MetricValue::Counter { value: 40. },
+                ..m1.clone()
+            }),
+        ];
+
+        sink.run(Box::pin(futures::stream::iter(metrics)))
+            .await
+            .unwrap();
+
+        let map = &sink.metrics.read().unwrap().map;
+
+        assert_eq!(
+            map.get_full(&MetricEntry(m1)).unwrap().1 .0.value,
+            MetricValue::Counter { value: 40. }
+        );
+
+        assert_eq!(
+            map.get_full(&MetricEntry(m2)).unwrap().1 .0.value,
+            MetricValue::Counter { value: 33. }
+        );
+    }
 }
 
 #[cfg(all(test, feature = "prometheus-integration-tests"))]

From 475e05e95a14a0bf03447dd96f6e2180c3c4ab1b Mon Sep 17 00:00:00 2001
From: Ian Henry <ianjhenry00@gmail.com>
Date: Mon, 18 Jan 2021 19:46:21 -0500
Subject: [PATCH 10/19] chore(kubernetes_logs source): Document built-in
 metrics pipeline that we ship with the Helm charts (#6119)

* Document built-in metrics pipeline that we ship with the Helm charts

Signed-off-by: Ian Henry <ianjhenry00@gmail.com>
Signed-off-by: James Turnbull <james@lovedthanlost.net>

* Update docs/reference/installation/platforms/kubernetes.cue

Co-authored-by: Binary Logic <bjohnson@binarylogic.com>
Signed-off-by: James Turnbull <james@lovedthanlost.net>

Co-authored-by: James Turnbull <james@lovedthanlost.net>
Co-authored-by: Binary Logic <bjohnson@binarylogic.com>
---
 .../installation/platforms/kubernetes.cue      | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/docs/reference/installation/platforms/kubernetes.cue b/docs/reference/installation/platforms/kubernetes.cue
index 2aa903b58bf81..5f7bcde025252 100644
--- a/docs/reference/installation/platforms/kubernetes.cue
+++ b/docs/reference/installation/platforms/kubernetes.cue
@@ -9,5 +9,21 @@ installation: platforms: kubernetes: {
 		"""
 	minimum_supported_version: "1.14"
 
-	how_it_works: components.sources.kubernetes_logs.how_it_works
+	how_it_works: {
+		components.sources.kubernetes_logs.how_it_works
+
+		metrics: {
+			title: "Metrics"
+			body: """
+				Our Helm chart deployments provide quality of life around setup and maintenance of
+				metrics pipelines in Kubernetes. Each of the Helm charts provide an `internal_metrics`
+				source and `prometheus` sink out of the box. Agent deployments also expose `host_metrics`
+				via the same `prometheus` sink.
+
+				Charts come with options to enable Prometheus integration via annotations or Prometheus Operator
+				integration via PodMonitor. Thus, the Prometheus node_exporter agent is not required when the `host_metrics` source is
+				enabled.
+				"""
+		}
+	}
 }

From 7fa5f0e48a9c9a5aab38a3ab7354c8444bd992ea Mon Sep 17 00:00:00 2001
From: Kirill Fomichev <fanatid@ya.ru>
Date: Tue, 19 Jan 2021 10:13:07 +0300
Subject: [PATCH 11/19] chore(postgresql_metrics source): add more asserts in
 tests (#6110)

Signed-off-by: Kirill Fomichev <fanatid@ya.ru>
---
 .github/CODEOWNERS                |  2 +
 src/sources/postgresql_metrics.rs | 91 ++++++++++++++++++++++++++++---
 2 files changed, 85 insertions(+), 8 deletions(-)

diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 431e4b34cc6fb..05701e0a0740c 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -37,6 +37,7 @@
 /docs/reference/components/sources/kubernetes_logs.cue @timberio/vector-kubernetes
 /docs/reference/components/sources/mongodb_metrics.cue @fanatid
 /docs/reference/components/sources/nginx_metrics.cue @fanatid
+/docs/reference/components/sources/postgresql_metrics.cue @fanatid @jszwedko
 /docs/reference/components/sources/prometheus_scrape.cue @bruceg
 /docs/reference/components/sources/prometheus_remote_write.cue @bruceg
 /docs/reference/components/sources/stdin.cue @bruceg
@@ -187,6 +188,7 @@
 /src/sources/journald.rs @bruceg
 /src/sources/mongodb_metrics/ @fanatid
 /src/sources/nginx/ @fanatid
+/src/sources/postgresql_metrics.rs @fanatid @jszwedko
 /src/sources/prometheus @bruceg
 /src/sources/stdin.rs @bruceg
 /src/sources/syslog.rs @lukesteensen
diff --git a/src/sources/postgresql_metrics.rs b/src/sources/postgresql_metrics.rs
index 52952b7d6fbc1..44fe25b5771d4 100644
--- a/src/sources/postgresql_metrics.rs
+++ b/src/sources/postgresql_metrics.rs
@@ -72,7 +72,9 @@ enum BuildError {
     #[snafu(display("failed to connect ({}): {}", endpoint, source))]
     ConnectionFailed { source: PgError, endpoint: String },
     #[snafu(display("failed to get PostgreSQL version ({}): {}", endpoint, source))]
-    VersionFailed { source: PgError, endpoint: String },
+    SelectVersionFailed { source: PgError, endpoint: String },
+    #[snafu(display("version ({}) is not supported", version))]
+    InvalidVersion { version: String },
 }
 
 #[derive(Debug, Snafu)]
@@ -279,6 +281,7 @@ struct PostgresqlMetrics {
     config: Config,
     tls_config: Option<PostgresqlMetricsTlsConfig>,
     client: Option<Client>,
+    version: Option<usize>,
     namespace: Option<String>,
     tags: BTreeMap<String, String>,
     datname_filter: DatnameFilter,
@@ -316,6 +319,7 @@ impl PostgresqlMetrics {
             config,
             tls_config,
             client: None,
+            version: None,
             namespace,
             tags,
             datname_filter,
@@ -360,17 +364,48 @@ impl PostgresqlMetrics {
         let version_row = client
             .query_one("SELECT version()", &[])
             .await
-            .with_context(|| VersionFailed {
+            .with_context(|| SelectVersionFailed {
                 endpoint: config_to_endpoint(&self.config),
             })?;
         let version = version_row
             .try_get::<&str, &str>("version")
-            .with_context(|| VersionFailed {
+            .with_context(|| SelectVersionFailed {
                 endpoint: config_to_endpoint(&self.config),
             })?;
         debug!(message = "Connected to server.", endpoint = %config_to_endpoint(&self.config), server_version = %version);
 
         self.client = Some(client);
+        self.verify_version().await?;
+
+        Ok(())
+    }
+
+    async fn verify_version(&mut self) -> Result<(), BuildError> {
+        let row = self
+            .client
+            .as_ref()
+            .unwrap()
+            .query_one("SHOW server_version_num", &[])
+            .await
+            .with_context(|| SelectVersionFailed {
+                endpoint: config_to_endpoint(&self.config),
+            })?;
+
+        let version = row
+            .try_get::<&str, &str>("server_version_num")
+            .with_context(|| SelectVersionFailed {
+                endpoint: config_to_endpoint(&self.config),
+            })?;
+
+        self.version = Some(match version.parse::<usize>() {
+            Ok(version) if version >= 90600 => version,
+            Ok(_) | Err(_) => {
+                return Err(BuildError::InvalidVersion {
+                    version: version.to_string(),
+                })
+            }
+        });
+
         Ok(())
     }
 
@@ -505,11 +540,7 @@ impl PostgresqlMetrics {
                     tags!(self.tags, "db" => db),
                 ),
             ]);
-            if row
-                .columns()
-                .iter()
-                .any(|column| column.name() == "checksum_failures")
-            {
+            if self.version.expect("version is set above") >= 120000 {
                 metrics.extend_from_slice(&[
                     self.create_metric(
                         "pg_stat_database_checksum_failures_total",
@@ -799,6 +830,14 @@ mod integration_tests {
     async fn test_postgresql_metrics(endpoint: String, tls: Option<PostgresqlMetricsTlsConfig>) {
         trace_init();
 
+        let config: Config = endpoint.parse().unwrap();
+        let tags_endpoint = config_to_endpoint(&config);
+        let tags_host = match config.get_hosts().get(0).unwrap() {
+            Host::Tcp(host) => host.clone(),
+            #[cfg(unix)]
+            Host::Unix(path) => path.to_string_lossy().to_string(),
+        };
+
         let (sender, mut recv) = Pipeline::new_test();
 
         tokio::spawn(async move {
@@ -832,6 +871,42 @@ mod integration_tests {
             }
         }
         assert!(events.len() > 1);
+
+        // test up metric
+        assert_eq!(
+            events
+                .iter()
+                .map(|e| e.as_metric())
+                .find(|e| e.name == "up")
+                .unwrap()
+                .value,
+            gauge!(1)
+        );
+
+        // test namespace and tags
+        for event in &events {
+            let metric = event.as_metric();
+
+            assert_eq!(metric.namespace, Some("postgresql".to_owned()));
+            assert_eq!(
+                metric.tags.as_ref().unwrap().get("endpoint").unwrap(),
+                &tags_endpoint
+            );
+            assert_eq!(
+                metric.tags.as_ref().unwrap().get("host").unwrap(),
+                &tags_host
+            );
+        }
+
+        // test metrics from different queries
+        let names = vec![
+            "pg_stat_database_datid",
+            "pg_stat_database_conflicts_confl_tablespace_total",
+            "pg_stat_bgwriter_checkpoints_timed_total",
+        ];
+        for name in names {
+            assert!(events.iter().any(|e| e.as_metric().name == name));
+        }
     }
 
     #[tokio::test]

From 34f333f5e981fd6e0f3ab58e6485d406ee1a5561 Mon Sep 17 00:00:00 2001
From: Jesse Szwedko <jesse@szwedko.me>
Date: Tue, 19 Jan 2021 04:22:32 -0400
Subject: [PATCH 12/19] chore(ci): Fix remap benches (#6124)

Co-authored-by: Jean Mertz <git@jeanmertz.com>
---
 benches/remap.rs                     | 9 +++++----
 tests/behavior/transforms/remap.toml | 6 +++---
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/benches/remap.rs b/benches/remap.rs
index e0b29bf412d54..67625947602af 100644
--- a/benches/remap.rs
+++ b/benches/remap.rs
@@ -131,7 +131,7 @@ fn benchmark_remap(c: &mut Criterion) {
     c.bench_function("remap: parse JSON with remap", |b| {
         let mut tform: Box<dyn FunctionTransform> = Box::new(
             Remap::new(RemapConfig {
-                source: ".bar = parse_json(.foo)".to_owned(),
+                source: ".bar = parse_json!(.foo)".to_owned(),
                 drop_on_err: false,
             })
             .unwrap(),
@@ -195,9 +195,10 @@ fn benchmark_remap(c: &mut Criterion) {
     c.bench_function("remap: coerce with remap", |b| {
         let mut tform: Box<dyn FunctionTransform> = Box::new(
             Remap::new(RemapConfig {
-                source: r#".number = to_int(.number)
-                .bool = to_bool(.bool)
-                .timestamp = parse_timestamp(.timestamp, format: "%d/%m/%Y:%H:%M:%S %z")
+                source: r#"
+                .number = to_int!(.number)
+                .bool = to_bool!(.bool)
+                .timestamp = parse_timestamp!(.timestamp, format: "%d/%m/%Y:%H:%M:%S %z")
                 "#
                 .to_owned(),
                 drop_on_err: true,
diff --git a/tests/behavior/transforms/remap.toml b/tests/behavior/transforms/remap.toml
index e4726fde373fd..e3b5f94d35c42 100644
--- a/tests/behavior/transforms/remap.toml
+++ b/tests/behavior/transforms/remap.toml
@@ -1900,9 +1900,9 @@
   inputs = []
   type = "remap"
   source = '''
-    .a = length(parse_json(.a))
-    .b = length(parse_json(.b))
-    .c = length(parse_json(.c))
+    .a = length!(parse_json!(.a))
+    .b = length!(parse_json!(.b))
+    .c = length!(parse_json!(.c))
   '''
 [[tests]]
   name = "remap_function_length"

From 7e5f6baa19cc616eab8b69e5be43c4c70990e1ff Mon Sep 17 00:00:00 2001
From: Jean Mertz <git@jeanmertz.com>
Date: Tue, 19 Jan 2021 09:26:38 +0100
Subject: [PATCH 13/19] feat(remap): improve test harness set-up (#6105)

Signed-off-by: Jean Mertz <git@jeanmertz.com>
---
 Cargo.lock                                    |  1 +
 lib/remap-tests/Cargo.toml                    |  1 +
 lib/remap-tests/README.md                     | 58 +++++++++++++++++++
 lib/remap-tests/src/main.rs                   | 37 ++++++++----
 lib/remap-tests/tests/README.md               | 51 ++++++++++++++++
 lib/remap-tests/tests/diagnostics/README.md   | 22 +++++++
 .../call_to_undefined_function.vrl}           |  0
 ..._abort_function_call_that_never_fails.vrl} |  0
 .../function_argument_arity_mismatch.vrl}     |  0
 .../function_argument_missing.vrl}            |  0
 .../invalid_if_condition_type.vrl}            |  0
 .../path_based_variable_assignment.vrl}       |  0
 ..._aborted_internal_function_call_error.vrl} |  0
 ...program_aborted_invalid_argument_type.vrl} |  0
 .../regex_parsing_unsuccessful.vrl}           |  0
 .../syntax_error_path_segment.vrl}            |  0
 .../unhandled_error.vrl}                      |  0
 .../unknown_function_argument_keyword.vrl}    |  0
 .../unneeded_error_assignment.vrl}            |  0
 lib/remap-tests/tests/example.vrl             |  5 +-
 lib/remap-tests/tests/examples/README.md      |  7 +++
 lib/remap-tests/tests/expressions/README.md   | 17 ++++++
 .../expressions/arithmetic/addition/float.vrl |  4 ++
 .../arithmetic/addition/float_int.vrl         |  4 ++
 .../arithmetic/addition/integer.vrl           |  4 ++
 lib/remap-tests/tests/fixme/README.md         | 25 ++++++++
 .../arithmetic_addition_integer_float.vrl     | 11 ++++
 ...ithmetic_incorrectly_marked_infallible.vrl | 11 ++++
 .../infallible_ok_incorrect_type_def.vrl      | 12 ++++
 lib/remap-tests/tests/functions/README.md     |  6 ++
 lib/remap-tests/tests/issues/README.md        | 10 ++++
 31 files changed, 273 insertions(+), 13 deletions(-)
 create mode 100644 lib/remap-tests/README.md
 create mode 100644 lib/remap-tests/tests/README.md
 create mode 100644 lib/remap-tests/tests/diagnostics/README.md
 rename lib/remap-tests/tests/{function_call_undefined.vrl => diagnostics/call_to_undefined_function.vrl} (100%)
 rename lib/remap-tests/tests/{function_call_abort_infallible.vrl => diagnostics/cannot_abort_function_call_that_never_fails.vrl} (100%)
 rename lib/remap-tests/tests/{funtion_call_arity_mismatch.vrl => diagnostics/function_argument_arity_mismatch.vrl} (100%)
 rename lib/remap-tests/tests/{function_call_missing_argument.vrl => diagnostics/function_argument_missing.vrl} (100%)
 rename lib/remap-tests/tests/{if_statement_non_boolean_condition.vrl => diagnostics/invalid_if_condition_type.vrl} (100%)
 rename lib/remap-tests/tests/{assignment_variable_with_path.vrl => diagnostics/path_based_variable_assignment.vrl} (100%)
 rename lib/remap-tests/tests/{function_call_internal_error.vrl => diagnostics/program_aborted_internal_function_call_error.vrl} (100%)
 rename lib/remap-tests/tests/{function_call_invalid_argument_type.vrl => diagnostics/program_aborted_invalid_argument_type.vrl} (100%)
 rename lib/remap-tests/tests/{regex_invalid.vrl => diagnostics/regex_parsing_unsuccessful.vrl} (100%)
 rename lib/remap-tests/tests/{invalid_path.vrl => diagnostics/syntax_error_path_segment.vrl} (100%)
 rename lib/remap-tests/tests/{fallible_root_expression.vrl => diagnostics/unhandled_error.vrl} (100%)
 rename lib/remap-tests/tests/{function_call_unknown_keyword.vrl => diagnostics/unknown_function_argument_keyword.vrl} (100%)
 rename lib/remap-tests/tests/{assignment_fallible_for_infallible_expression.vrl => diagnostics/unneeded_error_assignment.vrl} (100%)
 create mode 100644 lib/remap-tests/tests/examples/README.md
 create mode 100644 lib/remap-tests/tests/expressions/README.md
 create mode 100644 lib/remap-tests/tests/expressions/arithmetic/addition/float.vrl
 create mode 100644 lib/remap-tests/tests/expressions/arithmetic/addition/float_int.vrl
 create mode 100644 lib/remap-tests/tests/expressions/arithmetic/addition/integer.vrl
 create mode 100644 lib/remap-tests/tests/fixme/README.md
 create mode 100644 lib/remap-tests/tests/fixme/arithmetic_addition_integer_float.vrl
 create mode 100644 lib/remap-tests/tests/fixme/division_arithmetic_incorrectly_marked_infallible.vrl
 create mode 100644 lib/remap-tests/tests/fixme/infallible_ok_incorrect_type_def.vrl
 create mode 100644 lib/remap-tests/tests/functions/README.md
 create mode 100644 lib/remap-tests/tests/issues/README.md

diff --git a/Cargo.lock b/Cargo.lock
index 9a9b4138c77ba..bdbde46f4c8c1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5380,6 +5380,7 @@ name = "remap-tests"
 version = "0.1.0"
 dependencies = [
  "ansi_term 0.12.1",
+ "glob 0.3.0",
  "prettydiff",
  "remap-functions",
  "remap-lang",
diff --git a/lib/remap-tests/Cargo.toml b/lib/remap-tests/Cargo.toml
index 1e1b730dfc2c0..c44c6b48ce9a9 100644
--- a/lib/remap-tests/Cargo.toml
+++ b/lib/remap-tests/Cargo.toml
@@ -7,6 +7,7 @@ publish = false
 
 [dependencies]
 ansi_term = "0.12"
+glob = "0.3"
 prettydiff = "0.4"
 remap = { package = "remap-lang", path = "../remap-lang" }
 remap-functions = { path = "../remap-functions" }
diff --git a/lib/remap-tests/README.md b/lib/remap-tests/README.md
new file mode 100644
index 0000000000000..1cdcc3962f1d5
--- /dev/null
+++ b/lib/remap-tests/README.md
@@ -0,0 +1,58 @@
+# Vector Remap Language Test Harness
+
+This test harness allows us to run a variety of test cases against the latest
+build of VRL.
+
+The goal is to make it as simple as possible for other contributors to expand
+our test coverage, without the requirement to know anything about the internals
+of VRL itself, or the language in which VRL is built (Rust).
+
+## Adding Tests
+
+New tests are added in the [`tests`](./tests) sub-directory. There's an
+[`example.vrl`](./tests/example.vrl) file to show the general structure of a
+test case.
+
+Each directory inside the test directory has its own documentation to explain
+which tests go where.
+
+## Q&A
+
+- **How can I run these tests locally?**
+
+  For now, you need to have [Rust](https://www.rust-lang.org/) installed, and
+  then run `cargo run` in this directory.
+
+  You can also use [cargo-watch](https://crates.io/crates/cargo-watch) to
+  continuously run the tests as you make changes to VRL or the tests themselves.
+
+- **How does the CLI work?**
+
+  It's fairly basic right now. There's no `--help`, but you can provide
+  `--verbose` to see the output of each test regardless if it failed or
+  succeeded.
+
+  Note that, when using Cargo, you need to run `cargo run -- --verbose`.
+
+- **Can I add any test I want?**
+
+  Yes! If you submit a test, we might ask you to move it to a different
+  directory, rename it, or add a few tweaks, but in general, the more tests the
+  better.
+
+- **I don't know how to add a test, but would like to contribute!**
+
+  If the existing documentation isn't clear enough, then feel free to open an
+  issue describing what's unclear. We'll help you out in the issue and make sure
+  to improve the documentation for future contributors.
+
+- **I've made changes to VRL, resulting in many broken tests!**
+
+  This is an unfortunate — but expected — side-effect of using "UI testing".
+
+  We're planning on adding a `--update-tests` flag to mass-update existing tests
+  in one go, but until then, you'll have to update tests manually.
+
+  If you have a large number of failing tests, please open an issue, as it might
+  be less work to add the above-mentioned flag, than to update the tests
+  manually.
diff --git a/lib/remap-tests/src/main.rs b/lib/remap-tests/src/main.rs
index 0c9ed7ba80d58..eb9910b4d1f32 100644
--- a/lib/remap-tests/src/main.rs
+++ b/lib/remap-tests/src/main.rs
@@ -1,4 +1,5 @@
 use ansi_term::Colour;
+use glob::glob;
 use remap::{diagnostic::Formatter, prelude::*, Program, Runtime};
 use std::fs;
 use std::path::PathBuf;
@@ -10,12 +11,15 @@ fn main() {
         .unwrap_or_default();
 
     let mut failed_count = 0;
-    let tests = fs::read_dir("tests").expect("dir exists");
+    for entry in glob("tests/**/*.vrl").expect("valid pattern") {
+        let path = match entry {
+            Ok(path) => path,
+            Err(_) => continue,
+        };
 
-    for file in tests {
-        let mut test = Test::new(file.expect("file").path());
+        let mut test = Test::new(path);
 
-        print!("{:.<60}", test.name);
+        print!("{:.<70}", test.name);
 
         if test.skip {
             println!("{}", Colour::Yellow.bold().paint("SKIPPED"));
@@ -36,15 +40,18 @@ fn main() {
                         let got = value.to_string();
 
                         if got == want {
-                            println!("{}", Colour::Green.bold().paint("OK"));
+                            if !test.skip {
+                                println!("{}", Colour::Green.bold().paint("OK"));
+                            }
                         } else {
-                            println!("{} (expectation)", Colour::Red.bold().paint("FAILED"));
+                            if !test.skip {
+                                println!("{} (expectation)", Colour::Red.bold().paint("FAILED"));
+                                failed_count += 1;
+                            }
 
                             let diff =
                                 prettydiff::diff_chars(&want, &got).set_highlight_whitespace(true);
                             println!("  {}", diff);
-
-                            failed_count += 1;
                         }
 
                         if verbose {
@@ -58,9 +65,14 @@ fn main() {
                         let want = want.trim().to_owned();
 
                         if got == want {
-                            println!("{}", Colour::Green.bold().paint("OK"));
+                            if !test.skip {
+                                println!("{}", Colour::Green.bold().paint("OK"));
+                            }
                         } else {
-                            println!("{} (runtime)", Colour::Red.bold().paint("FAILED"));
+                            if !test.skip {
+                                println!("{} (runtime)", Colour::Red.bold().paint("FAILED"));
+                                failed_count += 1;
+                            }
 
                             let diff = prettydiff::diff_lines(&want, &got);
                             println!("{}", diff);
@@ -80,7 +92,10 @@ fn main() {
                 if got == want {
                     println!("{}", Colour::Green.bold().paint("OK"));
                 } else {
-                    println!("{} (compilation)", Colour::Red.bold().paint("FAILED"));
+                    if !test.skip {
+                        println!("{} (compilation)", Colour::Red.bold().paint("FAILED"));
+                        failed_count += 1;
+                    }
 
                     let diff = prettydiff::diff_lines(&want, &got);
                     println!("{}", diff);
diff --git a/lib/remap-tests/tests/README.md b/lib/remap-tests/tests/README.md
new file mode 100644
index 0000000000000..6480acf03a871
--- /dev/null
+++ b/lib/remap-tests/tests/README.md
@@ -0,0 +1,51 @@
+# Tests
+
+This directory contains all the behavior tests for Vector Remap Language.
+
+The tests are split up into different categories.
+
+## Expressions
+
+Contains tests for all built-in expressions.
+
+_See the [documentation](./expressions/README.md) inside the directory for more
+details._
+
+## Functions
+
+Contains tests for individual functions.
+
+_See the [documentation](./functions/README.md) inside the directory for more
+details._
+
+## Diagnostics
+
+Contains tests that validate our diagnostic error messages.
+
+_See the [documentation](./diagnostics/README.md) inside the directory for more
+details._
+
+## Examples
+
+Contains a random set of more expansive test-cases that test a collection of
+different features combined together.
+
+_See the [documentation](./examples/README.md) inside the directory for more
+details._
+
+## Issues
+
+Contains tests that validate a previous issue that has since been fixed.
+
+_See the [documentation](./issues/README.md) inside the directory for more
+details._
+
+## Fix Me
+
+Contains tests that demonstrate an open bug in VRL.
+
+These tests are disabled by default, but are created to keep track of these bugs
+in our test suite until they are fixed. Ideally this directory is empty.
+
+_See the [documentation](./fixme/README.md) inside the directory for more
+details._
diff --git a/lib/remap-tests/tests/diagnostics/README.md b/lib/remap-tests/tests/diagnostics/README.md
new file mode 100644
index 0000000000000..a83b866a75d28
--- /dev/null
+++ b/lib/remap-tests/tests/diagnostics/README.md
@@ -0,0 +1,22 @@
+# Diagnostics
+
+This directory contains tests that validate the output of our diagnostic
+messages.
+
+The name of the file should preferably be similar to the title of the diagnostic
+message.
+
+A diagnostic message is shown at compile-time, similar to this example:
+
+```text
+error: unneeded error assignment
+  ┌─ :2:1
+  │
+2 │ ok, err = 5;
+  │ ^^^^^^^   - because this expression cannot fail
+  │ │
+  │ this error assignment is unneeded
+  │
+  = hint: assign to "ok", without assigning to "err"
+  = see language documentation at: https://vector.dev/docs/reference/vrl/
+```
diff --git a/lib/remap-tests/tests/function_call_undefined.vrl b/lib/remap-tests/tests/diagnostics/call_to_undefined_function.vrl
similarity index 100%
rename from lib/remap-tests/tests/function_call_undefined.vrl
rename to lib/remap-tests/tests/diagnostics/call_to_undefined_function.vrl
diff --git a/lib/remap-tests/tests/function_call_abort_infallible.vrl b/lib/remap-tests/tests/diagnostics/cannot_abort_function_call_that_never_fails.vrl
similarity index 100%
rename from lib/remap-tests/tests/function_call_abort_infallible.vrl
rename to lib/remap-tests/tests/diagnostics/cannot_abort_function_call_that_never_fails.vrl
diff --git a/lib/remap-tests/tests/funtion_call_arity_mismatch.vrl b/lib/remap-tests/tests/diagnostics/function_argument_arity_mismatch.vrl
similarity index 100%
rename from lib/remap-tests/tests/funtion_call_arity_mismatch.vrl
rename to lib/remap-tests/tests/diagnostics/function_argument_arity_mismatch.vrl
diff --git a/lib/remap-tests/tests/function_call_missing_argument.vrl b/lib/remap-tests/tests/diagnostics/function_argument_missing.vrl
similarity index 100%
rename from lib/remap-tests/tests/function_call_missing_argument.vrl
rename to lib/remap-tests/tests/diagnostics/function_argument_missing.vrl
diff --git a/lib/remap-tests/tests/if_statement_non_boolean_condition.vrl b/lib/remap-tests/tests/diagnostics/invalid_if_condition_type.vrl
similarity index 100%
rename from lib/remap-tests/tests/if_statement_non_boolean_condition.vrl
rename to lib/remap-tests/tests/diagnostics/invalid_if_condition_type.vrl
diff --git a/lib/remap-tests/tests/assignment_variable_with_path.vrl b/lib/remap-tests/tests/diagnostics/path_based_variable_assignment.vrl
similarity index 100%
rename from lib/remap-tests/tests/assignment_variable_with_path.vrl
rename to lib/remap-tests/tests/diagnostics/path_based_variable_assignment.vrl
diff --git a/lib/remap-tests/tests/function_call_internal_error.vrl b/lib/remap-tests/tests/diagnostics/program_aborted_internal_function_call_error.vrl
similarity index 100%
rename from lib/remap-tests/tests/function_call_internal_error.vrl
rename to lib/remap-tests/tests/diagnostics/program_aborted_internal_function_call_error.vrl
diff --git a/lib/remap-tests/tests/function_call_invalid_argument_type.vrl b/lib/remap-tests/tests/diagnostics/program_aborted_invalid_argument_type.vrl
similarity index 100%
rename from lib/remap-tests/tests/function_call_invalid_argument_type.vrl
rename to lib/remap-tests/tests/diagnostics/program_aborted_invalid_argument_type.vrl
diff --git a/lib/remap-tests/tests/regex_invalid.vrl b/lib/remap-tests/tests/diagnostics/regex_parsing_unsuccessful.vrl
similarity index 100%
rename from lib/remap-tests/tests/regex_invalid.vrl
rename to lib/remap-tests/tests/diagnostics/regex_parsing_unsuccessful.vrl
diff --git a/lib/remap-tests/tests/invalid_path.vrl b/lib/remap-tests/tests/diagnostics/syntax_error_path_segment.vrl
similarity index 100%
rename from lib/remap-tests/tests/invalid_path.vrl
rename to lib/remap-tests/tests/diagnostics/syntax_error_path_segment.vrl
diff --git a/lib/remap-tests/tests/fallible_root_expression.vrl b/lib/remap-tests/tests/diagnostics/unhandled_error.vrl
similarity index 100%
rename from lib/remap-tests/tests/fallible_root_expression.vrl
rename to lib/remap-tests/tests/diagnostics/unhandled_error.vrl
diff --git a/lib/remap-tests/tests/function_call_unknown_keyword.vrl b/lib/remap-tests/tests/diagnostics/unknown_function_argument_keyword.vrl
similarity index 100%
rename from lib/remap-tests/tests/function_call_unknown_keyword.vrl
rename to lib/remap-tests/tests/diagnostics/unknown_function_argument_keyword.vrl
diff --git a/lib/remap-tests/tests/assignment_fallible_for_infallible_expression.vrl b/lib/remap-tests/tests/diagnostics/unneeded_error_assignment.vrl
similarity index 100%
rename from lib/remap-tests/tests/assignment_fallible_for_infallible_expression.vrl
rename to lib/remap-tests/tests/diagnostics/unneeded_error_assignment.vrl
diff --git a/lib/remap-tests/tests/example.vrl b/lib/remap-tests/tests/example.vrl
index 0b7c25c28ca9e..57cfe2f33b8c1 100644
--- a/lib/remap-tests/tests/example.vrl
+++ b/lib/remap-tests/tests/example.vrl
@@ -1,6 +1,7 @@
-# object: { "bar": "bar" }
-# result: { "bar": "foo", "foo": "test" }
+# object: { "bar": "bar", "baz": true }
+# result: { "bar": "foo", "baz": 5, "foo": "test" }
 
 .foo = "test"
 .bar = "foo"
+.baz = (to_int(.baz) ?? 0) + 4
 .
diff --git a/lib/remap-tests/tests/examples/README.md b/lib/remap-tests/tests/examples/README.md
new file mode 100644
index 0000000000000..6ec64043aad60
--- /dev/null
+++ b/lib/remap-tests/tests/examples/README.md
@@ -0,0 +1,7 @@
+# Examples
+
+This directory contains tests that group together multiple language features and
+functions to demonstrate the (correct) usage of read-world usage examples.
+
+Any programs we consider important enough to continuously validate can be added
+in this directory to put under test coverage.
diff --git a/lib/remap-tests/tests/expressions/README.md b/lib/remap-tests/tests/expressions/README.md
new file mode 100644
index 0000000000000..b61cbd0cea6cf
--- /dev/null
+++ b/lib/remap-tests/tests/expressions/README.md
@@ -0,0 +1,17 @@
+# Expressions
+
+This directory contains tests validating the correct behavior of all existing
+expression types, such as:
+
+* arithmetic
+* assignment
+* block
+* function call
+* group
+* if statement
+* literals
+* path query
+* variable
+
+Each expression type has its own sub-directory. This top-level directory should
+not contain any tests.
diff --git a/lib/remap-tests/tests/expressions/arithmetic/addition/float.vrl b/lib/remap-tests/tests/expressions/arithmetic/addition/float.vrl
new file mode 100644
index 0000000000000..1ddb8e1203804
--- /dev/null
+++ b/lib/remap-tests/tests/expressions/arithmetic/addition/float.vrl
@@ -0,0 +1,4 @@
+# object: {}
+# result: 2.7
+
+1.4 + 1.3
diff --git a/lib/remap-tests/tests/expressions/arithmetic/addition/float_int.vrl b/lib/remap-tests/tests/expressions/arithmetic/addition/float_int.vrl
new file mode 100644
index 0000000000000..f76bc0fe2cb9f
--- /dev/null
+++ b/lib/remap-tests/tests/expressions/arithmetic/addition/float_int.vrl
@@ -0,0 +1,4 @@
+# object: {}
+# result: 2.3
+
+1.3 + 1
diff --git a/lib/remap-tests/tests/expressions/arithmetic/addition/integer.vrl b/lib/remap-tests/tests/expressions/arithmetic/addition/integer.vrl
new file mode 100644
index 0000000000000..973160fc571af
--- /dev/null
+++ b/lib/remap-tests/tests/expressions/arithmetic/addition/integer.vrl
@@ -0,0 +1,4 @@
+# object: {}
+# result: 2
+
+1 + 1
diff --git a/lib/remap-tests/tests/fixme/README.md b/lib/remap-tests/tests/fixme/README.md
new file mode 100644
index 0000000000000..1a8fee6143bb2
--- /dev/null
+++ b/lib/remap-tests/tests/fixme/README.md
@@ -0,0 +1,25 @@
+# Fix Me
+
+This directory contains tests that show a bug in VRL that needs to be resolved.
+
+The first line in these tests should start with:
+
+```ruby
+# SKIP
+```
+
+This allows the test harness to skip the tests (but still list them as being
+skipped).
+
+The second line should provide a link to the open relevant tracking issue:
+
+```text
+issue: <link to issue>
+```
+
+Usually the file name of the test should be similar to the title of the linked
+issue, shortened for brevity.
+
+Once an issue has been resolved, the test should be moved to `tests/issues` and
+the `# SKIP` line should be removed. This ensures we keep a trail to the
+original issue, and our test-harness captures any regressions in the future.
diff --git a/lib/remap-tests/tests/fixme/arithmetic_addition_integer_float.vrl b/lib/remap-tests/tests/fixme/arithmetic_addition_integer_float.vrl
new file mode 100644
index 0000000000000..bfa9074cfc97e
--- /dev/null
+++ b/lib/remap-tests/tests/fixme/arithmetic_addition_integer_float.vrl
@@ -0,0 +1,11 @@
+# SKIP
+#
+# This incorrectly converts the rhs float to an integer, because the lhs is an
+# integer as well.
+#
+# Instead, the lhs should be converted to a float.
+#
+# object: {}
+# result: 2.3
+
+1 + 1.3
diff --git a/lib/remap-tests/tests/fixme/division_arithmetic_incorrectly_marked_infallible.vrl b/lib/remap-tests/tests/fixme/division_arithmetic_incorrectly_marked_infallible.vrl
new file mode 100644
index 0000000000000..de4498d91fc89
--- /dev/null
+++ b/lib/remap-tests/tests/fixme/division_arithmetic_incorrectly_marked_infallible.vrl
@@ -0,0 +1,11 @@
+# SKIP
+#
+# Division is a fallible operation, because division by 0 fails.
+#
+# It currently is marked as infallible, which in turn prevents us from using
+# the fallible assignment operation.
+#
+# object: {}
+# result: TODO
+
+ok, err = 1 / 0
diff --git a/lib/remap-tests/tests/fixme/infallible_ok_incorrect_type_def.vrl b/lib/remap-tests/tests/fixme/infallible_ok_incorrect_type_def.vrl
new file mode 100644
index 0000000000000..29755de7dff68
--- /dev/null
+++ b/lib/remap-tests/tests/fixme/infallible_ok_incorrect_type_def.vrl
@@ -0,0 +1,12 @@
+# SKIP
+#
+# This test should result in an error, because .foo is either "string" or
+# "null", because we don't know at compile-time if the downcase call succeeds
+# or not.
+#
+# object: { "foo": "bar" }
+# result: TODO
+
+.foo # any
+.foo, err = downcase(.foo) # string
+.foo = upcase(.foo) # string
diff --git a/lib/remap-tests/tests/functions/README.md b/lib/remap-tests/tests/functions/README.md
new file mode 100644
index 0000000000000..24e259ed5bb0b
--- /dev/null
+++ b/lib/remap-tests/tests/functions/README.md
@@ -0,0 +1,6 @@
+# Functions
+
+All functions shipped with VRL are tested here.
+
+Since some functions require multiple test cases, each function has its own
+sub-directory, even if one test case is sufficient.
diff --git a/lib/remap-tests/tests/issues/README.md b/lib/remap-tests/tests/issues/README.md
new file mode 100644
index 0000000000000..451d045843187
--- /dev/null
+++ b/lib/remap-tests/tests/issues/README.md
@@ -0,0 +1,10 @@
+# Issues
+
+This directory contains tests to validate an issue reported in our issue tracker
+is indeed fixed and hasn't regressed.
+
+The first line of each test should include the line:
+
+```text
+issue: <link to issue>
+```

From 3b92e4b3d7e3b62f06ca76df0650067e1ee3517d Mon Sep 17 00:00:00 2001
From: Kirill Fomichev <fanatid@ya.ru>
Date: Tue, 19 Jan 2021 13:24:42 +0300
Subject: [PATCH 14/19] chore(deps): update (#6106)

Signed-off-by: Kirill Fomichev <fanatid@ya.ru>
---
 Cargo.lock                     | 20 +++++++++-----------
 Cargo.toml                     |  2 +-
 lib/file-source/Cargo.toml     |  3 +--
 lib/file-source/src/lib.rs     | 27 +++++++++++++++++----------
 lib/remap-functions/Cargo.toml |  2 +-
 5 files changed, 29 insertions(+), 25 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index bdbde46f4c8c1..944b396f2f700 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1833,9 +1833,9 @@ dependencies = [
 
 [[package]]
 name = "env_logger"
-version = "0.7.1"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44533bbbb3bb3c1fa17d9f2e4e38bbbaf8396ba82193c4cb1b6445d711445d36"
+checksum = "f26ecb66b4bdca6c1409b40fb255eefc2bd4f6d135dab3c3124f80ffa2a9661e"
 dependencies = [
  "log",
  "regex",
@@ -1965,7 +1965,6 @@ dependencies = [
  "indexmap",
  "libc",
  "quickcheck",
- "rand 0.7.3",
  "scan_fmt",
  "serde",
  "serde_json",
@@ -4905,14 +4904,13 @@ checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
 
 [[package]]
 name = "quickcheck"
-version = "0.9.2"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a44883e74aa97ad63db83c4bf8ca490f02b2fc02f92575e720c8551e843c945f"
+checksum = "588f6378e4dd99458b60ec275b4477add41ce4fa9f64dcba6f15adccb19b50d6"
 dependencies = [
- "env_logger 0.7.1",
+ "env_logger 0.8.2",
  "log",
- "rand 0.7.3",
- "rand_core 0.5.1",
+ "rand 0.8.2",
 ]
 
 [[package]]
@@ -6608,12 +6606,12 @@ dependencies = [
 
 [[package]]
 name = "syslog_loose"
-version = "0.7.0"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59105a46f64e6e0c60a07061ffd07ef42d137735b5d9796572fe969b21342772"
+checksum = "7981176aaf014836371693ebc7e254e865bb2dafa9f7d71943fbde7c87640e35"
 dependencies = [
  "chrono",
- "nom 5.1.2",
+ "nom 6.0.1",
 ]
 
 [[package]]
diff --git a/Cargo.toml b/Cargo.toml
index 0660871ddf44d..9df20e6c50cf1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -149,7 +149,7 @@ http = "0.2"
 typetag = "0.1.6"
 toml = "0.5.8"
 syslog = "5"
-syslog_loose = "0.7.0"
+syslog_loose = "0.8.0"
 leveldb = { version = "0.8", optional = true, default-features = false }
 db-key = "0.0.5"
 headers = "0.3"
diff --git a/lib/file-source/Cargo.toml b/lib/file-source/Cargo.toml
index de0c08558df6d..de4ab6fd4569f 100644
--- a/lib/file-source/Cargo.toml
+++ b/lib/file-source/Cargo.toml
@@ -24,6 +24,5 @@ chrono = { version = "0.4.19", features = ["serde"] }
 dashmap = "4.0.0"
 
 [dev-dependencies]
-quickcheck = "0.9"
-rand = "0.7"
+quickcheck = "1"
 tempfile = "3.1.0"
diff --git a/lib/file-source/src/lib.rs b/lib/file-source/src/lib.rs
index 8d86adb395cf8..4e38cd2874b3e 100644
--- a/lib/file-source/src/lib.rs
+++ b/lib/file-source/src/lib.rs
@@ -22,7 +22,6 @@ mod test {
     use self::file_watcher::FileWatcher;
     use super::*;
     use quickcheck::{Arbitrary, Gen, QuickCheck, TestResult};
-    use rand::{distributions::Alphanumeric, Rng};
     use std::fs;
     use std::io::Write;
     #[cfg(unix)]
@@ -166,20 +165,28 @@ mod test {
     }
 
     impl Arbitrary for FWAction {
-        fn arbitrary<G>(g: &mut G) -> FWAction
-        where
-            G: Gen,
-        {
-            let i: usize = g.gen_range(0, 100);
-            let ln_sz = g.gen_range(1, 32);
-            let pause = g.gen_range(1, 3);
+        fn arbitrary(g: &mut Gen) -> FWAction {
+            let i: usize = *g.choose(&(0..100).collect::<Vec<_>>()).unwrap();
             match i {
                 // These weights are more or less arbitrary. 'Pause' maybe
                 // doesn't have a use but we keep it in place to allow for
                 // variations in file-system flushes.
-                0..=50 => FWAction::WriteLine(g.sample_iter(&Alphanumeric).take(ln_sz).collect()),
+                0..=50 => {
+                    const GEN_ASCII_STR_CHARSET: &[u8] =
+                        b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+                    let ln_sz = *g.choose(&(1..32).collect::<Vec<_>>()).unwrap();
+                    FWAction::WriteLine(
+                        std::iter::repeat_with(|| *g.choose(&GEN_ASCII_STR_CHARSET).unwrap())
+                            .take(ln_sz)
+                            .map(|v| -> char { v.into() })
+                            .collect(),
+                    )
+                }
                 51..=69 => FWAction::Read,
-                70..=75 => FWAction::Pause(pause),
+                70..=75 => {
+                    let pause = *g.choose(&(1..3).collect::<Vec<_>>()).unwrap();
+                    FWAction::Pause(pause)
+                }
                 76..=85 => FWAction::RotateFile,
                 86..=90 => FWAction::TruncateFile,
                 91..=95 => FWAction::DeleteFile,
diff --git a/lib/remap-functions/Cargo.toml b/lib/remap-functions/Cargo.toml
index 6e267e99d3b9c..f1dfc5aa8e6f8 100644
--- a/lib/remap-functions/Cargo.toml
+++ b/lib/remap-functions/Cargo.toml
@@ -26,7 +26,7 @@ sha-2 = { package = "sha2", version = "0.9", optional = true }
 sha-3 = { package = "sha3", version = "0.9", optional = true }
 shared = { path = "../shared", default-features = false, optional = true }
 strip-ansi-escapes = { version = "0.1", optional = true }
-syslog_loose = { version = "0.7", optional = true }
+syslog_loose = { version = "0.8", optional = true }
 tracing = { version = "0.1", optional = true }
 url = { version = "2", optional = true }
 uuid = { version = "0.8", features = ["v4"], optional = true }

From f33a2a4c03d1d8bfd3f1c22403964a1afb636377 Mon Sep 17 00:00:00 2001
From: Lee Benson <lee@leebenson.com>
Date: Tue, 19 Jan 2021 13:39:54 +0000
Subject: [PATCH 15/19] enhancement(graphql api): API sorting, starting with
 `components` (#6115)

* filtering wip

Signed-off-by: Lee Benson <lee@leebenson.com>

* StringFilter

Signed-off-by: Lee Benson <lee@leebenson.com>

* import

Signed-off-by: Lee Benson <lee@leebenson.com>

* tweaks

Signed-off-by: Lee Benson <lee@leebenson.com>

* -smallvec

Signed-off-by: Lee Benson <lee@leebenson.com>

* EqualityFilter

Signed-off-by: Lee Benson <lee@leebenson.com>

* sinks/transforms/sources

Signed-off-by: Lee Benson <lee@leebenson.com>

* component_type

Signed-off-by: Lee Benson <lee@leebenson.com>

* schema

Signed-off-by: Lee Benson <lee@leebenson.com>

* FileSourceMetricsFilesFilter

Signed-off-by: Lee Benson <lee@leebenson.com>

* schema

Signed-off-by: Lee Benson <lee@leebenson.com>

* merge

Signed-off-by: Lee Benson <lee@leebenson.com>

* tests

Signed-off-by: Lee Benson <lee@leebenson.com>

* more tests

Signed-off-by: Lee Benson <lee@leebenson.com>

* improved filter

Signed-off-by: Lee Benson <lee@leebenson.com>

* filter_item

Signed-off-by: Lee Benson <lee@leebenson.com>

* lockfile

Signed-off-by: Lee Benson <lee@leebenson.com>

* initial sort

Signed-off-by: Lee Benson <lee@leebenson.com>

* tweaks

Signed-off-by: Lee Benson <lee@leebenson.com>

* std::cmp

Signed-off-by: Lee Benson <lee@leebenson.com>

* tests

Signed-off-by: Lee Benson <lee@leebenson.com>

* Ordering

Signed-off-by: Lee Benson <lee@leebenson.com>

* fold_while

Signed-off-by: Lee Benson <lee@leebenson.com>

* default ASC

Signed-off-by: Lee Benson <lee@leebenson.com>
---
 lib/vector-api-client/graphql/schema.json | 244 ++++++++++++++++++++--
 src/api/schema/components/mod.rs          | 154 ++++++++++++--
 src/api/schema/filter.rs                  |   4 +-
 src/api/schema/mod.rs                     |   1 +
 src/api/schema/sort.rs                    |  51 +++++
 5 files changed, 419 insertions(+), 35 deletions(-)
 create mode 100644 src/api/schema/sort.rs

diff --git a/lib/vector-api-client/graphql/schema.json b/lib/vector-api-client/graphql/schema.json
index ee8ac69688064..2c06ac1594588 100644
--- a/lib/vector-api-client/graphql/schema.json
+++ b/lib/vector-api-client/graphql/schema.json
@@ -5,9 +5,7 @@
         {
           "args": [],
           "description": "Directs the executor to query only when the field exists.",
-          "locations": [
-            "FIELD"
-          ],
+          "locations": ["FIELD"],
           "name": "ifdef"
         },
         {
@@ -28,11 +26,7 @@
             }
           ],
           "description": "Directs the executor to include this field or fragment only when the `if` argument is true.",
-          "locations": [
-            "FIELD",
-            "FRAGMENT_SPREAD",
-            "INLINE_FRAGMENT"
-          ],
+          "locations": ["FIELD", "FRAGMENT_SPREAD", "INLINE_FRAGMENT"],
           "name": "include"
         },
         {
@@ -53,11 +47,7 @@
             }
           ],
           "description": "Directs the executor to skip this field or fragment when the `if` argument is true.",
-          "locations": [
-            "FIELD",
-            "FRAGMENT_SPREAD",
-            "INLINE_FRAGMENT"
-          ],
+          "locations": ["FIELD", "FRAGMENT_SPREAD", "INLINE_FRAGMENT"],
           "name": "skip"
         }
       ],
@@ -283,6 +273,66 @@
           "name": "ComponentErrorsTotal",
           "possibleTypes": null
         },
+        {
+          "description": null,
+          "enumValues": [
+            {
+              "deprecationReason": null,
+              "description": null,
+              "isDeprecated": false,
+              "name": "SOURCE"
+            },
+            {
+              "deprecationReason": null,
+              "description": null,
+              "isDeprecated": false,
+              "name": "TRANSFORM"
+            },
+            {
+              "deprecationReason": null,
+              "description": null,
+              "isDeprecated": false,
+              "name": "SINK"
+            }
+          ],
+          "fields": null,
+          "inputFields": null,
+          "interfaces": null,
+          "kind": "ENUM",
+          "name": "ComponentKind",
+          "possibleTypes": null
+        },
+        {
+          "description": null,
+          "enumValues": null,
+          "fields": null,
+          "inputFields": [
+            {
+              "defaultValue": null,
+              "description": null,
+              "name": "equals",
+              "type": {
+                "kind": "ENUM",
+                "name": "ComponentKind",
+                "ofType": null
+              }
+            },
+            {
+              "defaultValue": null,
+              "description": null,
+              "name": "notEquals",
+              "type": {
+                "kind": "ENUM",
+                "name": "ComponentKind",
+                "ofType": null
+              }
+            }
+          ],
+          "interfaces": null,
+          "kind": "INPUT_OBJECT",
+          "name": "ComponentKindFilter",
+          "possibleTypes": null
+        },
         {
           "description": null,
           "enumValues": null,
@@ -580,6 +630,133 @@
           "name": "ComponentsFilter",
           "possibleTypes": null
         },
+        {
+          "description": null,
+          "enumValues": null,
+          "fields": null,
+          "inputFields": [
+            {
+              "defaultValue": null,
+              "description": null,
+              "name": "name",
+              "type": {
+                "kind": "LIST",
+                "name": null,
+                "ofType": {
+                  "kind": "NON_NULL",
+                  "name": null,
+                  "ofType": {
+                    "kind": "INPUT_OBJECT",
+                    "name": "StringFilter",
+                    "ofType": null
+                  }
+                }
+              }
+            },
+            {
+              "defaultValue": null,
+              "description": null,
+              "name": "componentKind",
+              "type": {
+                "kind": "LIST",
+                "name": null,
+                "ofType": {
+                  "kind": "NON_NULL",
+                  "name": null,
+                  "ofType": {
+                    "kind": "INPUT_OBJECT",
+                    "name": "ComponentKindFilter",
+                    "ofType": null
+                  }
+                }
+              }
+            },
+            {
+              "defaultValue": null,
+              "description": null,
+              "name": "or",
+              "type": {
+                "kind": "LIST",
+                "name": null,
+                "ofType": {
+                  "kind": "NON_NULL",
+                  "name": null,
+                  "ofType": {
+                    "kind": "INPUT_OBJECT",
+                    "name": "ComponentsFilter",
+                    "ofType": null
+                  }
+                }
+              }
+            }
+          ],
+          "interfaces": null,
+          "kind": "INPUT_OBJECT",
+          "name": "ComponentsFilter",
+          "possibleTypes": null
+        },
+        {
+          "description": null,
+          "enumValues": null,
+          "fields": null,
+          "inputFields": [
+            {
+              "defaultValue": null,
+              "description": null,
+              "name": "field",
+              "type": {
+                "kind": "NON_NULL",
+                "name": null,
+                "ofType": {
+                  "kind": "ENUM",
+                  "name": "ComponentsSortFieldName",
+                  "ofType": null
+                }
+              }
+            },
+            {
+              "defaultValue": null,
+              "description": null,
+              "name": "direction",
+              "type": {
+                "kind": "NON_NULL",
+                "name": null,
+                "ofType": {
+                  "kind": "ENUM",
+                  "name": "Direction",
+                  "ofType": null
+                }
+              }
+            }
+          ],
+          "interfaces": null,
+          "kind": "INPUT_OBJECT",
+          "name": "ComponentsSortField",
+          "possibleTypes": null
+        },
+        {
+          "description": null,
+          "enumValues": [
+            {
+              "deprecationReason": null,
+              "description": null,
+              "isDeprecated": false,
+              "name": "NAME"
+            },
+            {
+              "deprecationReason": null,
+              "description": null,
+              "isDeprecated": false,
+              "name": "COMPONENT_KIND"
+            }
+          ],
+          "fields": null,
+          "inputFields": null,
+          "interfaces": null,
+          "kind": "ENUM",
+          "name": "ComponentsSortFieldName",
+          "possibleTypes": null
+        },
         {
           "description": null,
           "enumValues": null,
@@ -617,6 +794,29 @@
           "name": "DateTime",
           "possibleTypes": null
         },
+        {
+          "description": null,
+          "enumValues": [
+            {
+              "deprecationReason": null,
+              "description": null,
+              "isDeprecated": false,
+              "name": "ASC"
+            },
+            {
+              "deprecationReason": null,
+              "description": null,
+              "isDeprecated": false,
+              "name": "DESC"
+            }
+          ],
+          "fields": null,
+          "inputFields": null,
+          "interfaces": null,
+          "kind": "ENUM",
+          "name": "Direction",
+          "possibleTypes": null
+        },
         {
           "description": null,
           "enumValues": null,
@@ -2036,6 +2236,24 @@
                     "name": "ComponentsFilter",
                     "ofType": null
                   }
+                },
+                {
+                  "defaultValue": null,
+                  "description": null,
+                  "name": "sort",
+                  "type": {
+                    "kind": "LIST",
+                    "name": null,
+                    "ofType": {
+                      "kind": "NON_NULL",
+                      "name": null,
+                      "ofType": {
+                        "kind": "INPUT_OBJECT",
+                        "name": "ComponentsSortField",
+                        "ofType": null
+                      }
+                    }
+                  }
                 }
               ],
               "deprecationReason": null,
diff --git a/src/api/schema/components/mod.rs b/src/api/schema/components/mod.rs
index 27d20a2d1e7cf..3dfba57a2ae16 100644
--- a/src/api/schema/components/mod.rs
+++ b/src/api/schema/components/mod.rs
@@ -7,14 +7,17 @@ use crate::{
     api::schema::{
         components::state::component_by_name,
         filter::{self, filter_items},
-        relay,
+        relay, sort,
     },
     config::Config,
     filter_check,
 };
 use async_graphql::{Enum, InputObject, Interface, Object, Subscription};
 use lazy_static::lazy_static;
-use std::collections::{HashMap, HashSet};
+use std::{
+    cmp,
+    collections::{HashMap, HashSet},
+};
 use tokio::stream::{Stream, StreamExt};
 
 #[derive(Debug, Clone, Interface)]
@@ -28,9 +31,8 @@ pub enum Component {
     Sink(sink::Sink),
 }
 
-#[derive(Enum, Copy, Clone, Eq, PartialEq)]
-/// Type of component
-pub enum ComponentType {
+#[derive(Enum, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
+pub enum ComponentKind {
     Source,
     Transform,
     Sink,
@@ -45,11 +47,11 @@ impl Component {
         }
     }
 
-    fn get_filter_type(&self) -> ComponentType {
+    fn get_component_kind(&self) -> ComponentKind {
         match self {
-            Component::Source(_) => ComponentType::Source,
-            Component::Transform(_) => ComponentType::Transform,
-            Component::Sink(_) => ComponentType::Sink,
+            Component::Source(_) => ComponentKind::Source,
+            Component::Transform(_) => ComponentKind::Transform,
+            Component::Sink(_) => ComponentKind::Sink,
         }
     }
 }
@@ -57,19 +59,25 @@ impl Component {
 #[derive(Default, InputObject)]
 pub struct ComponentsFilter {
     name: Option<Vec<filter::StringFilter>>,
-    component_type: Option<Vec<filter::EqualityFilter<ComponentType>>>,
+    component_kind: Option<Vec<filter::EqualityFilter<ComponentKind>>>,
     or: Option<Vec<Self>>,
 }
 
+#[derive(Enum, Copy, Clone, Eq, PartialEq)]
+pub enum ComponentsSortFieldName {
+    Name,
+    ComponentKind,
+}
+
 impl filter::CustomFilter<Component> for ComponentsFilter {
     fn matches(&self, component: &Component) -> bool {
         filter_check!(
             self.name
                 .as_ref()
                 .map(|f| f.iter().all(|f| f.filter_value(component.get_name()))),
-            self.component_type.as_ref().map(|f| f
+            self.component_kind.as_ref().map(|f| f
                 .iter()
-                .all(|f| f.filter_value(component.get_filter_type())))
+                .all(|f| f.filter_value(component.get_component_kind())))
         );
         true
     }
@@ -79,6 +87,17 @@ impl filter::CustomFilter<Component> for ComponentsFilter {
     }
 }
 
+impl sort::SortableByField<ComponentsSortFieldName> for Component {
+    fn sort(&self, rhs: &Self, field: &ComponentsSortFieldName) -> cmp::Ordering {
+        match field {
+            ComponentsSortFieldName::Name => Ord::cmp(self.get_name(), rhs.get_name()),
+            ComponentsSortFieldName::ComponentKind => {
+                Ord::cmp(&self.get_component_kind(), &rhs.get_component_kind())
+            }
+        }
+    }
+}
+
 #[derive(Default)]
 pub struct ComponentsQuery;
 
@@ -92,9 +111,14 @@ impl ComponentsQuery {
         first: Option<i32>,
         last: Option<i32>,
         filter: Option<ComponentsFilter>,
+        sort: Option<Vec<sort::SortField<ComponentsSortFieldName>>>,
     ) -> relay::ConnectionResult<Component> {
         let filter = filter.unwrap_or_else(ComponentsFilter::default);
-        let components = filter_items(state::get_components().into_iter(), &filter);
+        let mut components = filter_items(state::get_components().into_iter(), &filter);
+
+        if let Some(sort_fields) = sort {
+            sort::by_fields(&mut components, &sort_fields);
+        }
 
         relay::query(
             components.into_iter(),
@@ -283,7 +307,7 @@ pub fn update_config(config: &Config) {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::config::DataType;
+    use crate::{api::schema::sort, config::DataType};
 
     /// Generate component fixes for use with tests
     fn component_fixtures() -> Vec<Component> {
@@ -360,8 +384,8 @@ mod tests {
                 equals: Some("gen1".to_string()),
                 ..Default::default()
             }]),
-            component_type: Some(vec![filter::EqualityFilter {
-                equals: Some(ComponentType::Source),
+            component_kind: Some(vec![filter::EqualityFilter {
+                equals: Some(ComponentKind::Source),
                 not_equals: None,
             }]),
             ..Default::default()
@@ -379,13 +403,13 @@ mod tests {
                 equals: Some("gen1".to_string()),
                 ..Default::default()
             }]),
-            component_type: Some(vec![filter::EqualityFilter {
-                equals: Some(ComponentType::Source),
+            component_kind: Some(vec![filter::EqualityFilter {
+                equals: Some(ComponentKind::Source),
                 not_equals: None,
             }]),
             or: Some(vec![ComponentsFilter {
-                component_type: Some(vec![filter::EqualityFilter {
-                    equals: Some(ComponentType::Sink),
+                component_kind: Some(vec![filter::EqualityFilter {
+                    equals: Some(ComponentKind::Sink),
                     not_equals: None,
                 }]),
                 ..Default::default()
@@ -396,4 +420,94 @@ mod tests {
 
         assert_eq!(components.len(), 2);
     }
+
+    #[test]
+    fn components_sort_asc() {
+        let mut components = component_fixtures();
+        let fields = vec![sort::SortField::<ComponentsSortFieldName> {
+            field: ComponentsSortFieldName::Name,
+            direction: sort::Direction::Asc,
+        }];
+        sort::by_fields(&mut components, &fields);
+
+        let expectations = ["devnull", "gen1", "gen2", "gen3", "parse_json"];
+
+        for (i, name) in expectations.iter().enumerate() {
+            assert_eq!(components[i].get_name(), *name);
+        }
+    }
+
+    #[test]
+    fn components_sort_desc() {
+        let mut components = component_fixtures();
+        let fields = vec![sort::SortField::<ComponentsSortFieldName> {
+            field: ComponentsSortFieldName::Name,
+            direction: sort::Direction::Desc,
+        }];
+        sort::by_fields(&mut components, &fields);
+
+        let expectations = ["parse_json", "gen3", "gen2", "gen1", "devnull"];
+
+        for (i, name) in expectations.iter().enumerate() {
+            assert_eq!(components[i].get_name(), *name);
+        }
+    }
+
+    #[test]
+    fn components_sort_multi() {
+        let mut components = vec![
+            Component::Sink(sink::Sink(sink::Data {
+                name: "a".to_string(),
+                component_type: "blackhole".to_string(),
+                inputs: vec!["gen3".to_string(), "parse_json".to_string()],
+            })),
+            Component::Sink(sink::Sink(sink::Data {
+                name: "b".to_string(),
+                component_type: "blackhole".to_string(),
+                inputs: vec!["gen3".to_string(), "parse_json".to_string()],
+            })),
+            Component::Transform(transform::Transform(transform::Data {
+                name: "c".to_string(),
+                component_type: "json".to_string(),
+                inputs: vec!["gen1".to_string(), "gen2".to_string()],
+            })),
+            Component::Source(source::Source(source::Data {
+                name: "e".to_string(),
+                component_type: "generator".to_string(),
+                output_type: DataType::Metric,
+            })),
+            Component::Source(source::Source(source::Data {
+                name: "d".to_string(),
+                component_type: "generator".to_string(),
+                output_type: DataType::Metric,
+            })),
+            Component::Source(source::Source(source::Data {
+                name: "g".to_string(),
+                component_type: "generator".to_string(),
+                output_type: DataType::Metric,
+            })),
+            Component::Source(source::Source(source::Data {
+                name: "f".to_string(),
+                component_type: "generator".to_string(),
+                output_type: DataType::Metric,
+            })),
+        ];
+
+        let fields = vec![
+            sort::SortField::<ComponentsSortFieldName> {
+                field: ComponentsSortFieldName::ComponentKind,
+                direction: sort::Direction::Asc,
+            },
+            sort::SortField::<ComponentsSortFieldName> {
+                field: ComponentsSortFieldName::Name,
+                direction: sort::Direction::Asc,
+            },
+        ];
+        sort::by_fields(&mut components, &fields);
+
+        let expectations = ["d", "e", "f", "g", "c", "a", "b"];
+        for (i, name) in expectations.iter().enumerate() {
+            assert_eq!(components[i].get_name(), *name);
+        }
+    }
 }
diff --git a/src/api/schema/filter.rs b/src/api/schema/filter.rs
index ab7db88bb248f..3cf2e0110b129 100644
--- a/src/api/schema/filter.rs
+++ b/src/api/schema/filter.rs
@@ -1,4 +1,4 @@
-use super::components::{source, ComponentType};
+use super::components::{source, ComponentKind};
 use async_graphql::{InputObject, InputType};
 
 /// Takes an &Option<bool> and returns early if false
@@ -45,7 +45,7 @@ impl StringFilter {
 }
 
 #[derive(InputObject)]
-#[graphql(concrete(name = "ComponentTypeFilter", params(ComponentType)))]
+#[graphql(concrete(name = "ComponentKindFilter", params(ComponentKind)))]
 #[graphql(concrete(name = "SourceOutputTypeFilter", params(source::SourceOutputType)))]
 pub struct EqualityFilter<T: InputType + PartialEq + Eq> {
     pub equals: Option<T>,
diff --git a/src/api/schema/mod.rs b/src/api/schema/mod.rs
index 48c3c20636047..41e8639dd1a3b 100644
--- a/src/api/schema/mod.rs
+++ b/src/api/schema/mod.rs
@@ -4,6 +4,7 @@ mod health;
 mod meta;
 mod metrics;
 mod relay;
+pub mod sort;
 
 use async_graphql::{EmptyMutation, MergedObject, MergedSubscription, Schema, SchemaBuilder};
 
diff --git a/src/api/schema/sort.rs b/src/api/schema/sort.rs
new file mode 100644
index 0000000000000..0b3350a45b73d
--- /dev/null
+++ b/src/api/schema/sort.rs
@@ -0,0 +1,51 @@
+use crate::api::schema::components::ComponentsSortFieldName;
+use async_graphql::{Enum, InputObject, InputType};
+use itertools::{
+    FoldWhile::{Continue, Done},
+    Itertools,
+};
+use std::cmp::Ordering;
+
+#[derive(Enum, Copy, Clone, PartialEq, Eq)]
+pub enum Direction {
+    Asc,
+    Desc,
+}
+
+impl Default for Direction {
+    fn default() -> Self {
+        Direction::Asc
+    }
+}
+
+#[derive(InputObject)]
+#[graphql(concrete(name = "ComponentsSortField", params(ComponentsSortFieldName)))]
+pub struct SortField<T: InputType> {
+    pub field: T,
+    #[graphql(default_with = "Direction::default()")]
+    pub direction: Direction,
+}
+
+/// Defines a type as sortable by a given field
+pub trait SortableByField<T: InputType> {
+    fn sort(&self, rhs: &Self, field: &T) -> Ordering;
+}
+
+/// Performs an in-place sort against a slice of Sortable<T>, with the provided SortField<T>s
+pub fn by_fields<T: InputType>(f: &mut [impl SortableByField<T>], sort_fields: &[SortField<T>]) {
+    f.sort_by(|a, b| {
+        sort_fields
+            .iter()
+            .fold_while(Ordering::Equal, |cmp, f| match cmp {
+                Ordering::Equal => {
+                    let cmp = a.sort(b, &f.field);
+                    Continue(match f.direction {
+                        Direction::Desc => cmp.reverse(),
+                        _ => cmp,
+                    })
+                }
+                _ => Done(cmp),
+            })
+            .into_inner()
+    });
+}

From d119fe9ee7889848f95375fe9a11fad8da8b9153 Mon Sep 17 00:00:00 2001
From: FungusHumungus <fungus.humungus@gmail.com>
Date: Tue, 19 Jan 2021 14:30:43 +0000
Subject: [PATCH 16/19] fix(remap): `ipv6_to_ipv4` function allows ipv4
 addresses to pass through (#6052)

* Allow ipv4 addresses to pass through

Signed-off-by: Stephen Wakely <fungus.humungus@gmail.com>

* Updated docs to mention IPv4 pass through

Signed-off-by: Stephen Wakely <fungus.humungus@gmail.com>
---
 .../remap/functions/ipv6_to_ipv4.cue          |  3 +
 lib/remap-functions/src/ipv6_to_ipv4.rs       | 72 ++++++++-----------
 2 files changed, 31 insertions(+), 44 deletions(-)

diff --git a/docs/reference/remap/functions/ipv6_to_ipv4.cue b/docs/reference/remap/functions/ipv6_to_ipv4.cue
index 4b965069352f4..3c53d4fac8f69 100644
--- a/docs/reference/remap/functions/ipv6_to_ipv4.cue
+++ b/docs/reference/remap/functions/ipv6_to_ipv4.cue
@@ -17,6 +17,9 @@ remap: functions: ipv6_to_ipv4: {
 	category: "IP"
 	description: #"""
 		Converts the provided `ip` to an IPv4 address.
+
+		If the parameter is already an IPv4 address it is passed through untouched. If it is an IPv6 address it has
+		to be an IPv4 compatible address.
 		"""#
 	examples: [
 		{
diff --git a/lib/remap-functions/src/ipv6_to_ipv4.rs b/lib/remap-functions/src/ipv6_to_ipv4.rs
index ddbfce2bf7249..011198af104e2 100644
--- a/lib/remap-functions/src/ipv6_to_ipv4.rs
+++ b/lib/remap-functions/src/ipv6_to_ipv4.rs
@@ -30,13 +30,6 @@ struct Ipv6ToIpV4Fn {
     value: Box<dyn Expression>,
 }
 
-impl Ipv6ToIpV4Fn {
-    #[cfg(test)]
-    fn new(value: Box<dyn Expression>) -> Self {
-        Self { value }
-    }
-}
-
 impl Expression for Ipv6ToIpV4Fn {
     fn execute(&self, state: &mut state::Program, object: &mut dyn Object) -> Result<Value> {
         let ip = {
@@ -47,7 +40,7 @@ impl Expression for Ipv6ToIpV4Fn {
         };
 
         match ip {
-            IpAddr::V4(addr) => Ok(addr.to_ipv6_mapped().to_string().into()),
+            IpAddr::V4(addr) => Ok(addr.to_string().into()),
             IpAddr::V6(addr) => match addr.to_ipv4() {
                 Some(addr) => Ok(addr.to_string().into()),
                 None => Err(format!("IPV6 address {} is not compatible with IPV4", addr).into()),
@@ -66,7 +59,6 @@ impl Expression for Ipv6ToIpV4Fn {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::map;
 
     remap::test_type_def![value_string {
         expr: |_| Ipv6ToIpV4Fn {
@@ -79,40 +71,32 @@ mod tests {
         },
     }];
 
-    #[test]
-    fn ipv6_to_ipv4() {
-        let cases = vec![
-            (
-                map!["foo": "i am not an ipaddress"],
-                Err("function call error: unable to parse IP address: invalid IP address syntax".to_string()),
-                Ipv6ToIpV4Fn::new(Box::new(Path::from("foo"))),
-            ),
-            (
-                map!["foo": "2001:0db8:85a3::8a2e:0370:7334"],
-                Err("function call error: IPV6 address 2001:db8:85a3::8a2e:370:7334 is not compatible with IPV4".to_string()),
-                Ipv6ToIpV4Fn::new(Box::new(Path::from("foo"))),
-            ),
-            (
-                map!["foo": "::ffff:192.168.0.1"],
-                Ok(Value::from("192.168.0.1")),
-                Ipv6ToIpV4Fn::new(Box::new(Path::from("foo"))),
-            ),
-            (
-                map!["foo": "0:0:0:0:0:ffff:c633:6410"],
-                Ok(Value::from("198.51.100.16")),
-                Ipv6ToIpV4Fn::new(Box::new(Path::from("foo"))),
-            ),
-        ];
-
-        let mut state = state::Program::default();
-
-        for (object, exp, func) in cases {
-            let mut object = Value::Map(object);
-            let got = func
-                .execute(&mut state, &mut object)
-                .map_err(|e| format!("{:#}", anyhow::anyhow!(e)));
-
-            assert_eq!(got, exp);
+    test_function![
+        ipv6_to_ipv4 => Ipv6ToIpV4;
+
+        error {
+            args: func_args![value: "i am not an ipaddress"],
+            want: Err("function call error: unable to parse IP address: invalid IP address syntax".to_string()),
         }
-    }
+
+        incompatible {
+            args: func_args![value: "2001:0db8:85a3::8a2e:0370:7334"],
+            want: Err("function call error: IPV6 address 2001:db8:85a3::8a2e:370:7334 is not compatible with IPV4".to_string()),
+        }
+
+        ipv4_compatible {
+            args: func_args![value: "::ffff:192.168.0.1"],
+            want: Ok(Value::from("192.168.0.1")),
+        }
+
+        ipv6 {
+            args: func_args![value: "0:0:0:0:0:ffff:c633:6410"],
+            want: Ok(Value::from("198.51.100.16")),
+        }
+
+        ipv4 {
+            args: func_args![value: "198.51.100.16"],
+            want: Ok(Value::from("198.51.100.16")),
+        }
+    ];
 }

From 225eaa1fe78608144ca3d32cd439d71c2d96ae17 Mon Sep 17 00:00:00 2001
From: Luc Perkins <lucperkins@gmail.com>
Date: Tue, 19 Jan 2021 09:54:19 -0700
Subject: [PATCH 17/19] Add vrl-cli to default features (#5925)

Signed-off-by: Luc Perkins <luc@timber.io>
---
 Cargo.toml | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 9df20e6c50cf1..1a0a2d2f138e9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -255,14 +255,15 @@ rusty-fork = "0.3.0"
 
 [features]
 # Default features for *-unknown-linux-gnu and *-apple-darwin
-default = ["api", "api-client", "sources", "transforms", "sinks", "vendor-all", "unix", "leveldb", "rdkafka-plain"]
-default-musl = ["api", "api-client", "sources", "transforms", "sinks", "vendor-all", "unix", "leveldb", "rdkafka-cmake"]
+default = ["api", "api-client", "vrl-cli", "sources", "transforms", "sinks", "vendor-all", "unix", "leveldb", "rdkafka-plain"]
+default-musl = ["api", "api-client", "vrl-cli", "sources", "transforms", "sinks", "vendor-all", "unix", "leveldb", "rdkafka-cmake"]
 # Default features for *-unknown-linux-* which make use of `cmake` for dependencies
-default-cmake = ["api", "api-client", "sources", "transforms", "sinks", "vendor-all", "unix", "leveldb", "rdkafka-cmake"]
+default-cmake = ["api", "api-client", "vrl-cli", "sources", "transforms", "sinks", "vendor-all", "unix", "leveldb", "rdkafka-cmake"]
 # Default features for *-pc-windows-msvc
 # TODO: Enable SASL https://github.com/timberio/vector/pull/3081#issuecomment-659298042
-default-msvc = ["api", "api-client", "sources", "transforms", "sinks", "vendor-openssl", "vendor-libz", "leveldb", "rdkafka-cmake"]
-default-no-api-client = ["api", "sources", "transforms", "sinks", "vendor-all", "unix", "leveldb", "rdkafka-plain"]
+default-msvc = ["api", "api-client", "vrl-cli", "sources", "transforms", "sinks", "vendor-openssl", "vendor-libz", "leveldb", "rdkafka-cmake"]
+default-no-api-client = ["api", "sources", "vrl-cli", "transforms", "sinks", "vendor-all", "unix", "leveldb", "rdkafka-plain"]
+default-no-vrl-cli = ["api", "sources", "transforms", "sinks", "vendor-all", "unix", "leveldb", "rdkafka-plain"]
 
 # Target specific release features.
 # The `make` tasks will select this according to the appropriate triple.

From 7209a6f08e0bba06f9413415d34229ac8aa4adf8 Mon Sep 17 00:00:00 2001
From: Binary Logic <bjohnson@binarylogic.com>
Date: Tue, 19 Jan 2021 13:14:44 -0500
Subject: [PATCH 18/19] chore: Update Remap function examples (#6143)

Signed-off-by: binarylogic <bjohnson@binarylogic.com>
---
 docs/reference/remap/functions/append.cue     |  5 +-
 docs/reference/remap/functions/assert.cue     |  8 +-
 docs/reference/remap/functions/ceil.cue       | 10 +--
 docs/reference/remap/functions/compact.cue    | 15 +---
 docs/reference/remap/functions/contains.cue   | 14 +--
 .../remap/functions/decode_base64.cue         |  9 +-
 docs/reference/remap/functions/downcase.cue   |  5 +-
 .../remap/functions/encode_base64.cue         | 27 +++---
 .../reference/remap/functions/encode_json.cue |  5 +-
 docs/reference/remap/functions/ends_with.cue  | 16 ++--
 docs/reference/remap/functions/exists.cue     | 16 +---
 docs/reference/remap/functions/flatten.cue    | 24 ++---
 docs/reference/remap/functions/floor.cue      | 10 +--
 .../remap/functions/format_number.cue         |  5 +-
 .../remap/functions/format_timestamp.cue      | 10 +--
 .../reference/remap/functions/get_env_var.cue |  9 +-
 docs/reference/remap/functions/includes.cue   |  9 +-
 .../remap/functions/ip_cidr_contains.cue      | 10 +--
 docs/reference/remap/functions/ip_subnet.cue  | 10 +--
 docs/reference/remap/functions/ip_to_ipv6.cue |  5 +-
 .../remap/functions/ipv6_to_ipv4.cue          |  5 +-
 docs/reference/remap/functions/is_nullish.cue | 21 +++--
 docs/reference/remap/functions/length.cue     | 60 +++++++------
 docs/reference/remap/functions/log.cue        | 14 ++-
 docs/reference/remap/functions/match.cue      | 15 ++--
 docs/reference/remap/functions/md5.cue        |  5 +-
 docs/reference/remap/functions/merge.cue      | 89 +++++++++----------
 docs/reference/remap/functions/now.cue        |  5 +-
 .../reference/remap/functions/only_fields.cue | 36 --------
 .../remap/functions/parse_aws_alb_log.cue     |  7 +-
 ...ws_cloudwatch_log_subscription_message.cue |  2 +-
 .../functions/parse_aws_vpc_flow_log.cue      | 13 +--
 .../remap/functions/parse_duration.cue        |  5 +-
 docs/reference/remap/functions/parse_grok.cue |  8 +-
 docs/reference/remap/functions/parse_json.cue |  5 +-
 .../remap/functions/parse_key_value.cue       | 20 ++---
 .../reference/remap/functions/parse_regex.cue | 14 +--
 .../remap/functions/parse_regex_all.cue       |  9 +-
 .../remap/functions/parse_syslog.cue          | 11 +--
 .../remap/functions/parse_timestamp.cue       |  5 +-
 .../remap/functions/parse_tokens.cue          | 11 +--
 docs/reference/remap/functions/parse_url.cue  |  5 +-
 docs/reference/remap/functions/push.cue       |  5 +-
 docs/reference/remap/functions/redact.cue     | 14 ++-
 docs/reference/remap/functions/replace.cue    | 15 ++--
 docs/reference/remap/functions/round.cue      | 10 +--
 docs/reference/remap/functions/sha1.cue       |  5 +-
 docs/reference/remap/functions/sha2.cue       |  5 +-
 docs/reference/remap/functions/sha3.cue       |  5 +-
 docs/reference/remap/functions/slice.cue      | 10 +--
 docs/reference/remap/functions/split.cue      | 10 +--
 .../reference/remap/functions/starts_with.cue | 10 +--
 .../functions/strip_ansi_escape_codes.cue     |  5 +-
 .../remap/functions/strip_whitespace.cue      |  5 +-
 docs/reference/remap/functions/to_bool.cue    | 51 ++++++-----
 docs/reference/remap/functions/to_float.cue   |  7 +-
 docs/reference/remap/functions/to_int.cue     | 21 +++--
 docs/reference/remap/functions/to_string.cue  | 31 ++++---
 .../remap/functions/to_syslog_facility.cue    |  7 +-
 .../remap/functions/to_syslog_level.cue       |  7 +-
 .../remap/functions/to_syslog_severity.cue    |  7 +-
 .../remap/functions/to_timestamp.cue          |  7 +-
 .../remap/functions/to_unix_timestamp.cue     | 29 +++---
 docs/reference/remap/functions/truncate.cue   |  5 +-
 docs/reference/remap/functions/upcase.cue     |  5 +-
 docs/reference/remap/functions/uuid_v4.cue    |  5 +-
 66 files changed, 393 insertions(+), 475 deletions(-)
 delete mode 100644 docs/reference/remap/functions/only_fields.cue

diff --git a/docs/reference/remap/functions/append.cue b/docs/reference/remap/functions/append.cue
index bbbec030d3a7a..1ad50eb4e0de1 100644
--- a/docs/reference/remap/functions/append.cue
+++ b/docs/reference/remap/functions/append.cue
@@ -24,11 +24,10 @@ remap: functions: append: {
 	examples: [
 		{
 			title: "Append to an array"
-			input: log: array: [1, 2]
 			source: """
-				.array = append(.array, [3, 4])
+				 append([1, 2], [3, 4])
 				"""
-			output: log: array: [1, 2, 3, 4]
+			return: [1, 2, 3, 4]
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/assert.cue b/docs/reference/remap/functions/assert.cue
index 265f85c677262..173352d7e83cd 100644
--- a/docs/reference/remap/functions/assert.cue
+++ b/docs/reference/remap/functions/assert.cue
@@ -28,17 +28,15 @@ remap: functions: assert: {
 	examples: [
 		{
 			title: "Assertion (true)"
-			input: log: foo: "foo"
 			source: #"""
-				assert(.foo == "foo", message: "Foo must be foo!")
+				assert("foo" == "foo", message: "Foo must be foo!")
 				"""#
-			output: input
+			return: null
 		},
 		{
 			title: "Assertion (false)"
-			input: log: foo: "bar"
 			source: #"""
-				assert(.foo == "foo", message: "Foo must be foo!")
+				assert("foo" == "bar", message: "Foo must be foo!")
 				"""#
 			raises: "Foo must be foo!"
 		},
diff --git a/docs/reference/remap/functions/ceil.cue b/docs/reference/remap/functions/ceil.cue
index 3a9ba52df45bf..6f33f02665ffd 100644
--- a/docs/reference/remap/functions/ceil.cue
+++ b/docs/reference/remap/functions/ceil.cue
@@ -25,19 +25,17 @@ remap: functions: ceil: {
 	examples: [
 		{
 			title: "Round a number up (without precision)"
-			input: log: number: 4.345
 			source: #"""
-				.number = ceil(.number)
+				ceil(4.345)
 				"""#
-			output: log: number: 4
+			return: 4
 		},
 		{
 			title: "Round a number up (with precision)"
-			input: log: number: 4.345
 			source: #"""
-				.number = ceil(.number, precision: 2)
+				ceil(4.345, precision: 2)
 				"""#
-			output: log: number: 4.35
+			return: 4.35
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/compact.cue b/docs/reference/remap/functions/compact.cue
index 6ec2ce4f99355..fdef0c7a74e72 100644
--- a/docs/reference/remap/functions/compact.cue
+++ b/docs/reference/remap/functions/compact.cue
@@ -62,24 +62,17 @@ remap: functions: compact: {
 	examples: [
 		{
 			title: "Compact an array"
-			input: log: array: ["foo", "bar", "", null, [], "buzz"]
 			source: #"""
-				.log = compact(.array, string: true, array: true, null: true)
+				compact(["foo", "bar", "", null, [], "buzz"], string: true, array: true, null: true)
 				"""#
-			output: log: array: ["foo", "bar", "buzz"]
+			return: ["foo", "bar", "buzz"]
 		},
 		{
 			title: "Compact a map"
-			input: log: map: {
-				field1: 1
-				field2: ""
-				field3: []
-				field4: null
-			}
 			source: #"""
-				.map = compact(.map, string: true, array: true, null: true)
+				compact({"field1": 1, "field2": "", "field3": [], "field4": null}, string: true, array: true, null: true)
 				"""#
-			output: log: map: field1: 1
+			return: field1: 1
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/contains.cue b/docs/reference/remap/functions/contains.cue
index fcbe3a4f16f83..89ceb76c0cf08 100644
--- a/docs/reference/remap/functions/contains.cue
+++ b/docs/reference/remap/functions/contains.cue
@@ -31,23 +31,17 @@ remap: functions: contains: {
 	examples: [
 		{
 			title: "String contains (case sensitive)"
-			input: log: message: #"The Needle In The Haystack"#
 			source: #"""
-				.contains = contains(.message, "Needle")
+				contains("The Needle In The Haystack", "Needle")
 				"""#
-			output: input & {
-				log: contains: true
-			}
+			return: true
 		},
 		{
 			title: "String contains (case insensitive)"
-			input: log: message: #"The Needle In The Haystack"#
 			source: #"""
-				.contains = contains(.message, "needle", case_sensitive: false)
+				contains("The Needle In The Haystack", "needle", case_sensitive: false)
 				"""#
-			output: input & {
-				log: contains: true
-			}
+			return: true
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/decode_base64.cue b/docs/reference/remap/functions/decode_base64.cue
index d73cf37c1266b..02e86ffefe083 100644
--- a/docs/reference/remap/functions/decode_base64.cue
+++ b/docs/reference/remap/functions/decode_base64.cue
@@ -20,11 +20,10 @@ remap: functions: decode_base64: {
 	examples: [
 		{
 			title: "Decode Base64 data"
-			input: log: message: "eW91IGhhdmUgc3VjY2Vzc2Z1bGx5IGRlY29kZWQgbWU="
-			source: ".decoded = decode_base64(.message)"
-			output: input & {log: {
-				decoded: "you have successfully decoded me"
-			}}
+			source: """
+				decode_base64("eW91IGhhdmUgc3VjY2Vzc2Z1bGx5IGRlY29kZWQgbWU=")
+				"""
+			return: "you have successfully decoded me"
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/downcase.cue b/docs/reference/remap/functions/downcase.cue
index d8428976a9569..1922129e57622 100644
--- a/docs/reference/remap/functions/downcase.cue
+++ b/docs/reference/remap/functions/downcase.cue
@@ -20,11 +20,10 @@ remap: functions: downcase: {
 	examples: [
 		{
 			title: "Downcase a string"
-			input: log: message: #"Here Is A Message"#
 			source: #"""
-				.message = downcase(.message)
+				downcase("Hello, World!")
 				"""#
-			output: log: message: "here is a message"
+			return: "hello, world!"
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/encode_base64.cue b/docs/reference/remap/functions/encode_base64.cue
index 23b5d9d854a33..78eabce7140ac 100644
--- a/docs/reference/remap/functions/encode_base64.cue
+++ b/docs/reference/remap/functions/encode_base64.cue
@@ -37,27 +37,24 @@ remap: functions: encode_base64: {
 	examples: [
 		{
 			title: "Encode to Base64 (default)"
-			input: log: message: "please encode me"
-			source: ".encoded = encode_base64(.message)"
-			output: input & {log: {
-				encoded: "cGxlYXNlIGVuY29kZSBtZQ=="
-			}}
+			source: """
+				.encoded = encode_base64("please encode me")
+				"""
+			return: "cGxlYXNlIGVuY29kZSBtZQ=="
 		},
 		{
 			title: "Encode to Base64 (without padding)"
-			input: log: message: "please encode me, no padding though"
-			source: ".encoded = encode_base64(.message, padding: false)"
-			output: input & {log: {
-				encoded: "cGxlYXNlIGVuY29kZSBtZSwgbm8gcGFkZGluZyB0aG91Z2g"
-			}}
+			source: """
+				encode_base64("please encode me, no padding though", padding: false)
+				"""
+			return: "cGxlYXNlIGVuY29kZSBtZSwgbm8gcGFkZGluZyB0aG91Z2g"
 		},
 		{
 			title: "Encode to Base64 (URL safe)"
-			input: log: message: "please encode me, but safe for URLs"
-			source: #".encoded = encode_base64(.message, charset: "url_safe")"#
-			output: input & {log: {
-				encoded: "cGxlYXNlIGVuY29kZSBtZSwgYnV0IHNhZmUgZm9yIFVSTHM="
-			}}
+			source: """
+				encode_base64("please encode me, but safe for URLs", charset: "url_safe")
+				"""
+			return: "cGxlYXNlIGVuY29kZSBtZSwgYnV0IHNhZmUgZm9yIFVSTHM="
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/encode_json.cue b/docs/reference/remap/functions/encode_json.cue
index 9a8bc45563dd5..6fcfca915c526 100644
--- a/docs/reference/remap/functions/encode_json.cue
+++ b/docs/reference/remap/functions/encode_json.cue
@@ -18,11 +18,10 @@ remap: functions: encode_json: {
 	examples: [
 		{
 			title: "Encode to JSON"
-			input: log: payload: age: 42
 			source: #"""
-				.payload = encode_json(.payload)
+				.payload = encode_json({"hello": "world"})
 				"""#
-			output: log: payload: #"{"age": 42}"#
+			return: #"{"hello": "world"}"#
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/ends_with.cue b/docs/reference/remap/functions/ends_with.cue
index df95ad08bfcee..5fff2538d4b6d 100644
--- a/docs/reference/remap/functions/ends_with.cue
+++ b/docs/reference/remap/functions/ends_with.cue
@@ -30,14 +30,18 @@ remap: functions: ends_with: {
 		"""#
 	examples: [
 		{
-			title: "String ends with"
-			input: log: message: #"The Needle In The Haystack"#
+			title: "String ends with (case sensitive)"
 			source: #"""
-				.contains = ends_with(.message, "the haystack", case_sensitive: false)
+				ends_with("The Needle In The Haystack", "The Haystack")
 				"""#
-			output: input & {
-				log: contains: true
-			}
+			return: true
+		},
+		{
+			title: "String ends with (case insensitive)"
+			source: #"""
+				ends_with("The Needle In The Haystack", "the haystack", case_sensitive: false)
+				"""#
+			return: true
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/exists.cue b/docs/reference/remap/functions/exists.cue
index c0d52e28f2ba5..c68f9ff3bb7f5 100644
--- a/docs/reference/remap/functions/exists.cue
+++ b/docs/reference/remap/functions/exists.cue
@@ -21,25 +21,17 @@ remap: functions: exists: {
 			title: "Exists (field)"
 			input: log: field: 1
 			source: #"""
-				.exists = exists(.field)
-				.doesntexist = exists(.field2)
+				exists(.field)
 				"""#
-			output: input & {log: {
-				exists:      true
-				doesntexist: false
-			}}
+			return: true
 		},
 		{
 			title: "Exits (array element)"
 			input: log: array: [1, 2, 3]
 			source: #"""
-				.exists = exists(.array[2])
-				.doesntexist = exists(.array[3])
+				exists(.array[2])
 				"""#
-			output: input & {log: {
-				exists:      true
-				doesntexist: false
-			}}
+			return: true
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/flatten.cue b/docs/reference/remap/functions/flatten.cue
index c8490e1c11081..0998b49fb69f0 100644
--- a/docs/reference/remap/functions/flatten.cue
+++ b/docs/reference/remap/functions/flatten.cue
@@ -18,25 +18,25 @@ remap: functions: flatten: {
 	examples: [
 		{
 			title: "Flatten array"
-			input: log: array: [1, [2, 3, 4], [5, [6, 7], 8], 9]
 			source: #"""
-				.array = flatten(.array)
+				flatten([1, [2, 3, 4], [5, [6, 7], 8], 9])
 				"""#
-			output: log: array: [1, 2, 3, 4, 5, 6, 7, 8, 9]
+			return: [1, 2, 3, 4, 5, 6, 7, 8, 9]
 		},
 		{
 			title: "Flatten map"
-			input: log: object: grandparent: {
-				parent1: {
-					child1: 1
-					child2: 2
-				}
-				parent2: child1: 3
-			}
 			source: #"""
-				.object = flatten(.object)
+				flatten({
+					"parent1": {
+						"child1": 1,
+						"child2": 2
+					},
+					"parent2": {
+						"child3": 3
+					}
+				})
 				"""#
-			output: log: object: {
+			return: {
 				"grandparent.parent1.child1": 1
 				"grandparent.parent1.child2": 2
 				"grandparent.parent2.child1": 2
diff --git a/docs/reference/remap/functions/floor.cue b/docs/reference/remap/functions/floor.cue
index f5bbd340d69fe..19cff74eba503 100644
--- a/docs/reference/remap/functions/floor.cue
+++ b/docs/reference/remap/functions/floor.cue
@@ -25,19 +25,17 @@ remap: functions: floor: {
 	examples: [
 		{
 			title: "Round a number down (without precision)"
-			input: log: number: 4.345
 			source: #"""
-				.floor = floor(.number, precision: 2)
+				floor(4.345)
 				"""#
-			output: log: number: 4
+			return: 4
 		},
 		{
 			title: "Round a number down (with precision)"
-			input: log: number: 4.345
 			source: #"""
-				.floor = floor(.number, precision: 2)
+				floor(4.345, precision: 2)
 				"""#
-			output: log: number: 4.34
+			return: 4.34
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/format_number.cue b/docs/reference/remap/functions/format_number.cue
index e2a54d374bb4c..4d79a171d4480 100644
--- a/docs/reference/remap/functions/format_number.cue
+++ b/docs/reference/remap/functions/format_number.cue
@@ -38,11 +38,10 @@ remap: functions: format_number: {
 	examples: [
 		{
 			title: "Format a number (3 decimals)"
-			input: log: number: 1234567.89
 			source: #"""
-				.formatted = format_number(.number, 3, decimal_separator: ".", grouping_separator: ",")
+				format_number(1234567.89, 3, decimal_separator: ".", grouping_separator: ",")
 				"""#
-			output: log: number: "1,234,567.890"
+			return: "1,234,567.890"
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/format_timestamp.cue b/docs/reference/remap/functions/format_timestamp.cue
index 98367d7bab53f..15f9984ac78ac 100644
--- a/docs/reference/remap/functions/format_timestamp.cue
+++ b/docs/reference/remap/functions/format_timestamp.cue
@@ -24,19 +24,17 @@ remap: functions: format_timestamp: {
 	examples: [
 		{
 			title: "Format a timestamp (ISO8601/RFC 3339)"
-			input: log: {}
 			source: #"""
-				.timestamp = format_timestamp(now(), format: "%+")
+				format_timestamp(now(), format: "%+")
 				"""#
-			output: log: timestamp: "2020-10-21T16:00:00Z"
+			return: "2020-10-21T16:00:00Z"
 		},
 		{
 			title: "Format a timestamp (custom)"
-			input: log: {}
 			source: #"""
-				.timestamp = format_timestamp(now(), format: "%v %R")
+				format_timestamp(now(), format: "%v %R")
 				"""#
-			output: log: timestamp: "10-Oct-2020 16:00"
+			return: "10-Oct-2020 16:00"
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/get_env_var.cue b/docs/reference/remap/functions/get_env_var.cue
index b2942d40fd10f..3acfae90f2459 100644
--- a/docs/reference/remap/functions/get_env_var.cue
+++ b/docs/reference/remap/functions/get_env_var.cue
@@ -21,15 +21,10 @@ remap: functions: get_env_var: {
 	examples: [
 		{
 			title: "Get environment variable"
-			input: log: {}
 			source: #"""
-				.home = get_env_var!("HOME")
-				.not_found = get_env_var("SOME_VAR") ?? "default"
+				get_env_var("HOME")
 				"""#
-			output: log: {
-				home:      "/root"
-				not_found: "default"
-			}
+			return: "/root"
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/includes.cue b/docs/reference/remap/functions/includes.cue
index c9b7cd656ea31..0e4cef8434c1b 100644
--- a/docs/reference/remap/functions/includes.cue
+++ b/docs/reference/remap/functions/includes.cue
@@ -24,15 +24,10 @@ remap: functions: includes: {
 	examples: [
 		{
 			title: "Array includes"
-			input: log: fruits: ["apple", "orange", "banana"]
 			source: #"""
-				.includes_banana = includes(.fruits, "banana")
-				.includes_mango = includes(.fruits, "mango")
+				includes(["apple", "orange", "banana"], "banana")
 				"""#
-			output: input & {log: {
-				includes_banana: true
-				includes_mango:  false
-			}}
+			return: true
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/ip_cidr_contains.cue b/docs/reference/remap/functions/ip_cidr_contains.cue
index 9fdc9cb21889a..d26ba583dbfe4 100644
--- a/docs/reference/remap/functions/ip_cidr_contains.cue
+++ b/docs/reference/remap/functions/ip_cidr_contains.cue
@@ -27,19 +27,17 @@ remap: functions: ip_cidr_contains: {
 	examples: [
 		{
 			title: "IPv4 contains CIDR"
-			input: log: address: "192.168.10.32"
 			source: #"""
-				.cidr = ip_cidr_contains(.address, "192.168.0.0/16")
+				ip_cidr_contains("192.168.0.0/16", "192.168.10.32")
 				"""#
-			output: input & {log: cidr: true}
+			return: true
 		},
 		{
 			title: "IPv6 contains CIDR"
-			input: log: address: "2001:4f8:3:ba:2e0:81ff:fe22:d1f1"
 			source: #"""
-				.cidr = ip_cidr_contains(.address, "2001:4f8:4:ba::/64")
+				ip_cidr_contains("2001:4f8:4:ba::/64", "2001:4f8:4:ba:2e0:81ff:fe22:d1f1")
 				"""#
-			output: input & {log: cidr: false}
+			return: true
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/ip_subnet.cue b/docs/reference/remap/functions/ip_subnet.cue
index c3beaf0bd2b40..8e993cdd5921d 100644
--- a/docs/reference/remap/functions/ip_subnet.cue
+++ b/docs/reference/remap/functions/ip_subnet.cue
@@ -32,19 +32,17 @@ remap: functions: ip_subnet: {
 	examples: [
 		{
 			title: "IPv4 subnet"
-			input: log: address: "192.168.10.32"
 			source: #"""
-				.subnet = ip_subnet(.address, "255.255.255.0")
+				ip_subnet("192.168.10.32", "255.255.255.0")
 				"""#
-			output: input & {log: subnet: "192.168.10.0"}
+			return: "192.168.10.0"
 		},
 		{
 			title: "IPv6 subnet"
-			input: log: address: "2404:6800:4003:c02::64"
 			source: #"""
-				.subnet = ip_subnet(.address, "/32")
+				ip_subnet("2404:6800:4003:c02::64", "/32")
 				"""#
-			output: input & {log: subnet: "2404:6800::"}
+			return: "2404:6800::"
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/ip_to_ipv6.cue b/docs/reference/remap/functions/ip_to_ipv6.cue
index 7857b6fea072f..51c6f2f01b169 100644
--- a/docs/reference/remap/functions/ip_to_ipv6.cue
+++ b/docs/reference/remap/functions/ip_to_ipv6.cue
@@ -23,11 +23,10 @@ remap: functions: ip_to_ipv6: {
 	examples: [
 		{
 			title: "IPv4 to IPv6"
-			input: log: v4: "192.168.10.32"
 			source: #"""
-				.v6 = ip_to_ipv6(.v4)
+				ip_to_ipv6("192.168.10.32")
 				"""#
-			output: input & {log: v6: "::ffff:192.168.10.32"}
+			return: "::ffff:192.168.10.32"
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/ipv6_to_ipv4.cue b/docs/reference/remap/functions/ipv6_to_ipv4.cue
index 3c53d4fac8f69..18b837631b9b4 100644
--- a/docs/reference/remap/functions/ipv6_to_ipv4.cue
+++ b/docs/reference/remap/functions/ipv6_to_ipv4.cue
@@ -24,11 +24,10 @@ remap: functions: ipv6_to_ipv4: {
 	examples: [
 		{
 			title: "IPv6 to IPv4"
-			input: log: v6: "::ffff:192.168.0.1"
 			source: #"""
-				.v4 = ipv6_to_ipv4(.address)
+				ipv6_to_ipv4("::ffff:192.168.0.1")
 				"""#
-			output: input & {log: v4: "192.168.0.1"}
+			return: "192.168.0.1"
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/is_nullish.cue b/docs/reference/remap/functions/is_nullish.cue
index a81e971d9cb43..e95b60fafe7b6 100644
--- a/docs/reference/remap/functions/is_nullish.cue
+++ b/docs/reference/remap/functions/is_nullish.cue
@@ -24,21 +24,24 @@ remap: functions: is_nullish: {
 	examples: [
 		{
 			title: "Null detection (blank string)"
-			input: log: string: ""
-			source: ".is_nullish = is_nullish(.string)"
-			output: input & {log: is_nullish: true}
+			source: """
+				is_nullish("")
+				"""
+			return: true
 		},
 		{
 			title: "Null detection (dash string)"
-			input: log: string: "-"
-			source: ".is_nullish = is_nullish(.string)"
-			output: input & {log: is_nullish: true}
+			source: """
+				is_nullish("-")
+				"""
+			return: true
 		},
 		{
 			title: "Null detection (whitespace)"
-			input: log: string: "\n   \n"
-			source: ".is_nullish = is_nullish(.string)"
-			output: input & {log: is_nullish: true}
+			source: """
+				is_nullish("\n  \n")
+				"""
+			return: true
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/length.cue b/docs/reference/remap/functions/length.cue
index db4d250bad0de..3bedb47b74209 100644
--- a/docs/reference/remap/functions/length.cue
+++ b/docs/reference/remap/functions/length.cue
@@ -21,40 +21,44 @@ remap: functions: length: {
 		"""
 	examples: [
 		{
-			title: "Standard map"
-			input: log: teams: {
-				portland: "Trail Blazers"
-				seattle:  "Supersonics"
-			}
-			source: ".num_teams = length(.teams)"
-			output: input & {log: num_teams: 2}
+			title: "Length (map)"
+			source: """
+				length({
+					"portland": "Trail Blazers"
+					"seattle":  "Supersonics"
+				})
+				"""
+			return: 2
 		},
 		{
-			title: "Array"
-			input: log: teams: ["Trail Blazers", "Supersonics", "Grizzlies"]
-			source: ".num_teams = length(.teams)"
-			output: input & {log: num_teams: 3}
+			title: "Length (nested map)"
+			source: """
+				length({
+					"home": {
+						"city":  "Portland"
+						"state": "Oregon"
+					}
+					"name": "Trail Blazers"
+					"mascot": {
+						"name": "Blaze the Trail Cat"
+					}
+				})
+				"""
+			return: 3
 		},
 		{
-			title: "Nested map"
-			input: log: team: {
-				home: {
-					city:  "Portland"
-					state: "Oregon"
-				}
-				name: "Trail Blazers"
-				mascot: {
-					name: "Blaze the Trail Cat"
-				}
-			}
-			source: ".num_attrs = length(.team)"
-			output: input & {log: num_attrs: 3}
+			title: "Length (array)"
+			source: """
+				length(["Trail Blazers", "Supersonics", "Grizzlies"])
+				"""
+			return: 3
 		},
 		{
-			title: "String"
-			input: log: message: "The Planet of the Apes Musical"
-			source: ".str_len = length(.message)"
-			output: input & {log: str_len: 30}
+			title: "Length (string)"
+			source: """
+				length("The Planet of the Apes Musical")
+				"""
+			return: 30
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/log.cue b/docs/reference/remap/functions/log.cue
index fb37a32df6a45..e3956441a9f82 100644
--- a/docs/reference/remap/functions/log.cue
+++ b/docs/reference/remap/functions/log.cue
@@ -32,15 +32,21 @@ remap: functions: log: {
 		"""
 	examples: [
 		{
-			title: "Log timestamp format error"
-			input: log: timestamp: "10-Oct-2020 1"
+			title: "Log a message"
 			source: #"""
-				ts, err = format_timestamp(to_timestamp(.timestamp))
+				log("Hello, World!", level: "info")
+				"""#
+			return: null
+		},
+		{
+			title: "Log an error"
+			source: #"""
+				ts, err = format_timestamp(to_timestamp("10-Oct-2020 1"))
 				if err != null {
 					log(err, level: "error")
 				}
 				"""#
-			output: log: timestamp: "10-Oct-2020 1"
+			return: null
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/match.cue b/docs/reference/remap/functions/match.cue
index 0a1a07b217975..b87c934312a5a 100644
--- a/docs/reference/remap/functions/match.cue
+++ b/docs/reference/remap/functions/match.cue
@@ -23,16 +23,11 @@ remap: functions: match: {
 		"""
 	examples: [
 		{
-			title: "Successful Regex match on string"
-			input: log: phrase: "I'm a little teapot"
-			source: ".has_teapot = match(.phrase, /teapot/)"
-			output: input & {log: has_teapot: true}
-		},
-		{
-			title: "Unsuccessful Regex match on string"
-			input: log: phrase: "Life is but a dream"
-			source: ".has_teapot = match(.phrase, /teapot/)"
-			output: input & {log: has_teapot: false}
+			title: "Regex match on a string"
+			source: """
+				match("I'm a little teapot", /teapot/)
+				"""
+			return: true
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/md5.cue b/docs/reference/remap/functions/md5.cue
index 38070d289e520..54939371da69c 100644
--- a/docs/reference/remap/functions/md5.cue
+++ b/docs/reference/remap/functions/md5.cue
@@ -18,11 +18,10 @@ remap: functions: md5: {
 	examples: [
 		{
 			title: "Create md5 hash"
-			input: log: text: #"foo"#
 			source: #"""
-				.hash = md5(.text)
+				md5("foo")
 				"""#
-			output: input & {log: hash: "acbd18db4cc2f85cedef654fccc4a4d8"}
+			return: "acbd18db4cc2f85cedef654fccc4a4d8"
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/merge.cue b/docs/reference/remap/functions/merge.cue
index 3c2c5174d53be..2db4ca2725469 100644
--- a/docs/reference/remap/functions/merge.cue
+++ b/docs/reference/remap/functions/merge.cue
@@ -35,67 +35,62 @@ remap: functions: merge: {
 	examples: [
 		{
 			title: "Object merge (shallow)"
-			input: log: {
-				map1: {
-					parent1: {
-						child1: 1
-						child2: 2
-					}
-					parent2: child3: 3
-				}
-				map2: parent1: {
-					child2: 4
-					child5: 5
-				}
-			}
 			source: #"""
-				merge(.map1, .map2, deep: false)
-				"""#
-			output: log: {
-				map1: {
-					parent1: {
-						child2: 4
-						child5: 5
+				merge(
+					{
+						"parent1": {
+							"child1": 1,
+							"child2": 2
+						},
+						"parent2": {
+							"child3": 3
+						}
+					},
+					{
+						"parent1": {
+							"child2": 4,
+							"child5": 4
+						}
 					}
-					parent2: child3: 3
-				}
-				map2: parent1: {
+				)
+				"""#
+			return: {
+				parent1: {
 					child2: 4
 					child5: 5
 				}
+				parent2: child3: 3
 			}
 		},
 		{
 			title: "Object merge (deep)"
-			input: log: {
-				map1: {
-					parent1: {
-						child1: 1
-						child2: 2
-					}
-					parent2: child3: 3
-				}
-				map2: parent1: {
-					child2: 4
-					child5: 5
-				}
-			}
 			source: #"""
-				merge(.map1, .map2, deep: true)
+				merge(
+					{
+						"parent1": {
+							"child1": 1,
+							"child2": 2
+						},
+						"parent2": {
+							"child3": 3
+						}
+					},
+					{
+						"parent1": {
+							"child2": 4,
+							"child5": 4
+						}
+					},
+					deep: true
+				)
 				"""#
-			output: log: {
-				map1: {
-					parent1: {
-						child1: 1
-						child2: 4
-						child5: 5
-					}
-					parent2: child3: 3
-				}
-				map2: parent1: {
+			return: {
+				parent1: {
+					child1: 1
 					child2: 4
 					child5: 5
 				}
+				parent2: child3: 3
 			}
 		},
 	]
diff --git a/docs/reference/remap/functions/now.cue b/docs/reference/remap/functions/now.cue
index 735fdd92f462f..4e5302b06c89c 100644
--- a/docs/reference/remap/functions/now.cue
+++ b/docs/reference/remap/functions/now.cue
@@ -11,11 +11,10 @@ remap: functions: now: {
 	examples: [
 		{
 			title: "Generate a current timestamp"
-			input: log: {}
 			source: #"""
-				.timestamp = now()
+				now()
 				"""#
-			output: log: timestamp: "2020-10-21T20:53:12.212221Z"
+			return: "2020-10-21T20:53:12.212221Z"
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/only_fields.cue b/docs/reference/remap/functions/only_fields.cue
deleted file mode 100644
index 4faf6446c6e38..0000000000000
--- a/docs/reference/remap/functions/only_fields.cue
+++ /dev/null
@@ -1,36 +0,0 @@
-package metadata
-
-remap: functions: only_fields: {
-	arguments: [
-		{
-			name:        "paths"
-			description: "The paths of the fields to keep."
-			required:    true
-			multiple:    true
-			type: ["string"]
-		},
-	]
-	internal_failure_reasons: []
-	return: ["null"]
-	category: "Event"
-	description: #"""
-		Remove any fields that are *not* specified by the given `paths` from the root `event` object. Multiple fields can be specified.
-		"""#
-	examples: [
-		{
-			title: "White-list event fields"
-			input: log: {
-				field1: 1
-				field2: 2
-				field3: 3
-			}
-			source: #"""
-				only_fields(.field1, .field3)
-				"""#
-			output: log: {
-				field1: 1
-				field3: 3
-			}
-		},
-	]
-}
diff --git a/docs/reference/remap/functions/parse_aws_alb_log.cue b/docs/reference/remap/functions/parse_aws_alb_log.cue
index dc22f926628d6..3a7b1262b41a5 100644
--- a/docs/reference/remap/functions/parse_aws_alb_log.cue
+++ b/docs/reference/remap/functions/parse_aws_alb_log.cue
@@ -20,11 +20,12 @@ remap: functions: parse_aws_alb_log: {
 	examples: [
 		{
 			title: "Parse AWS ALB log"
-			input: log: message: #"http 2018-11-30T22:23:00.186641Z app/my-loadbalancer/50dc6c495c0c9188 192.168.131.39:2817 - 0.000 0.001 0.000 200 200 34 366 "GET http://www.example.com:80/ HTTP/1.1" "curl/7.46.0" - - arn:aws:elasticloadbalancing:us-east-2:123456789012:targetgroup/my-targets/73e2d6bc24d8a067 "Root=1-58337364-23a8c76965a2ef7629b185e3" "-" "-" 0 2018-11-30T22:22:48.364000Z "forward" "-" "-" "-" "-" "-" "-""#
 			source: #"""
-				. = parse_aws_alb_log(.message)
+				parse_aws_alb_log(
+					"http 2018-11-30T22:23:00.186641Z app/my-loadbalancer/50dc6c495c0c9188 192.168.131.39:2817 - 0.000 0.001 0.000 200 200 34 366 \"GET http://www.example.com:80/ HTTP/1.1\" \"curl/7.46.0\" - - arn:aws:elasticloadbalancing:us-east-2:123456789012:targetgroup/my-targets/73e2d6bc24d8a067 \"Root=1-58337364-23a8c76965a2ef7629b185e3\" \"-\" \"-\" 0 2018-11-30T22:22:48.364000Z \"forward\" \"-\" \"-\" \"-\" \"-\" \"-\" \"-\""
+				)
 				"""#
-			output: log: {
+			return: {
 				type:                     "http"
 				timestamp:                "2018-11-30T22:23:00.186641Z"
 				elb:                      "app/my-loadbalancer/50dc6c495c0c9188"
diff --git a/docs/reference/remap/functions/parse_aws_cloudwatch_log_subscription_message.cue b/docs/reference/remap/functions/parse_aws_cloudwatch_log_subscription_message.cue
index dc1d3db3b5364..27177551aee7f 100644
--- a/docs/reference/remap/functions/parse_aws_cloudwatch_log_subscription_message.cue
+++ b/docs/reference/remap/functions/parse_aws_cloudwatch_log_subscription_message.cue
@@ -40,7 +40,7 @@ remap: functions: parse_aws_cloudwatch_log_subscription_message: {
 				}
 				"""
 			source: #"""
-				. = parse_aws_cloudwatch_log_subscription_message(.message)
+				parse_aws_cloudwatch_log_subscription_message(.message)
 				"""#
 			output: log: {
 				owner:        "111111111111"
diff --git a/docs/reference/remap/functions/parse_aws_vpc_flow_log.cue b/docs/reference/remap/functions/parse_aws_vpc_flow_log.cue
index 9ba24969af6a2..25d370f30a005 100644
--- a/docs/reference/remap/functions/parse_aws_vpc_flow_log.cue
+++ b/docs/reference/remap/functions/parse_aws_vpc_flow_log.cue
@@ -26,11 +26,10 @@ remap: functions: parse_aws_vpc_flow_log: {
 	examples: [
 		{
 			title: "Parse AWS VPC Flow log (default format)"
-			input: log: message: #"2 123456789010 eni-1235b8ca123456789 - - - - - - - 1431280876 1431280934 - NODATA"#
 			source: #"""
-				. = parse_aws_vpc_flow_log(.message)
+				parse_aws_vpc_flow_log("2 123456789010 eni-1235b8ca123456789 - - - - - - - 1431280876 1431280934 - NODATA")
 				"""#
-			output: log: {
+			return: {
 				"version":      2
 				"account_id":   123456789010
 				"interface_id": "eni-1235b8ca123456789"
@@ -49,11 +48,13 @@ remap: functions: parse_aws_vpc_flow_log: {
 		},
 		{
 			title: "Parse AWS VPC Flow log (custom format)"
-			input: log: message: #"- eni-1235b8ca123456789 10.0.1.5 10.0.0.220 10.0.1.5 203.0.113.5"#
 			source: #"""
-				. = parse_aws_vpc_flow_log(.message, "instance_id interface_id srcaddr dstaddr pkt_srcaddr pkt_dstaddr")
+				parse_aws_vpc_flow_log(
+					"- eni-1235b8ca123456789 10.0.1.5 10.0.0.220 10.0.1.5 203.0.113.5",
+					"instance_id interface_id srcaddr dstaddr pkt_srcaddr pkt_dstaddr"
+				)
 				"""#
-			output: log: {
+			return: {
 				"instance_id":  null
 				"interface_id": "eni-1235b8ca123456789"
 				"srcaddr":      "10.0.1.5"
diff --git a/docs/reference/remap/functions/parse_duration.cue b/docs/reference/remap/functions/parse_duration.cue
index 09f4534c8b671..678e03b79bef7 100644
--- a/docs/reference/remap/functions/parse_duration.cue
+++ b/docs/reference/remap/functions/parse_duration.cue
@@ -38,11 +38,10 @@ remap: functions: parse_duration: {
 	examples: [
 		{
 			title: "Parse duration (milliseconds)"
-			input: log: duration: "1005ms"
 			source: #"""
-				.seconds = parse_duration(.duration, unit: "s")
+				parse_duration("1005ms", unit: "s")
 				"""#
-			output: input & {log: seconds: 1.005}
+			return: 1.005
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/parse_grok.cue b/docs/reference/remap/functions/parse_grok.cue
index 02e703e2392de..a5a407ef58e4a 100644
--- a/docs/reference/remap/functions/parse_grok.cue
+++ b/docs/reference/remap/functions/parse_grok.cue
@@ -37,11 +37,13 @@ remap: functions: parse_grok: {
 	examples: [
 		{
 			title: "Parse via Grok"
-			input: log: message: "2020-10-02T23:22:12.223222Z info Hello world"
 			source: #"""
-				. = parse_grok(.message, "%{TIMESTAMP_ISO8601:timestamp} %{LOGLEVEL:level} %{GREEDYDATA:message}")
+				parse_grok(
+					"2020-10-02T23:22:12.223222Z info Hello world",
+					"%{TIMESTAMP_ISO8601:timestamp} %{LOGLEVEL:level} %{GREEDYDATA:message}"
+				)
 				"""#
-			output: log: {
+			return: {
 				timestamp: "2020-10-02T23:22:12.223222Z"
 				level:     "info"
 				message:   "Hello world"
diff --git a/docs/reference/remap/functions/parse_json.cue b/docs/reference/remap/functions/parse_json.cue
index 291369f815445..ccb5976dc0097 100644
--- a/docs/reference/remap/functions/parse_json.cue
+++ b/docs/reference/remap/functions/parse_json.cue
@@ -23,11 +23,10 @@ remap: functions: parse_json: {
 	examples: [
 		{
 			title: "Parse JSON"
-			input: log: message: #"{"key": "val"}"#
 			source: #"""
-				. = parse_json(.message)
+				parse_json("{\"key\": \"val\"}")
 				"""#
-			output: log: key: "val"
+			return: key: "val"
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/parse_key_value.cue b/docs/reference/remap/functions/parse_key_value.cue
index 2fd1745140a3c..d070ac54a2d0f 100644
--- a/docs/reference/remap/functions/parse_key_value.cue
+++ b/docs/reference/remap/functions/parse_key_value.cue
@@ -37,13 +37,12 @@ remap: functions: parse_key_value: {
 	examples: [
 		{
 			title: "Parse logfmt log"
-			input: log: message: #"""
-				@timestamp="Sun Jan 10 16:47:39 EST 2021" level=info msg="Stopping all fetchers" tag#production=stopping_fetchers id=ConsumerFetcherManager-1382721708341 module=kafka.consumer.ConsumerFetcherManager
-				"""#
 			source: #"""
-				. = parse_key_value(.message)
+				parse_key_value(
+					"@timestamp=\"Sun Jan 10 16:47:39 EST 2021\" level=info msg=\"Stopping all fetchers\" tag#production=stopping_fetchers id=ConsumerFetcherManager-1382721708341 module=kafka.consumer.ConsumerFetcherManager"
+				)
 				"""#
-			output: log: {
+			return: {
 				"@timestamp":     "Sun Jan 10 16:47:39 EST 2021"
 				level:            "info"
 				msg:              "Stopping all fetchers"
@@ -54,13 +53,14 @@ remap: functions: parse_key_value: {
 		},
 		{
 			title: "Parse comma delimited log"
-			input: log: message: #"""
-				path:"/cart_link", host:store.app.com, fwd: "102.30.171.16", dyno: web.1 connect:0ms, service:87ms, status:304, bytes:632, protocol:https
-				"""#
 			source: #"""
-				. = parse_key_value(.message, field_delimiter: ",", key_value_delimiter: ":")
+				parse_key_value(
+					"path:\"/cart_link\", host:store.app.com, fwd: \"102.30.171.16\", dyno: web.1 connect:0ms, service:87ms, status:304, bytes:632, protocol:https",
+					field_delimiter: ",",
+					key_value_delimiter: ":"
+				)
 				"""#
-			output: log: {
+			return: {
 				path:     "/cart_link"
 				host:     "store.app.com"
 				fwd:      "102.30.171.16"
diff --git a/docs/reference/remap/functions/parse_regex.cue b/docs/reference/remap/functions/parse_regex.cue
index 10be138f5ebaa..4de107f725bb2 100644
--- a/docs/reference/remap/functions/parse_regex.cue
+++ b/docs/reference/remap/functions/parse_regex.cue
@@ -38,9 +38,10 @@ remap: functions: parse_regex: {
 	examples: [
 		{
 			title: "Parse via Regex (with capture groups)"
-			input: log: message: "first group and second group."
-			source: ". = parse_regex(.message, /(?P<number>.*?) group/)"
-			output: log: {
+			source: """
+				parse_regex("first group and second group.", /(?P<number>.*?) group/)
+				"""
+			return: {
 				number: "first"
 				"0":    "first group"
 				"1":    "first"
@@ -48,9 +49,10 @@ remap: functions: parse_regex: {
 		},
 		{
 			title: "Parse via Regex (without capture groups)"
-			input: log: message: "first group and second group."
-			source: ". = parse_regex(.message, /(?.*?) group/)"
-			output: log: {
+			source: """
+				parse_regex("first group and second group.", /(?.*?) group/)
+				"""
+			return: {
 				"1": "first"
 			}
 		},
diff --git a/docs/reference/remap/functions/parse_regex_all.cue b/docs/reference/remap/functions/parse_regex_all.cue
index 6d81844bc8d5a..4858a10360794 100644
--- a/docs/reference/remap/functions/parse_regex_all.cue
+++ b/docs/reference/remap/functions/parse_regex_all.cue
@@ -30,9 +30,10 @@ remap: functions: parse_regex_all: {
 	examples: [
 		{
 			title: "Parse via Regex (all matches)"
-			input: log: message: "first group and second group."
-			source: ".matches = parse_regex_all(.message, /(?P<number>.*?) group/)"
-			output: input & {log: matches: [
+			source: """
+				parse_regex_all("first group and second group.", /(?P<number>.*?) group/)
+				"""
+			return: [
 				{
 					number: "first"
 					"0":    "first group"
@@ -43,7 +44,7 @@ remap: functions: parse_regex_all: {
 					"0":    "second group"
 					"1":    "second"
 				},
-			]}
+			]
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/parse_syslog.cue b/docs/reference/remap/functions/parse_syslog.cue
index 78445a3b8222b..d8dbb800b3396 100644
--- a/docs/reference/remap/functions/parse_syslog.cue
+++ b/docs/reference/remap/functions/parse_syslog.cue
@@ -22,12 +22,13 @@ remap: functions: parse_syslog: {
 		"""#
 	examples: [
 		{
-			title: "Parse Syslog log"
-			input: log: message: """
-				<13>1 2020-03-13T20:45:38.119Z dynamicwireless.name non 2426 ID931 [exampleSDID@32473 iut="3" eventSource= "Application" eventID="1011"] Try to override the THX port, maybe it will reboot the neural interface!
+			title: "Parse Syslog log (5424)"
+			source: """
+				parse_syslog(
+					"<13>1 2020-03-13T20:45:38.119Z dynamicwireless.name non 2426 ID931 [exampleSDID@32473 iut=\"3\" eventSource= \"Application\" eventID=\"1011\"] Try to override the THX port, maybe it will reboot the neural interface!"
+				)
 				"""
-			source: ". = parse_syslog(.message)"
-			output: log: {
+			return: {
 				severity:    "notice"
 				facility:    "user"
 				timestamp:   "2020-03-13T20:45:38.119Z"
diff --git a/docs/reference/remap/functions/parse_timestamp.cue b/docs/reference/remap/functions/parse_timestamp.cue
index 19c287569b73c..f97758e89bc44 100644
--- a/docs/reference/remap/functions/parse_timestamp.cue
+++ b/docs/reference/remap/functions/parse_timestamp.cue
@@ -27,11 +27,10 @@ remap: functions: parse_timestamp: {
 	examples: [
 		{
 			title: "Parse timestamp"
-			input: log: timestamp: "10-Oct-2020 16:00"
 			source: #"""
-				.timestamp = parse_timestamp(.timestamp, format: "%v %R")
+				parse_timestamp("10-Oct-2020 16:00", format: "%v %R")
 				"""#
-			output: log: timestamp: "2020-10-10T16:00:00Z"
+			return: "2020-10-10T16:00:00Z"
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/parse_tokens.cue b/docs/reference/remap/functions/parse_tokens.cue
index 9d90cdc17f60b..921f52494e1e7 100644
--- a/docs/reference/remap/functions/parse_tokens.cue
+++ b/docs/reference/remap/functions/parse_tokens.cue
@@ -26,15 +26,12 @@ remap: functions: parse_tokens: {
 	examples: [
 		{
 			title: "Parse tokens"
-			input: log: text: #"""
-				A sentence "with \"a\" sentence inside" and [some brackets]
-				"""#
 			source: #"""
-				.tokens = parse_tokens(.text)
+				parse_tokens(
+					"A sentence \"with \\"a\\" sentence inside\" and [some brackets]"
+				)
 				"""#
-			output: input & {log: {
-				slice: ["A", "sentence", #"with \"a\" sentence inside"#, "and", "some brackets"]
-			}}
+			return: ["A", "sentence", #"with \"a\" sentence inside"#, "and", "some brackets"]
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/parse_url.cue b/docs/reference/remap/functions/parse_url.cue
index b8e23f36d0cdc..9b02835f6268a 100644
--- a/docs/reference/remap/functions/parse_url.cue
+++ b/docs/reference/remap/functions/parse_url.cue
@@ -20,11 +20,10 @@ remap: functions: parse_url: {
 	examples: [
 		{
 			title: "Parse URL"
-			input: log: url: #"ftp://foo:bar@vector.dev:4343/foobar?hello=world#123"#
 			source: #"""
-				.url = parse_url(.url)
+				parse_url("ftp://foo:bar@vector.dev:4343/foobar?hello=world#123")
 				"""#
-			output: log: url: {
+			return: {
 				scheme:   "ftp"
 				username: "foo"
 				password: "bar"
diff --git a/docs/reference/remap/functions/push.cue b/docs/reference/remap/functions/push.cue
index 8e402b68b28ff..f537ac5302b8d 100644
--- a/docs/reference/remap/functions/push.cue
+++ b/docs/reference/remap/functions/push.cue
@@ -26,11 +26,10 @@ remap: functions: push: {
 	examples: [
 		{
 			title: "Push an item onto an array"
-			input: log: array: [72.5, false, [1, 2, 3]]
 			source: """
-				.array = push(.array, "booper")
+				push([1, 2], 3)
 				"""
-			output: log: array: [72.5, false, [1, 2, 3], "booper"]
+			return: [1, 2, 3]
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/redact.cue b/docs/reference/remap/functions/redact.cue
index 275274ea48ba5..0cb8421681c6c 100644
--- a/docs/reference/remap/functions/redact.cue
+++ b/docs/reference/remap/functions/redact.cue
@@ -47,20 +47,18 @@ remap: functions: redact: {
 		"""
 	examples: [
 		{
-			title: "Redact credit card number"
-			input: log: credit_card: "9876123454320123"
+			title: "Redact (credit card number)"
 			source: """
-				.credit_card = redact(.credit_card, filters: ["pattern"], redactor: "full", patterns: [/[0-9]{16}/])
+				redact("9876123454320123", filters: ["pattern"], redactor: "full", patterns: [/[0-9]{16}/])
 				"""
-			output: log: credit_card: "****"
+			return: "****"
 		},
 		{
-			title: "Redact email address"
-			input: log: email: "ana@booper.com"
+			title: "Redact (email address)"
 			source: #"""
-				.email = redact(.email, filters: ["pattern"], redactor: "full", patterns: [/^\S+@\S+$/])
+				redact("vic@vector.dev", filters: ["pattern"], redactor: "full", patterns: [/^\S+@\S+$/])
 				"""#
-			output: log: email: "****"
+			return: "****"
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/replace.cue b/docs/reference/remap/functions/replace.cue
index fb5c0115c55ad..327d0862d00b8 100644
--- a/docs/reference/remap/functions/replace.cue
+++ b/docs/reference/remap/functions/replace.cue
@@ -38,27 +38,24 @@ remap: functions: replace: {
 	examples: [
 		{
 			title: "Replace literal text"
-			input: log: message: #"Apples and Bananas"#
 			source: #"""
-				.message = replace(.message, "and", "not")
+				replace("Apples and Bananas", "and", "not")
 				"""#
-			output: log: message: "Apples not Bananas"
+			return: "Apples not Bananas"
 		},
 		{
 			title: "Replace via regular expression"
-			input: log: message: #"Apples and Bananas"#
 			source: #"""
-				.message = replace(.message, /bananas/i, "Pineapples")
+				replace("Apples and Bananas", /bananas/i, "Pineapples")
 				"""#
-			output: log: message: "apples and Pineapples"
+			return: "apples and Pineapples"
 		},
 		{
 			title: "Replace first instance"
-			input: log: message: #"Bananas and Bananas"#
 			source: #"""
-				.message = replace(.message, "Bananas", "Pineapples", count: 1)
+				replace("Bananas and Bananas", "Bananas", "Pineapples", count: 1)
 				"""#
-			output: log: message: "Pineapples and Bananas"
+			return: "Pineapples and Bananas"
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/round.cue b/docs/reference/remap/functions/round.cue
index 5d65c8e092119..734a324ba2f40 100644
--- a/docs/reference/remap/functions/round.cue
+++ b/docs/reference/remap/functions/round.cue
@@ -25,19 +25,17 @@ remap: functions: round: {
 	examples: [
 		{
 			title: "Round a number (without precision)"
-			input: log: number: 4.345
 			source: #"""
-				.number = round(.number)
+				round(4.345)
 				"""#
-			output: log: number: 4
+			return: 4
 		},
 		{
 			title: "Round a number (with precision)"
-			input: log: number: 4.345
 			source: #"""
-				.number = round(.number, precision: 2)
+				round(4.345, precision: 2)
 				"""#
-			output: log: number: 4.35
+			return: 4.35
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/sha1.cue b/docs/reference/remap/functions/sha1.cue
index 38418ddf0b425..117bcaba4369c 100644
--- a/docs/reference/remap/functions/sha1.cue
+++ b/docs/reference/remap/functions/sha1.cue
@@ -18,11 +18,10 @@ remap: functions: sha1: {
 	examples: [
 		{
 			title: "Calculate sha1 hash"
-			input: log: text: #"foo"#
 			source: #"""
-				.hash = sha1(.text)
+				sha1("foo")
 				"""#
-			output: input & {log: hash: "0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33"}
+			return: "0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33"
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/sha2.cue b/docs/reference/remap/functions/sha2.cue
index 20b554ca1850a..0d661db1897e4 100644
--- a/docs/reference/remap/functions/sha2.cue
+++ b/docs/reference/remap/functions/sha2.cue
@@ -34,11 +34,10 @@ remap: functions: sha2: {
 	examples: [
 		{
 			title: "Calculate sha2 hash"
-			input: log: text: "foo"
 			source: #"""
-				.hash = sha2(.text, variant = "SHA-512/224")
+				sha2("foo, variant = "SHA-512/224")
 				"""#
-			output: input & {log: hash: "d68f258d37d670cfc1ec1001a0394784233f88f056994f9a7e5e99be"}
+			return: "d68f258d37d670cfc1ec1001a0394784233f88f056994f9a7e5e99be"
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/sha3.cue b/docs/reference/remap/functions/sha3.cue
index 1865cafd963dd..896ae569b0be6 100644
--- a/docs/reference/remap/functions/sha3.cue
+++ b/docs/reference/remap/functions/sha3.cue
@@ -32,11 +32,10 @@ remap: functions: sha3: {
 	examples: [
 		{
 			title: "Calaculate sha3 hash"
-			input: log: text: #"foo"#
 			source: #"""
-				.hash = sha3(.text, variant: "SHA3-224")
+				sha3("foo", variant: "SHA3-224")
 				"""#
-			output: input & {log: hash: "f4f6779e153c391bbd29c95e72b0708e39d9166c7cea51d1f10ef58a"}
+			return: "f4f6779e153c391bbd29c95e72b0708e39d9166c7cea51d1f10ef58a"
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/slice.cue b/docs/reference/remap/functions/slice.cue
index c718d5d772bee..417c449c3b8a4 100644
--- a/docs/reference/remap/functions/slice.cue
+++ b/docs/reference/remap/functions/slice.cue
@@ -35,19 +35,17 @@ remap: functions: slice: {
 	examples: [
 		{
 			title: "Slice a string (positve index)"
-			input: log: text: #"Supercalifragilisticexpialidocious"#
 			source: #"""
-				.text = slice(.text, start: 5, end: 13)
+				slice("Supercalifragilisticexpialidocious", start: 5, end: 13)
 				"""#
-			output: log: text: "califrag"
+			return: "califrag"
 		},
 		{
 			title: "Slice a string (negative index)"
-			input: log: text: #"Supercalifragilisticexpialidocious"#
 			source: #"""
-				.text = slice(.text, start: 5, end: -14)
+				slice("Supercalifragilisticexpialidocious", start: 5, end: -14)
 				"""#
-			output: log: text: "califragilistic"
+			return: "califragilistic"
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/split.cue b/docs/reference/remap/functions/split.cue
index 9a18f80a5d587..681246844c1d7 100644
--- a/docs/reference/remap/functions/split.cue
+++ b/docs/reference/remap/functions/split.cue
@@ -32,19 +32,17 @@ remap: functions: split: {
 	examples: [
 		{
 			title: "Split a string (no limit)"
-			input: log: text: "apples and pears and bananas"
 			source: #"""
-				.text = split(.text, " and ")
+				split("apples and pears and bananas", " and ")
 				"""#
-			output: log: text: ["apples", "pears", "bananas"]
+			return: ["apples", "pears", "bananas"]
 		},
 		{
 			title: "Split a string (with a limit)"
-			input: log: text: "apples and pears and bananas"
 			source: #"""
-				.text = split(.text, " and ", limit: 1)
+				split("apples and pears and bananas", " and ", limit: 1)
 				"""#
-			output: log: text: ["apples", "pears and bananas"]
+			return: ["apples", "pears and bananas"]
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/starts_with.cue b/docs/reference/remap/functions/starts_with.cue
index 3757c8c7aadad..39d5b87277a1c 100644
--- a/docs/reference/remap/functions/starts_with.cue
+++ b/docs/reference/remap/functions/starts_with.cue
@@ -31,19 +31,17 @@ remap: functions: starts_with: {
 	examples: [
 		{
 			title: "String starts with (case sensitive)"
-			input: log: message: #"The Needle In The Haystack"#
 			source: #"""
-				.starts = starts_with(.message, \"The Needle\")
+				starts_with("The Needle In The Haystack", \"The Needle\")
 				"""#
-			output: input & {log: starts: true}
+			return: true
 		},
 		{
 			title: "String starts with (case insensitive)"
-			input: log: message: #"The Needle In The Haystack"#
 			source: #"""
-				.starts = starts_with(.message, \"the needle\", case_sensitive: false)
+				starts_with("The Needle In The Haystack", \"the needle\", case_sensitive: false)
 				"""#
-			output: input & {log: starts: true}
+			return: true
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/strip_ansi_escape_codes.cue b/docs/reference/remap/functions/strip_ansi_escape_codes.cue
index caaa1bebfdf3f..49da9d65af596 100644
--- a/docs/reference/remap/functions/strip_ansi_escape_codes.cue
+++ b/docs/reference/remap/functions/strip_ansi_escape_codes.cue
@@ -18,11 +18,10 @@ remap: functions: strip_ansi_escape_codes: {
 	examples: [
 		{
 			title: "Strip ANSI escape codes"
-			input: log: text: #"\e[46mfoo\e[0m bar"#
 			source: #"""
-				.text = strip_ansi_escape_codes(.text)
+				strip_ansi_escape_codes("\e[46mfoo\e[0m bar")
 				"""#
-			output: log: text: "foo bar"
+			return: "foo bar"
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/strip_whitespace.cue b/docs/reference/remap/functions/strip_whitespace.cue
index b0704743892fb..d298de8159824 100644
--- a/docs/reference/remap/functions/strip_whitespace.cue
+++ b/docs/reference/remap/functions/strip_whitespace.cue
@@ -20,11 +20,10 @@ remap: functions: strip_whitespace: {
 	examples: [
 		{
 			title: "Strip whitespace"
-			input: log: text: "  A sentence.  "
 			source: #"""
-				.text = strip_whitespace(.text)
+				strip_whitespace("  A sentence.  ")
 				"""#
-			output: log: text: "A sentence."
+			return: "A sentence."
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/to_bool.cue b/docs/reference/remap/functions/to_bool.cue
index 3d6bc9f242bc5..5bf3157f808b5 100644
--- a/docs/reference/remap/functions/to_bool.cue
+++ b/docs/reference/remap/functions/to_bool.cue
@@ -27,28 +27,39 @@ remap: functions: to_bool: {
 		"""#
 	examples: [
 		{
-			title: "Coerce to a boolean"
-			input: log: {
-				string:  "yes"
-				float:   0.0
-				"null":  null
-				integer: 1
-				boolean: false
-			}
+			title: "Coerce to a boolean (string)"
 			source: """
-				.string = to_bool(.string)
-				.float = to_bool(.float)
-				.null = to_bool(.null)
-				.integer = to_bool(.integer)
-				.boolean = to_bool(.boolean)
+				to_bool("yes")
 				"""
-			output: log: {
-				string:  true
-				float:   false
-				null:    false
-				integer: true
-				boolean: false
-			}
+			return: true
+		},
+		{
+			title: "Coerce to a boolean (float)"
+			source: """
+				to_bool(0.0)
+				"""
+			return: false
+		},
+		{
+			title: "Coerce to a boolean (int)"
+			source: """
+				to_bool(0)
+				"""
+			return: false
+		},
+		{
+			title: "Coerce to a boolean (null)"
+			source: """
+				to_bool(null)
+				"""
+			return: false
+		},
+		{
+			title: "Coerce to a boolean (boolean)"
+			source: """
+				to_bool(true)
+				"""
+			return: true
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/to_float.cue b/docs/reference/remap/functions/to_float.cue
index 0ed1393dcc7cc..aaa8288e63529 100644
--- a/docs/reference/remap/functions/to_float.cue
+++ b/docs/reference/remap/functions/to_float.cue
@@ -18,9 +18,10 @@ remap: functions: to_float: {
 	examples: [
 		{
 			title: "Coerce to a float"
-			input: log: string: "3.14"
-			source: ".string = to_float(.string)"
-			output: log: string: 3.14
+			source: """
+				to_float("3.145")
+				"""
+			return: 3.145
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/to_int.cue b/docs/reference/remap/functions/to_int.cue
index c109ed887404a..e4391d591529b 100644
--- a/docs/reference/remap/functions/to_int.cue
+++ b/docs/reference/remap/functions/to_int.cue
@@ -24,19 +24,18 @@ remap: functions: to_int: {
 		"""#
 	examples: [
 		{
-			title: "Coerce to an int"
-			input: log: {
-				string:    "2"
-				timestamp: "2020-12-30 22:20:53.824727 UTC"
-			}
+			title: "Coerce to an int (string)"
 			source: """
-				.string = to_int(.string)
-				.timestamp = to_int(.timestamp)
+				to_int("2")
 				"""
-			output: log: {
-				string:    2
-				timestamp: 1609366853
-			}
+			return: 2
+		},
+		{
+			title: "Coerce to an int (timestamp)"
+			source: """
+				to_int(to_timestamp("2020-12-30 22:20:53.824727 UTC"))
+				"""
+			return: 1609366853
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/to_string.cue b/docs/reference/remap/functions/to_string.cue
index 52a2925b06bee..056792b46af83 100644
--- a/docs/reference/remap/functions/to_string.cue
+++ b/docs/reference/remap/functions/to_string.cue
@@ -17,22 +17,25 @@ remap: functions: to_string: {
 		"""#
 	examples: [
 		{
-			title: "Coerce to a string"
-			input: log: {
-				boolean: true
-				int:     52
-				float:   12.2
-			}
+			title: "Coerce to a string (boolean)"
 			source: #"""
-				.boolean = to_string(.boolean)
-				.int = to_string(.int)
-				.float = to_string(.float)
+				to_string(true)
 				"""#
-			output: log: {
-				boolean: "true"
-				int:     "52"
-				float:   "12.2"
-			}
+			return: true
+		},
+		{
+			title: "Coerce to a string (int)"
+			source: #"""
+				to_string(52)
+				"""#
+			return: "52"
+		},
+		{
+			title: "Coerce to a string (float)"
+			source: #"""
+				to_string(52.2)
+				"""#
+			return: "52.2"
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/to_syslog_facility.cue b/docs/reference/remap/functions/to_syslog_facility.cue
index 0078ba6ea4354..0ff6a97bf6763 100644
--- a/docs/reference/remap/functions/to_syslog_facility.cue
+++ b/docs/reference/remap/functions/to_syslog_facility.cue
@@ -21,9 +21,10 @@ remap: functions: to_syslog_facility: {
 	examples: [
 		{
 			title: "Coerce to a Syslog facility"
-			input: log: syslog_facility: "4"
-			source: ".syslog_facility = to_syslog_facility(.syslog_facility)"
-			output: log: syslog_facility: "auth"
+			source: """
+				to_syslog_facility("4")
+				"""
+			return: "auth"
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/to_syslog_level.cue b/docs/reference/remap/functions/to_syslog_level.cue
index acd4e119d697d..e699ac6331750 100644
--- a/docs/reference/remap/functions/to_syslog_level.cue
+++ b/docs/reference/remap/functions/to_syslog_level.cue
@@ -21,9 +21,10 @@ remap: functions: to_syslog_level: {
 	examples: [
 		{
 			title: "Coerce to a Syslog level"
-			input: log: severity: "5"
-			source: ".log_level = to_syslog_level(.severity)"
-			output: input & {log: level: "notice"}
+			source: """
+				to_syslog_level("5")
+				"""
+			return: "notice"
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/to_syslog_severity.cue b/docs/reference/remap/functions/to_syslog_severity.cue
index df64c871756ee..3d452e6d137d2 100644
--- a/docs/reference/remap/functions/to_syslog_severity.cue
+++ b/docs/reference/remap/functions/to_syslog_severity.cue
@@ -24,9 +24,10 @@ remap: functions: to_syslog_severity: {
 	examples: [
 		{
 			title: "Coerce to Syslog serverity"
-			input: log: level: "alert"
-			source: ".severity = to_syslog_severity(.level)"
-			output: input & {log: severity: 1}
+			source: """
+				to_syslog_severity("alert")
+				"""
+			return: 1
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/to_timestamp.cue b/docs/reference/remap/functions/to_timestamp.cue
index 7272fb9572cdc..7f842cd3acf14 100644
--- a/docs/reference/remap/functions/to_timestamp.cue
+++ b/docs/reference/remap/functions/to_timestamp.cue
@@ -22,9 +22,10 @@ remap: functions: to_timestamp: {
 	examples: [
 		{
 			title: "Coerce to a timestamp"
-			input: log: date: "2020-10-21T16:00:00Z"
-			source: ".date = to_timestamp(.date)"
-			output: log: date: "2020-10-21T16:00:00Z"
+			source: """
+				to_timestamp("2020-10-21T16:00:00Z")
+				"""
+			return: "2020-10-21T16:00:00Z"
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/to_unix_timestamp.cue b/docs/reference/remap/functions/to_unix_timestamp.cue
index 02198b090e78e..250e9cc928f2c 100644
--- a/docs/reference/remap/functions/to_unix_timestamp.cue
+++ b/docs/reference/remap/functions/to_unix_timestamp.cue
@@ -32,20 +32,25 @@ remap: functions: to_unix_timestamp: {
 		"""
 	examples: [
 		{
-			title: "Convert to a Unix timestamp"
-			input: log: date: "2021-01-01T00:00:00+00:00"
+			title: "Convert to a Unix timestamp (seconds)"
 			source: #"""
-				.no_default = to_unix_timestamp(to_timestamp(.date))
-				.seconds = to_unix_timestamp(to_timestamp(.date))
-				.milliseconds = to_unix_timestamp(to_timestamp(.date), unit: "milliseconds")
-				.nanoseconds = to_unix_timestamp(to_timestamp(.date), unit: "nanoseconds")
+				to_unix_timestamp(to_timestamp("2021-01-01T00:00:00+00:00"))
 				"""#
-			output: input & {log: {
-				default:      1609459200
-				seconds:      1609459200
-				milliseconds: 1609459200000
-				nanoseconds:  1609459200000000000
-			}}
+			return: 1609459200
+		},
+		{
+			title: "Convert to a Unix timestamp (milliseconds)"
+			source: #"""
+				to_unix_timestamp(to_timestamp("2021-01-01T00:00:00+00:00"), unit: "milliseconds")
+				"""#
+			return: 1609459200000
+		},
+		{
+			title: "Convert to a Unix timestamp (nanoseconds)"
+			source: #"""
+				to_unix_timestamp(to_timestamp("2021-01-01T00:00:00+00:00"), unit: "nanoseconds")
+				"""#
+			return: 1609459200000000000
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/truncate.cue b/docs/reference/remap/functions/truncate.cue
index 74a68aab02d4b..cefaa11f41948 100644
--- a/docs/reference/remap/functions/truncate.cue
+++ b/docs/reference/remap/functions/truncate.cue
@@ -33,11 +33,10 @@ remap: functions: truncate: {
 	examples: [
 		{
 			title: "Truncate a string"
-			input: log: message: #"A rather long sentence."#
 			source: #"""
-				.message = truncate(.message, limit = 11, ellipsis = true)
+				truncate("A rather long sentence.", limit = 11, ellipsis = true)
 				"""#
-			output: log: message: "A rather lo..."
+			return: "A rather lo..."
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/upcase.cue b/docs/reference/remap/functions/upcase.cue
index 066b1b26c46fd..e913f3538214b 100644
--- a/docs/reference/remap/functions/upcase.cue
+++ b/docs/reference/remap/functions/upcase.cue
@@ -20,11 +20,10 @@ remap: functions: upcase: {
 	examples: [
 		{
 			title: "Upcase a string"
-			input: log: message: #"Here Is A Message"#
 			source: #"""
-				.message = upcase(.message)
+				upcase("Hello, World!")
 				"""#
-			output: log: message: "HERE IS A MESSAGE"
+			output: log: message: "HELLO, WORLD!"
 		},
 	]
 }
diff --git a/docs/reference/remap/functions/uuid_v4.cue b/docs/reference/remap/functions/uuid_v4.cue
index b5758bc03a226..8967021757b9e 100644
--- a/docs/reference/remap/functions/uuid_v4.cue
+++ b/docs/reference/remap/functions/uuid_v4.cue
@@ -11,11 +11,10 @@ remap: functions: uuid_v4: {
 	examples: [
 		{
 			title: "Create a UUIDv4"
-			input: log: {}
 			source: #"""
-				.id = uuid_v4()
+				uuid_v4()
 				"""#
-			output: log: id: "1d262f4f-199b-458d-879f-05fd0a5f0683"
+			return: "1d262f4f-199b-458d-879f-05fd0a5f0683"
 		},
 	]
 }

From e249753fae02524ac811242f0d43466da0215b7a Mon Sep 17 00:00:00 2001
From: binarylogic <bjohnson@binarylogic.com>
Date: Tue, 19 Jan 2021 12:18:58 -0600
Subject: [PATCH 19/19] chore: Always include notices array on Remap functions

Signed-off-by: binarylogic <bjohnson@binarylogic.com>
---
 docs/reference/remap/functions.cue | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/reference/remap/functions.cue b/docs/reference/remap/functions.cue
index 54601ee9a1fa1..2c6065f9bb8ea 100644
--- a/docs/reference/remap/functions.cue
+++ b/docs/reference/remap/functions.cue
@@ -15,7 +15,7 @@ remap: {
 		name:        string
 		category:    #FunctionCategory
 		description: string
-		notices?: [string, ...string]
+		notices:     [string, ...string] | *[]
 
 		arguments: [...#Argument]
 		return: [remap.#Type, ...remap.#Type]