Merge branch 'feature_gate'

.lighthouse/pipeline-rust-build.yaml

@@ -0,0 +1,260 @@
+apiVersion: tekton.dev/v1beta1
+kind: PipelineRun
+metadata:
+  name: rust-build
+spec:
+  pipelineSpec:
+    params:
+      - name: image-name
+        description: The name for the built image
+        type: string
+      - name: path-to-image-context
+        description: The path to the build context
+        type: string
+      - name: path-to-dockerfile
+        description: The path to the Dockerfile
+        type: string
+      - name: command
+        type: array
+        description: Command to run.
+        default: []
+    tasks:
+      - name: report-pending
+        taskRef:
+          name: gitea-set-status
+        runAfter:
+          - fetch-repository
+        params:
+          - name: CONTEXT
+            value: "$(params.JOB_NAME)"
+          - name: REPO_FULL_NAME
+            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
+          - name: GITEA_HOST_URL
+            value: code.fizz.buzz
+          - name: SHA
+            value: "$(tasks.fetch-repository.results.commit)"
+          - name: DESCRIPTION
+            value: "Build $(params.JOB_NAME) has started"
+          - name: STATE
+            value: pending
+          - name: TARGET_URL
+            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
+      - name: fetch-repository
+        taskRef:
+          name: git-clone
+        workspaces:
+          - name: output
+            workspace: git-source
+        params:
+          - name: url
+            value: $(params.REPO_URL)
+          - name: revision
+            value: $(params.PULL_BASE_SHA)
+          - name: deleteExisting
+            value: "true"
+      - name: build-image
+        taskRef:
+          name: kaniko
+        params:
+          - name: IMAGE
+            value: "$(params.image-name):$(tasks.fetch-repository.results.commit)"
+          - name: CONTEXT
+            value: $(params.path-to-image-context)
+          - name: DOCKERFILE
+            value: $(params.path-to-dockerfile)
+          - name: BUILDER_IMAGE
+            value: "gcr.io/kaniko-project/executor:v1.12.1"
+          - name: EXTRA_ARGS
+            value:
+              - --cache=true
+              - --cache-copy-layers
+              - --cache-repo=harbor.fizz.buzz/kanikocache/cache
+              - --use-new-run # Should result in a speed-up
+              - --reproducible # To remove timestamps so layer caching works.
+              - --snapshot-mode=redo
+              - --skip-unused-stages=true
+              - --registry-mirror=dockerhub.dockerhub.svc.cluster.local
+        workspaces:
+          - name: source
+            workspace: git-source
+          - name: dockerconfig
+            workspace: docker-credentials
+        runAfter:
+          - fetch-repository
+      - name: run-image-none
+        taskRef:
+          name: run-docker-image
+        workspaces:
+          - name: source
+            workspace: git-source
+          - name: cargo-cache
+            workspace: cargo-cache
+        runAfter:
+          - build-image
+        params:
+          - name: command
+            value: ["$(params.command[*])"]
+          - name: args
+            value: ["--no-default-features"]
+          - name: docker-image
+            value: "$(params.image-name):$(tasks.fetch-repository.results.commit)"
+      - name: run-image-tracing
+        taskRef:
+          name: run-docker-image
+        workspaces:
+          - name: source
+            workspace: git-source
+          - name: cargo-cache
+            workspace: cargo-cache
+        runAfter:
+          - run-image-none
+        params:
+          - name: command
+            value: ["$(params.command[*])"]
+          - name: args
+            value: ["--no-default-features", "--features", "tracing"]
+          - name: docker-image
+            value: "$(params.image-name):$(tasks.fetch-repository.results.commit)"
+      - name: run-image-compare
+        taskRef:
+          name: run-docker-image
+        workspaces:
+          - name: source
+            workspace: git-source
+          - name: cargo-cache
+            workspace: cargo-cache
+        runAfter:
+          - run-image-tracing
+        params:
+          - name: command
+            value: ["$(params.command[*])"]
+          - name: args
+            value: ["--no-default-features", "--features", "compare"]
+          - name: docker-image
+            value: "$(params.image-name):$(tasks.fetch-repository.results.commit)"
+      - name: run-image-default
+        taskRef:
+          name: run-docker-image
+        workspaces:
+          - name: source
+            workspace: git-source
+          - name: cargo-cache
+            workspace: cargo-cache
+        runAfter:
+          - run-image-compare
+        params:
+          - name: command
+            value: ["$(params.command[*])"]
+          - name: args
+            value: []
+          - name: docker-image
+            value: "$(params.image-name):$(tasks.fetch-repository.results.commit)"
+      - name: run-image-all
+        taskRef:
+          name: run-docker-image
+        workspaces:
+          - name: source
+            workspace: git-source
+          - name: cargo-cache
+            workspace: cargo-cache
+        runAfter:
+          - run-image-default
+        params:
+          - name: command
+            value: ["$(params.command[*])"]
+          - name: args
+            value: ["--no-default-features", "--features", "tracing,compare"]
+          - name: docker-image
+            value: "$(params.image-name):$(tasks.fetch-repository.results.commit)"
+    finally:
+      - name: report-success
+        when:
+          - input: "$(tasks.status)"
+            operator: in
+            values: ["Succeeded", "Completed"]
+        taskRef:
+          name: gitea-set-status
+        params:
+          - name: CONTEXT
+            value: "$(params.JOB_NAME)"
+          - name: REPO_FULL_NAME
+            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
+          - name: GITEA_HOST_URL
+            value: code.fizz.buzz
+          - name: SHA
+            value: "$(tasks.fetch-repository.results.commit)"
+          - name: DESCRIPTION
+            value: "Build $(params.JOB_NAME) has succeeded"
+          - name: STATE
+            value: success
+          - name: TARGET_URL
+            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
+      - name: report-failure
+        when:
+          - input: "$(tasks.status)"
+            operator: in
+            values: ["Failed"]
+        taskRef:
+          name: gitea-set-status
+        params:
+          - name: CONTEXT
+            value: "$(params.JOB_NAME)"
+          - name: REPO_FULL_NAME
+            value: "$(params.REPO_OWNER)/$(params.REPO_NAME)"
+          - name: GITEA_HOST_URL
+            value: code.fizz.buzz
+          - name: SHA
+            value: "$(tasks.fetch-repository.results.commit)"
+          - name: DESCRIPTION
+            value: "Build $(params.JOB_NAME) has failed"
+          - name: STATE
+            value: failure
+          - name: TARGET_URL
+            value: "https://tekton.fizz.buzz/#/namespaces/$(context.pipelineRun.namespace)/pipelineruns/$(context.pipelineRun.name)"
+      - name: cargo-cache-autoclean
+        taskRef:
+          name: run-docker-image
+        workspaces:
+          - name: source
+            workspace: git-source
+          - name: cargo-cache
+            workspace: cargo-cache
+        params:
+          - name: command
+            value: [cargo, cache, --autoclean]
+          - name: args
+            value: []
+          - name: docker-image
+            value: "$(params.image-name):$(tasks.fetch-repository.results.commit)"
+    workspaces:
+      - name: git-source
+      - name: docker-credentials
+      - name: cargo-cache
+  workspaces:
+    - name: git-source
+      volumeClaimTemplate:
+        spec:
+          storageClassName: "nfs-client"
+          accessModes:
+            - ReadWriteOnce
+          resources:
+            requests:
+              storage: 10Gi
+      subPath: rust-source
+    - name: cargo-cache
+      persistentVolumeClaim:
+        claimName: organic-cargo-cache-build
+    - name: docker-credentials
+      secret:
+        secretName: harbor-plain
+  serviceAccountName: build-bot
+  timeout: 240h0m0s
+  params:
+    - name: image-name
+      value: "harbor.fizz.buzz/private/organic-build"
+    - name: path-to-image-context
+      value: docker/organic_build/
+    - name: path-to-dockerfile
+      value: docker/organic_build/Dockerfile
+    - name: command
+      value: [cargo, build]

.lighthouse/triggers.yaml

@@ -16,3 +16,10 @@ spec:
       skip_branches:
         # We already run on every commit, so running when the semver tags get pushed is causing needless double-processing.
         - "^v[0-9]+\\.[0-9]+\\.[0-9]+$"
+    - name: rust-build
+      source: "pipeline-rust-build.yaml"
+      # Override https-based url from lighthouse events.
+      clone_uri: "git@code.fizz.buzz:talexander/organic.git"
+      skip_branches:
+        # We already run on every commit, so running when the semver tags get pushed is causing needless double-processing.
+        - "^v[0-9]+\\.[0-9]+\\.[0-9]+$"

Cargo.toml

@@ -9,6 +9,7 @@ repository = "https://code.fizz.buzz/talexander/organic"
 readme = "README.org"
 keywords = ["emacs", "org-mode"]
 categories = ["parsing"]
+resolver = "2"
 
 [lib]
 name = "organic"
@@ -21,18 +22,21 @@ path = "src/main.rs"
 
 [dependencies]
 nom = "7.1.1"
-opentelemetry = "0.17.0"
-opentelemetry-jaeger = "0.16.0"
-tracing = "0.1.37"
-tracing-opentelemetry = "0.17.2"
-tracing-subscriber = {version="0.3.16", features=["env-filter"]}
+opentelemetry = { version = "0.20.0", optional = true, default-features = false, features = ["trace", "rt-tokio"] }
+opentelemetry-otlp = { version = "0.13.0", optional = true }
+opentelemetry-semantic-conventions = { version = "0.12.0", optional = true }
+tokio = { version = "1.30.0", optional = true, default-features = false, features = ["rt", "rt-multi-thread"] }
+tracing = { version = "0.1.37", optional = true }
+tracing-opentelemetry = { version = "0.20.0", optional = true }
+tracing-subscriber = { version = "0.3.17", optional = true, features = ["env-filter"] }
 
 [build-dependencies]
 walkdir = "2.3.3"
 
 [features]
-default = ["compare"]
+default = ["compare", "tracing"]
 compare = []
+tracing = ["dep:opentelemetry", "dep:opentelemetry-otlp", "dep:opentelemetry-semantic-conventions", "dep:tokio", "dep:tracing", "dep:tracing-opentelemetry", "dep:tracing-subscriber"]
 
 [profile.release]
 lto = true

Makefile

@@ -47,7 +47,10 @@ unittest:
 
 .PHONY: jaeger
 jaeger:
-> docker run -d --rm --name organicdocker -p 6831:6831/udp -p 6832:6832/udp -p 16686:16686 -p 14268:14268 jaegertracing/all-in-one:latest
+# 4317 for OTLP gRPC, 4318 for OTLP HTTP. We currently use gRPC but I forward both ports regardless.
+#
+# These flags didn't help even though they seem like they would: --collector.otlp.grpc.max-message-size=10000000 --collector.queue-size=20000 --collector.num-workers=100
+> docker run -d --rm --name organicdocker -p 4317:4317 -p 4318:4318 -p 16686:16686 -e COLLECTOR_OTLP_ENABLED=true jaegertracing/all-in-one:1.47 --collector.grpc-server.max-message-size=10000000
 
 .PHONY: jaegerweb
 jaegerweb:

docker/organic_build/Dockerfile

@@ -0,0 +1,4 @@
+FROM rustlang/rust:nightly-alpine3.17
+
+RUN apk add --no-cache musl-dev
+RUN cargo install --locked --no-default-features --features ci-autoclean cargo-cache

docker/organic_build/Makefile

@@ -0,0 +1,35 @@
+IMAGE_NAME:=organic-build
+# REMOTE_REPO:=harbor.fizz.buzz/private
+
+.PHONY: all
+all: build push
+
+.PHONY: build
+build:
+	docker build -t $(IMAGE_NAME) -f Dockerfile ../
+
+.PHONY: push
+push:
+ifdef REMOTE_REPO
+	docker tag $(IMAGE_NAME) $(REMOTE_REPO)/$(IMAGE_NAME)
+	docker push $(REMOTE_REPO)/$(IMAGE_NAME)
+else
+	@echo "REMOTE_REPO not defined, not pushing to a remote repo."
+endif
+
+.PHONY: clean
+clean:
+	docker rmi $(IMAGE_NAME)
+ifdef REMOTE_REPO
+	docker rmi $(REMOTE_REPO)/$(IMAGE_NAME)
+else
+	@echo "REMOTE_REPO not defined, not removing from remote repo."
+endif
+
+.PHONY: run
+run:
+	docker run --rm -i -t $(IMAGE_NAME)
+
+.PHONY: shell
+shell:
+	docker run --rm -i -t --entrypoint /bin/bash $(IMAGE_NAME)

src/init_tracing.rs

@@ -1,34 +1,70 @@
-use tracing_subscriber::layer::SubscriberExt;
+#[cfg(feature = "tracing")]
+use opentelemetry_otlp::WithExportConfig;
+#[cfg(feature = "tracing")]
+use tracing_subscriber::prelude::__tracing_subscriber_SubscriberExt;
+#[cfg(feature = "tracing")]
 use tracing_subscriber::util::SubscriberInitExt;
-// use tracing_subscriber::EnvFilter;
 
+const SERVICE_NAME: &'static str = "organic";
+
+// Despite the obvious verbosity that fully-qualifying everything causes, in these functions I am fully-qualifying everything relating to tracing. This is because the tracing feature involves multiple libraries working together and so I think it is beneficial to see which libraries contribute which bits.
+
+#[cfg(feature = "tracing")]
 pub fn init_telemetry() -> Result<(), Box<dyn std::error::Error>> {
-    // let env_filter = EnvFilter::try_from_default_env().unwrap_or(EnvFilter::new("warn"));
+    // by default it will hit http://localhost:4317 with a gRPC payload
+    // TODO: I think the endpoint can be controlled by the OTEL_EXPORTER_OTLP_TRACES_ENDPOINT env variable instead of hard-coded into this code base. Regardless, I am the only developer right now so I am not too concerned.
+    let exporter = opentelemetry_otlp::new_exporter()
+        .tonic()
+        .with_endpoint("http://localhost:4317/v1/traces");
 
-    // let stdout = tracing_subscriber::fmt::Layer::new()
-    //     .pretty()
-    //     .with_file(true)
-    //     .with_line_number(true)
-    //     .with_thread_ids(false)
-    //     .with_target(false);
+    let tracer = opentelemetry_otlp::new_pipeline()
+        .tracing()
+        .with_exporter(exporter)
+        .with_trace_config(opentelemetry::sdk::trace::config().with_resource(
+            opentelemetry::sdk::Resource::new(vec![opentelemetry::KeyValue::new(
+                opentelemetry_semantic_conventions::resource::SERVICE_NAME,
+                SERVICE_NAME.to_string(),
+            )]),
+        ))
+        // If I do install_batch then 1K+ spans will get orphaned off into their own trace and I get the error message "OpenTelemetry trace error occurred. cannot send message to batch processor as the channel is closed"
+        //
+        // If I do install_simple then it only creates 1 trace (which is good!) but my console gets spammed with this concerning log message that makes me think it might be dropping the extra spans on the floor: "OpenTelemetry trace error occurred. Exporter otlp encountered the following error(s): the grpc server returns error (Unknown error): , detailed error message: Service was not ready: transport error"
+        //
+        // I suspect it is related to this bug: https://github.com/open-telemetry/opentelemetry-rust/issues/888
+        //
+        // .install_simple()
+        .install_batch(opentelemetry::runtime::Tokio)
+        .expect("Error: Failed to initialize the tracer.");
 
-    opentelemetry::global::set_text_map_propagator(opentelemetry_jaeger::Propagator::new());
-    let tracer = opentelemetry_jaeger::new_pipeline()
-        .with_service_name("organic")
-        .install_simple()?;
+    let subscriber = tracing_subscriber::Registry::default();
+    let level_filter_layer = tracing_subscriber::EnvFilter::try_from_default_env()
+        .unwrap_or(tracing_subscriber::EnvFilter::new("WARN"));
+    let tracing_layer = tracing_opentelemetry::layer().with_tracer(tracer);
 
-    let opentelemetry = tracing_opentelemetry::layer().with_tracer(tracer);
+    opentelemetry::global::set_text_map_propagator(
+        opentelemetry::sdk::propagation::TraceContextPropagator::new(),
+    );
 
-    tracing_subscriber::registry()
-        // .with(env_filter)
-        .with(opentelemetry)
-        // .with(stdout)
+    subscriber
+        .with(level_filter_layer)
+        .with(tracing_layer)
         .try_init()?;
 
     Ok(())
 }
 
+#[cfg(feature = "tracing")]
 pub fn shutdown_telemetry() -> Result<(), Box<dyn std::error::Error>> {
     opentelemetry::global::shutdown_tracer_provider();
     Ok(())
 }
+
+#[cfg(not(feature = "tracing"))]
+pub fn init_telemetry() -> Result<(), Box<dyn std::error::Error>> {
+    Ok(())
+}
+
+#[cfg(not(feature = "tracing"))]
+pub fn shutdown_telemetry() -> Result<(), Box<dyn std::error::Error>> {
+    Ok(())
+}

src/main.rs

@@ -1,16 +1,32 @@
 #![feature(round_char_boundary)]
 use std::path::Path;
 
+#[cfg(feature = "compare")]
 use ::organic::parser::document;
+#[cfg(feature = "compare")]
 use organic::compare_document;
+#[cfg(feature = "compare")]
 use organic::emacs_parse_org_document;
+#[cfg(feature = "compare")]
 use organic::parser::sexp::sexp_with_padding;
 
 use crate::init_tracing::init_telemetry;
 use crate::init_tracing::shutdown_telemetry;
 mod init_tracing;
 
+#[cfg(not(feature = "tracing"))]
 fn main() -> Result<(), Box<dyn std::error::Error>> {
+    main_body()
+}
+
+#[cfg(feature = "tracing")]
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let rt = tokio::runtime::Runtime::new()?;
+    let result = rt.block_on(async { main_body() });
+    result
+}
+
+fn main_body() -> Result<(), Box<dyn std::error::Error>> {
     init_telemetry()?;
     run_compare(
         std::env::args()
@@ -21,6 +37,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     Ok(())
 }
 
+#[cfg(feature = "compare")]
 fn run_compare<P: AsRef<Path>>(todo_org_path: P) -> Result<(), Box<dyn std::error::Error>> {
     let org_contents = std::fs::read_to_string(todo_org_path.as_ref()).expect("Read org file.");
     let (remaining, rust_parsed) = document(org_contents.as_str()).expect("Org Parse failure");
@@ -49,3 +66,9 @@ fn run_compare<P: AsRef<Path>>(todo_org_path: P) -> Result<(), Box<dyn std::erro
 
     Ok(())
 }
+
+#[cfg(not(feature = "compare"))]
+fn run_compare<P: AsRef<Path>>(_todo_org_path: P) -> Result<(), Box<dyn std::error::Error>> {
+    println!("This program was built with compare disabled. Doing nothing.");
+    Ok(())
+}

src/parser/angle_link.rs

@@ -15,7 +15,7 @@ use crate::parser::util::exit_matcher_parser;
 use crate::parser::util::get_consumed;
 use crate::parser::AngleLink;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn angle_link<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, AngleLink<'s>> {
     let (remaining, _) = tag("<")(input)?;
     let (remaining, proto) = protocol(context, remaining)?;
@@ -33,7 +33,7 @@ pub fn angle_link<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s s
     ))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn path_angle<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let parser_context =
         context.with_additional_node(ContextElement::ExitMatcherNode(ExitMatcherNode {
@@ -47,7 +47,7 @@ fn path_angle<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str,
     Ok((remaining, path))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn path_angle_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     tag(">")(input)
 }

src/parser/citation.rs

@@ -28,7 +28,7 @@ use crate::parser::util::exit_matcher_parser;
 use crate::parser::util::get_consumed;
 use crate::parser::Object;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn citation<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, Citation<'s>> {
     // TODO: Despite being a standard object, citations cannot exist inside the global prefix/suffix for other citations because citations must contain something that matches @key which is forbidden inside the global prefix/suffix. This TODO is to evaluate if its worth putting in an explicit check for this (which can be easily accomplished by checking the output of `get_bracket_depth()`). I suspect its not worth it because I expect, outside of intentionally crafted inputs, this parser will exit immediately inside a citation since it is unlikely to find the "[cite" substring inside a citation global prefix/suffix.
     let (remaining, _) = tag_no_case("[cite")(input)?;
@@ -47,7 +47,7 @@ pub fn citation<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str
     Ok((remaining, Citation { source }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn citestyle<'r, 's>(input: &'s str) -> Res<&'s str, &'s str> {
     let (remaining, _) = tuple((tag("/"), style))(input)?;
     let (remaining, _) = opt(tuple((tag("/"), variant)))(remaining)?;
@@ -55,21 +55,21 @@ fn citestyle<'r, 's>(input: &'s str) -> Res<&'s str, &'s str> {
     Ok((remaining, source))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn style<'r, 's>(input: &'s str) -> Res<&'s str, &'s str> {
     recognize(many1(verify(anychar, |c| {
         c.is_alphanumeric() || "_-".contains(*c)
     })))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn variant<'r, 's>(input: &'s str) -> Res<&'s str, &'s str> {
     recognize(many1(verify(anychar, |c| {
         c.is_alphanumeric() || "_-/".contains(*c)
     })))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn global_prefix<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -95,7 +95,7 @@ fn global_prefix<'r, 's>(
     Ok((remaining, children))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn global_prefix_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let context_depth = get_bracket_depth(context)
         .expect("This function should only be called from inside a citation.");
@@ -127,7 +127,7 @@ fn global_prefix_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'
     ))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn global_suffix<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -152,7 +152,7 @@ fn global_suffix<'r, 's>(
     Ok((remaining, children))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn global_suffix_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let context_depth = get_bracket_depth(context)
         .expect("This function should only be called from inside a citation.");

src/parser/citation_reference.rs

@@ -25,7 +25,7 @@ use crate::parser::util::get_consumed;
 use crate::parser::util::WORD_CONSTITUENT_CHARACTERS;
 use crate::parser::Object;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn citation_reference<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -38,7 +38,7 @@ pub fn citation_reference<'r, 's>(
     Ok((remaining, CitationReference { source }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn citation_reference_key<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -58,7 +58,7 @@ pub fn citation_reference_key<'r, 's>(
     Ok((remaining, source))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn key_prefix<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, Vec<Object<'s>>> {
     // TODO: I could insert CitationBracket entries in the context after each matched object to reduce the scanning done for counting brackets which should be more efficient.
     let parser_context = context
@@ -80,7 +80,7 @@ fn key_prefix<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str,
     Ok((remaining, children))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn key_suffix<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, Vec<Object<'s>>> {
     // TODO: I could insert CitationBracket entries in the context after each matched object to reduce the scanning done for counting brackets which should be more efficient.
     let parser_context = context
@@ -102,7 +102,7 @@ fn key_suffix<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str,
     Ok((remaining, children))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn get_bracket_depth<'r, 's>(context: Context<'r, 's>) -> Option<&'r CitationBracket<'s>> {
     for node in context.iter() {
         match node.get_data() {
@@ -113,7 +113,7 @@ pub fn get_bracket_depth<'r, 's>(context: Context<'r, 's>) -> Option<&'r Citatio
     None
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn key_prefix_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let context_depth = get_bracket_depth(context)
         .expect("This function should only be called from inside a citation reference.");
@@ -145,7 +145,7 @@ fn key_prefix_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s s
     ))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn key_suffix_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let context_depth = get_bracket_depth(context)
         .expect("This function should only be called from inside a citation reference.");

src/parser/clock.rs

@@ -18,7 +18,7 @@ use crate::parser::util::get_consumed;
 use crate::parser::util::start_of_line;
 use crate::parser::Clock;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn clock<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, Clock<'s>> {
     start_of_line(context, input)?;
     let (remaining, _leading_whitespace) = space0(input)?;
@@ -34,7 +34,7 @@ pub fn clock<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, C
     Ok((remaining, Clock { source }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn inactive_timestamp_range_duration<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -56,7 +56,7 @@ fn inactive_timestamp_range_duration<'r, 's>(
     )))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn inactive_timestamp<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     recognize(tuple((
         tag("["),

src/parser/comment.rs

@@ -23,7 +23,7 @@ use crate::parser::util::immediate_in_section;
 use crate::parser::util::start_of_line;
 use crate::parser::Comment;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn comment<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, Comment<'s>> {
     if immediate_in_section(context, "comment") {
         return Err(nom::Err::Error(CustomError::MyError(MyError(
@@ -41,7 +41,7 @@ pub fn comment<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str,
     Ok((remaining, Comment { source }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn comment_line<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     start_of_line(context, input)?;
     let (remaining, _indent) = space0(input)?;

src/parser/diary_sexp.rs

@@ -13,7 +13,7 @@ use crate::parser::util::get_consumed;
 use crate::parser::util::start_of_line;
 use crate::parser::DiarySexp;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn diary_sexp<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, DiarySexp<'s>> {
     start_of_line(context, input)?;
     let (remaining, _leading_whitespace) = space0(input)?;

src/parser/document.rs

@@ -91,7 +91,7 @@ impl<'s> Source<'s> for Heading<'s> {
     }
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 #[allow(dead_code)]
 pub fn document(input: &str) -> Res<&str, Document> {
     let initial_context: ContextTree<'_, '_> = ContextTree::new();
@@ -122,7 +122,7 @@ pub fn document(input: &str) -> Res<&str, Document> {
     Ok((remaining, document))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn _document<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, Document<'s>> {
     let zeroth_section_matcher = parser_with_context!(zeroth_section)(context);
     let heading_matcher = parser_with_context!(heading)(context);
@@ -140,7 +140,7 @@ pub fn _document<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s st
     ))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn zeroth_section<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, Section<'s>> {
     // TODO: The zeroth section is specialized so it probably needs its own parser
     let parser_context = context
@@ -185,7 +185,7 @@ fn zeroth_section<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s s
     Ok((remaining, Section { source, children }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn section<'r, 's>(context: Context<'r, 's>, mut input: &'s str) -> Res<&'s str, Section<'s>> {
     // TODO: The zeroth section is specialized so it probably needs its own parser
     let parser_context = context
@@ -226,13 +226,13 @@ fn section<'r, 's>(context: Context<'r, 's>, mut input: &'s str) -> Res<&'s str,
     Ok((remaining, Section { source, children }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn section_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let headline_matcher = parser_with_context!(headline)(context);
     recognize(headline_matcher)(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn heading<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, Heading<'s>> {
     not(|i| context.check_exit_matcher(i))(input)?;
     let (remaining, (star_count, _ws, title)) = headline(context, input)?;
@@ -257,7 +257,7 @@ fn heading<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, Hea
     ))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn headline<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -280,7 +280,7 @@ fn headline<'r, 's>(
     Ok((remaining, (star_count, ws, title)))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn headline_end<'r, 's>(_context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     line_ending(input)
 }

src/parser/drawer.rs

@@ -30,7 +30,7 @@ use crate::parser::Drawer;
 use crate::parser::Element;
 use crate::parser::Paragraph;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn drawer<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, Drawer<'s>> {
     if immediate_in_section(context, "drawer") {
         return Err(nom::Err::Error(CustomError::MyError(MyError(
@@ -88,12 +88,12 @@ pub fn drawer<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str,
     ))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn name<'s>(input: &'s str) -> Res<&'s str, &'s str> {
     take_while(|c| WORD_CONSTITUENT_CHARACTERS.contains(c) || "-_".contains(c))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn drawer_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     start_of_line(context, input)?;
     recognize(tuple((

src/parser/dynamic_block.rs

@@ -30,7 +30,7 @@ use crate::parser::util::immediate_in_section;
 use crate::parser::util::start_of_line;
 use crate::parser::Element;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn dynamic_block<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -94,17 +94,17 @@ pub fn dynamic_block<'r, 's>(
     ))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn name<'s>(input: &'s str) -> Res<&'s str, &'s str> {
     is_not(" \t\r\n")(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn parameters<'s>(input: &'s str) -> Res<&'s str, &'s str> {
     is_not("\r\n")(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn dynamic_block_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     start_of_line(context, input)?;
     let (remaining, source) = recognize(tuple((

src/parser/element.rs

@@ -76,7 +76,7 @@ impl<'s> Source<'s> for Element<'s> {
 }
 
 impl<'s> SetSource<'s> for Element<'s> {
-    #[tracing::instrument(ret, level = "debug")]
+    #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
     fn set_source(&mut self, source: &'s str) {
         match self {
             Element::Paragraph(obj) => obj.source = source,

src/parser/element_parser.rs

@@ -35,7 +35,7 @@ pub fn element(
     move |context: Context, input: &str| _element(context, input, can_be_paragraph)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn _element<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,

src/parser/entity.rs

@@ -13,7 +13,7 @@ use crate::parser::object::Entity;
 use crate::parser::parser_with_context::parser_with_context;
 use crate::parser::util::get_consumed;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn entity<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, Entity<'s>> {
     let (remaining, _) = tag("\\")(input)?;
     let (remaining, entity_name) = name(context, remaining)?;
@@ -33,7 +33,7 @@ pub fn entity<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str,
     ))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn name<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     // TODO: This should be defined by org-entities and optionally org-entities-user
 
@@ -42,7 +42,7 @@ fn name<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s st
     Ok((remaining, proto))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn entity_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, ()> {
     let (remaining, _) = alt((eof, recognize(satisfy(|c| !c.is_alphabetic()))))(input)?;
 

src/parser/export_snippet.rs

@@ -16,7 +16,7 @@ use crate::parser::util::exit_matcher_parser;
 use crate::parser::util::get_consumed;
 use crate::parser::ExportSnippet;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn export_snippet<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -37,7 +37,7 @@ pub fn export_snippet<'r, 's>(
     ))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn backend<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let (remaining, backend_name) =
         recognize(many1(verify(anychar, |c| c.is_alphanumeric() || *c == '-')))(input)?;
@@ -45,7 +45,7 @@ fn backend<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s
     Ok((remaining, backend_name))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn contents<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let (remaining, source) = recognize(verify(
         many_till(

src/parser/fixed_width_area.rs

@@ -19,7 +19,7 @@ use crate::parser::util::get_consumed;
 use crate::parser::util::start_of_line;
 use crate::parser::FixedWidthArea;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn fixed_width_area<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -34,7 +34,7 @@ pub fn fixed_width_area<'r, 's>(
     Ok((remaining, FixedWidthArea { source }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn fixed_width_area_line<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,

src/parser/footnote_definition.rs

@@ -28,7 +28,7 @@ use crate::parser::util::immediate_in_section;
 use crate::parser::util::maybe_consume_trailing_whitespace;
 use crate::parser::util::start_of_line;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn footnote_definition<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -66,7 +66,7 @@ pub fn footnote_definition<'r, 's>(
     ))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn label<'s>(input: &'s str) -> Res<&'s str, &'s str> {
     alt((
         digit1,
@@ -74,7 +74,7 @@ pub fn label<'s>(input: &'s str) -> Res<&'s str, &'s str> {
     ))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn footnote_definition_end<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,

src/parser/footnote_reference.rs

@@ -21,7 +21,7 @@ use crate::parser::util::get_consumed;
 use crate::parser::FootnoteReference;
 use crate::parser::Object;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn footnote_reference<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -33,7 +33,7 @@ pub fn footnote_reference<'r, 's>(
     ))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn anonymous_footnote<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -72,7 +72,7 @@ fn anonymous_footnote<'r, 's>(
     ))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn inline_footnote<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -113,7 +113,7 @@ fn inline_footnote<'r, 's>(
     ))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn footnote_reference_only<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -133,12 +133,12 @@ fn footnote_reference_only<'r, 's>(
     ))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn definition<'s>(input: &'s str) -> Res<&'s str, Vec<Object<'s>>> {
     Ok((input, vec![]))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn footnote_definition_end<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -170,7 +170,7 @@ fn footnote_definition_end<'r, 's>(
     tag("]")(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn get_bracket_depth<'r, 's>(
     context: Context<'r, 's>,
 ) -> Option<&'r FootnoteReferenceDefinition<'s>> {

src/parser/greater_block.rs

@@ -30,7 +30,7 @@ use crate::parser::util::start_of_line;
 use crate::parser::Element;
 use crate::parser::Paragraph;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn greater_block<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -107,17 +107,17 @@ pub fn greater_block<'r, 's>(
     ))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn name<'s>(input: &'s str) -> Res<&'s str, &'s str> {
     is_not(" \t\r\n")(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn parameters<'s>(input: &'s str) -> Res<&'s str, &'s str> {
     is_not("\r\n")(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn greater_block_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     start_of_line(context, input)?;
     let current_name: &str = get_context_greater_block_name(context).ok_or(nom::Err::Error(

src/parser/horizontal_rule.rs

@@ -13,7 +13,7 @@ use crate::error::Res;
 use crate::parser::util::start_of_line;
 use crate::parser::HorizontalRule;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn horizontal_rule<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,

src/parser/inline_babel_call.rs

@@ -21,7 +21,7 @@ use crate::parser::util::exit_matcher_parser;
 use crate::parser::util::get_consumed;
 use crate::parser::InlineBabelCall;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn inline_babel_call<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -36,7 +36,7 @@ pub fn inline_babel_call<'r, 's>(
     Ok((remaining, InlineBabelCall { source }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn name<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let parser_context =
         context.with_additional_node(ContextElement::ExitMatcherNode(ExitMatcherNode {
@@ -50,12 +50,12 @@ fn name<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s st
     Ok((remaining, name))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn name_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     recognize(one_of("[("))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn header<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let (remaining, _) = tag("[")(input)?;
 
@@ -77,7 +77,7 @@ fn header<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s
     Ok((remaining, name))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn header_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let context_depth = get_bracket_depth(context)
         .expect("This function should only be called from inside an inline babel call header.");
@@ -100,7 +100,7 @@ fn header_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str,
     alt((tag("]"), line_ending))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn argument<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let (remaining, _) = tag("(")(input)?;
 
@@ -122,7 +122,7 @@ fn argument<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'
     Ok((remaining, name))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn argument_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let context_depth = get_bracket_depth(context)
         .expect("This function should only be called from inside an inline babel call argument.");
@@ -145,7 +145,7 @@ fn argument_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str
     alt((tag(")"), line_ending))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn get_bracket_depth<'r, 's>(context: Context<'r, 's>) -> Option<&'r BabelHeaderBracket<'s>> {
     for node in context.iter() {
         match node.get_data() {

src/parser/inline_source_block.rs

@@ -8,6 +8,7 @@ use nom::combinator::opt;
 use nom::combinator::recognize;
 use nom::combinator::verify;
 use nom::multi::many_till;
+#[cfg(feature = "tracing")]
 use tracing::span;
 
 use super::Context;
@@ -22,7 +23,7 @@ use crate::parser::util::exit_matcher_parser;
 use crate::parser::util::get_consumed;
 use crate::parser::InlineSourceBlock;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn inline_source_block<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -36,7 +37,7 @@ pub fn inline_source_block<'r, 's>(
     Ok((remaining, InlineSourceBlock { source }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn lang<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let parser_context =
         context.with_additional_node(ContextElement::ExitMatcherNode(ExitMatcherNode {
@@ -50,12 +51,12 @@ fn lang<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s st
     Ok((remaining, lang))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn lang_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     recognize(one_of("[{"))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn header<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let (remaining, _) = tag("[")(input)?;
 
@@ -79,7 +80,7 @@ fn header<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s
     Ok((remaining, header_contents))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn header_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let context_depth = get_bracket_depth(context)
         .expect("This function should only be called from inside an inline source block header.");
@@ -109,7 +110,7 @@ fn header_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str,
     line_ending(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn body<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let (remaining, _) = tag("{")(input)?;
 
@@ -130,18 +131,20 @@ fn body<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s st
         parser_with_context!(exit_matcher_parser)(&parser_context),
     ))(remaining)?;
     let (remaining, _) = {
+        #[cfg(feature = "tracing")]
         let span = span!(
             tracing::Level::DEBUG,
             "outside end body",
             remaining = remaining
         );
+        #[cfg(feature = "tracing")]
         let _enter = span.enter();
         tag("}")(remaining)?
     };
     Ok((remaining, body_contents))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn body_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let context_depth = get_bracket_depth(context)
         .expect("This function should only be called from inside an inline source block body.");
@@ -162,12 +165,14 @@ fn body_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'
         }
     }
     {
+        #[cfg(feature = "tracing")]
         let span = span!(
             tracing::Level::DEBUG,
             "inside end body",
             remaining = input,
             current_depth = current_depth
         );
+        #[cfg(feature = "tracing")]
         let _enter = span.enter();
 
         if current_depth == 0 {
@@ -181,7 +186,7 @@ fn body_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'
     line_ending(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn get_bracket_depth<'r, 's>(
     context: Context<'r, 's>,
 ) -> Option<&'r InlineSourceBlockBracket<'s>> {

src/parser/keyword.rs

@@ -16,7 +16,7 @@ use crate::error::Res;
 use crate::parser::util::start_of_line;
 use crate::parser::Keyword;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn keyword<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, Keyword<'s>> {
     start_of_line(context, input)?;
     // TODO: When key is a member of org-element-parsed-keywords, value can contain the standard set objects, excluding footnote references.

src/parser/latex_environment.rs

@@ -22,7 +22,7 @@ use crate::parser::util::exit_matcher_parser;
 use crate::parser::util::start_of_line;
 use crate::parser::LatexEnvironment;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn latex_environment<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -51,12 +51,15 @@ pub fn latex_environment<'r, 's>(
     Ok((remaining, LatexEnvironment { source }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn name<'s>(input: &'s str) -> Res<&'s str, &'s str> {
     take_while1(|c: char| c.is_alphanumeric() || c == '*')(input)
 }
 
-#[tracing::instrument(ret, level = "debug", skip(end_matcher))]
+#[cfg_attr(
+    feature = "tracing",
+    tracing::instrument(ret, level = "debug", skip(end_matcher))
+)]
 pub fn contents<'r, 's, F: Fn(Context<'r, 's>, &'s str) -> Res<&'s str, &'s str>>(
     end_matcher: F,
     context: Context<'r, 's>,
@@ -82,7 +85,7 @@ fn latex_environment_end(
     }
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn _latex_environment_end<'r, 's, 'x>(
     context: Context<'r, 's>,
     input: &'s str,

src/parser/latex_fragment.rs

@@ -23,7 +23,7 @@ use crate::parser::util::get_consumed;
 use crate::parser::util::get_one_before;
 use crate::parser::LatexFragment;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn latex_fragment<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -41,7 +41,7 @@ pub fn latex_fragment<'r, 's>(
     Ok((remaining, LatexFragment { source }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn raw_latex_fragment<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let (remaining, _) = tag("\\")(input)?;
     let (remaining, _) = name(context, remaining)?;
@@ -51,12 +51,12 @@ fn raw_latex_fragment<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&
     Ok((remaining, source))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn name<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     alpha1(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn brackets<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let (remaining, body) = alt((
         recognize(tuple((
@@ -85,7 +85,7 @@ fn brackets<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'
     Ok((remaining, body))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn escaped_parenthesis_fragment<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -104,7 +104,7 @@ fn escaped_parenthesis_fragment<'r, 's>(
     Ok((remaining, source))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn escaped_bracket_fragment<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -123,7 +123,7 @@ fn escaped_bracket_fragment<'r, 's>(
     Ok((remaining, source))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn double_dollar_fragment<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -143,7 +143,7 @@ fn double_dollar_fragment<'r, 's>(
     Ok((remaining, source))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn dollar_char_fragment<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let (_, _) = pre(context, input)?;
     let (remaining, _) = tag("$")(input)?;
@@ -155,7 +155,7 @@ fn dollar_char_fragment<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res
     Ok((remaining, source))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn pre<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, ()> {
     let document_root = context.get_document_root().unwrap();
     let preceding_character = get_one_before(document_root, input)
@@ -169,7 +169,7 @@ pub fn pre<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, ()>
     Ok((input, ()))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn post<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, ()> {
     // TODO: What about eof? Test to find out.
 
@@ -178,7 +178,7 @@ pub fn post<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, ()
     Ok((remaining, ()))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn bordered_dollar_fragment<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -208,12 +208,12 @@ fn bordered_dollar_fragment<'r, 's>(
     Ok((remaining, source))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn open_border<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     recognize(verify(none_of(".,;$"), |c| !c.is_whitespace()))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn close_border<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, ()> {
     let document_root = context.get_document_root().unwrap();
     let preceding_character = get_one_before(document_root, input)

src/parser/lesser_block.rs

@@ -31,7 +31,7 @@ use crate::parser::util::get_consumed;
 use crate::parser::util::start_of_line;
 use crate::parser::util::text_until_exit;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn verse_block<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -80,7 +80,7 @@ pub fn verse_block<'r, 's>(
     ))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn comment_block<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -116,7 +116,7 @@ pub fn comment_block<'r, 's>(
     ))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn example_block<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -152,7 +152,7 @@ pub fn example_block<'r, 's>(
     ))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn export_block<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -189,7 +189,7 @@ pub fn export_block<'r, 's>(
     ))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn src_block<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, SrcBlock<'s>> {
     let (remaining, name) = lesser_block_begin("src")(context, input)?;
     // https://orgmode.org/worg/org-syntax.html#Blocks claims that data is mandatory and must follow the LANGUAGE SWITCHES ARGUMENTS pattern but testing has shown that no data and incorrect data here will still parse to a src block.
@@ -223,12 +223,12 @@ pub fn src_block<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s st
     ))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn name<'s>(input: &'s str) -> Res<&'s str, &'s str> {
     is_not(" \t\r\n")(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn data<'s>(input: &'s str) -> Res<&'s str, &'s str> {
     is_not("\r\n")(input)
 }

src/parser/line_break.rs

@@ -13,7 +13,7 @@ use crate::parser::util::get_current_line_before_position;
 use crate::parser::util::get_one_before;
 use crate::parser::LineBreak;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn line_break<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, LineBreak<'s>> {
     let (remaining, _) = pre(context, input)?;
     let (remaining, _) = tag(r#"\\"#)(remaining)?;
@@ -23,7 +23,7 @@ pub fn line_break<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s s
     Ok((remaining, LineBreak { source }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn pre<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, ()> {
     let document_root = context.get_document_root().unwrap();
     let preceding_character = get_one_before(document_root, input)

src/parser/object_parser.rs

@@ -28,7 +28,7 @@ use crate::parser::target::target;
 use crate::parser::text_markup::text_markup;
 use crate::parser::timestamp::timestamp;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn standard_set_object<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -87,7 +87,7 @@ pub fn standard_set_object<'r, 's>(
     ))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn minimal_set_object<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -110,7 +110,7 @@ pub fn minimal_set_object<'r, 's>(
     ))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn any_object_except_plain_text<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -167,7 +167,7 @@ pub fn any_object_except_plain_text<'r, 's>(
     ))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn regular_link_description_object_set<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,

src/parser/org_macro.rs

@@ -14,7 +14,7 @@ use crate::parser::parser_with_context::parser_with_context;
 use crate::parser::util::exit_matcher_parser;
 use crate::parser::util::get_consumed;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn org_macro<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, OrgMacro<'s>> {
     let (remaining, _) = tag("{{{")(input)?;
     let (remaining, macro_name) = org_macro_name(context, remaining)?;
@@ -32,7 +32,7 @@ pub fn org_macro<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s st
     ))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn org_macro_name<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let (remaining, _) = verify(anychar, |c| c.is_alphabetic())(input)?;
     let (remaining, _) = many0(verify(anychar, |c| {
@@ -42,7 +42,7 @@ fn org_macro_name<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s s
     Ok((remaining, source))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn org_macro_args<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, Vec<&'s str>> {
     let (remaining, _) = tag("(")(input)?;
     let (remaining, args) =
@@ -52,7 +52,7 @@ fn org_macro_args<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s s
     Ok((remaining, args))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn org_macro_arg<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let mut remaining = input;
     let mut escaping: bool = false;

src/parser/paragraph.rs

@@ -20,7 +20,7 @@ use crate::parser::parser_with_context::parser_with_context;
 use crate::parser::util::exit_matcher_parser;
 use crate::parser::util::start_of_line;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn paragraph<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, Paragraph<'s>> {
     let parser_context =
         context.with_additional_node(ContextElement::ExitMatcherNode(ExitMatcherNode {
@@ -42,7 +42,7 @@ pub fn paragraph<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s st
     Ok((remaining, Paragraph { source, children }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn paragraph_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let non_paragraph_element_matcher = parser_with_context!(element(false))(context);
     let start_of_line_matcher = parser_with_context!(start_of_line)(&context);

src/parser/parser_context.rs

@@ -44,7 +44,7 @@ impl<'r, 's> ContextTree<'r, 's> {
         self.tree.iter()
     }
 
-    #[tracing::instrument(ret, level = "debug")]
+    #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
     pub fn check_exit_matcher(
         &'r self,
         i: &'s str,

src/parser/plain_link.rs

@@ -23,7 +23,7 @@ use crate::parser::util::get_consumed;
 use crate::parser::util::get_one_before;
 use crate::parser::util::WORD_CONSTITUENT_CHARACTERS;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn plain_link<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, PlainLink<'s>> {
     let (remaining, _) = pre(context, input)?;
     let (remaining, proto) = protocol(context, remaining)?;
@@ -41,7 +41,7 @@ pub fn plain_link<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s s
     ))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn pre<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, ()> {
     let document_root = context.get_document_root().unwrap();
     let preceding_character = get_one_before(document_root, input)
@@ -61,13 +61,13 @@ fn pre<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, ()> {
     Ok((input, ()))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn post<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, ()> {
     let (remaining, _) = alt((eof, recognize(none_of(WORD_CONSTITUENT_CHARACTERS))))(input)?;
     Ok((remaining, ()))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn protocol<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     // TODO: This should be defined by org-link-parameters
     let (remaining, proto) = alt((
@@ -102,7 +102,7 @@ pub fn protocol<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str
     Ok((remaining, proto))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn path_plain<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     // TODO: "optionally containing parenthesis-wrapped non-whitespace non-bracket substrings up to a depth of two. The string must end with either a non-punctation non-whitespace character, a forwards slash, or a parenthesis-wrapped substring"
     let parser_context =
@@ -117,7 +117,7 @@ fn path_plain<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str,
     Ok((remaining, path))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn path_plain_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     recognize(one_of(" \t\r\n()[]<>"))(input)
 }

src/parser/plain_list.rs

@@ -14,6 +14,7 @@ use nom::multi::many_till;
 use nom::sequence::preceded;
 use nom::sequence::terminated;
 use nom::sequence::tuple;
+#[cfg(feature = "tracing")]
 use tracing::span;
 
 use super::greater_element::PlainList;
@@ -33,7 +34,7 @@ use crate::parser::util::exit_matcher_parser;
 use crate::parser::util::get_consumed;
 use crate::parser::util::start_of_line;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn plain_list<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, PlainList<'s>> {
     let parser_context = context
         .with_additional_node(ContextElement::Context("plain list"))
@@ -63,7 +64,9 @@ pub fn plain_list<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s s
          */
         {
             // Don't consume, yes exit matcher
+            #[cfg(feature = "tracing")]
             let span = span!(tracing::Level::DEBUG, "first");
+            #[cfg(feature = "tracing")]
             let _enter = span.enter();
 
             let last_item_then_exit = tuple((without_consume_matcher, exit_matcher))(remaining);
@@ -82,7 +85,9 @@ pub fn plain_list<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s s
 
         {
             // Consume, additional item
+            #[cfg(feature = "tracing")]
             let span = span!(tracing::Level::DEBUG, "second");
+            #[cfg(feature = "tracing")]
             let _enter = span.enter();
 
             let not_last_item =
@@ -104,7 +109,9 @@ pub fn plain_list<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s s
 
         {
             // Don't consume, no additional item
+            #[cfg(feature = "tracing")]
             let span = span!(tracing::Level::DEBUG, "third");
+            #[cfg(feature = "tracing")]
             let _enter = span.enter();
 
             let last_item_then_exit = without_consume_matcher(remaining);
@@ -138,7 +145,7 @@ pub fn plain_list<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s s
     Ok((remaining, PlainList { source, children }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn plain_list_item<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -208,7 +215,7 @@ pub fn plain_list_item<'r, 's>(
     };
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn bullet<'s>(i: &'s str) -> Res<&'s str, &'s str> {
     alt((
         tag("*"),
@@ -218,12 +225,12 @@ fn bullet<'s>(i: &'s str) -> Res<&'s str, &'s str> {
     ))(i)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn counter<'s>(i: &'s str) -> Res<&'s str, &'s str> {
     alt((recognize(one_of("abcdefghijklmnopqrstuvwxyz")), digit1))(i)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn plain_list_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let start_of_line_matcher = parser_with_context!(start_of_line)(context);
     recognize(tuple((
@@ -232,7 +239,7 @@ fn plain_list_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s s
     )))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn plain_list_item_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let current_item_indent_level: &usize =
         get_context_item_indent(context).ok_or(nom::Err::Error(CustomError::MyError(MyError(
@@ -248,7 +255,7 @@ fn plain_list_item_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<
     ))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn line_indented_lte<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let current_item_indent_level: &usize =
         get_context_item_indent(context).ok_or(nom::Err::Error(CustomError::MyError(MyError(

src/parser/plain_text.rs

@@ -16,7 +16,7 @@ use crate::parser::object_parser::any_object_except_plain_text;
 use crate::parser::parser_with_context::parser_with_context;
 use crate::parser::util::exit_matcher_parser;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn plain_text<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, PlainText<'s>> {
     let (remaining, source) = recognize(verify(
         many_till(
@@ -32,13 +32,13 @@ pub fn plain_text<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s s
     Ok((remaining, PlainText { source }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn plain_text_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     recognize(parser_with_context!(any_object_except_plain_text)(context))(input)
 }
 
 impl<'x> RematchObject<'x> for PlainText<'x> {
-    #[tracing::instrument(ret, level = "debug")]
+    #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
     fn rematch_object<'r, 's>(
         &'x self,
         _context: Context<'r, 's>,

src/parser/planning.rs

@@ -15,7 +15,7 @@ use crate::parser::lesser_element::Planning;
 use crate::parser::util::get_consumed;
 use crate::parser::util::start_of_line;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn planning<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, Planning<'s>> {
     start_of_line(context, input)?;
     let (remaining, _leading_whitespace) = space0(input)?;
@@ -27,7 +27,7 @@ pub fn planning<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str
     Ok((remaining, Planning { source }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn planning_parameter<'s>(input: &'s str) -> Res<&'s str, &'s str> {
     let (remaining, _planning_type) = alt((
         tag_no_case("DEADLINE"),

src/parser/property_drawer.rs

@@ -29,7 +29,7 @@ use crate::parser::util::immediate_in_section;
 use crate::parser::util::maybe_consume_trailing_whitespace_if_not_exiting;
 use crate::parser::util::start_of_line;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn property_drawer<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -71,7 +71,7 @@ pub fn property_drawer<'r, 's>(
     Ok((remaining, PropertyDrawer { source, children }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn property_drawer_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     recognize(tuple((
         parser_with_context!(start_of_line)(context),
@@ -82,7 +82,7 @@ fn property_drawer_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<
     )))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn node_property<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -121,7 +121,7 @@ fn node_property<'r, 's>(
     }
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn node_property_name<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let parser_context =
         context.with_additional_node(ContextElement::ExitMatcherNode(ExitMatcherNode {
@@ -138,7 +138,7 @@ fn node_property_name<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&
     Ok((remaining, name))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn node_property_name_end<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,

src/parser/radio_link.rs

@@ -20,7 +20,7 @@ use crate::parser::util::get_consumed;
 use crate::parser::RadioLink;
 use crate::parser::RadioTarget;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn radio_link<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, RadioLink<'s>> {
     let radio_targets = context
         .iter()
@@ -48,7 +48,7 @@ pub fn radio_link<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s s
     ))))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn rematch_target<'x, 'r, 's>(
     context: Context<'r, 's>,
     target: &'x Vec<Object<'x>>,
@@ -79,7 +79,7 @@ pub fn rematch_target<'x, 'r, 's>(
     Ok((remaining, new_matches))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn radio_target<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -105,7 +105,7 @@ pub fn radio_target<'r, 's>(
     Ok((remaining, RadioTarget { source, children }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn radio_target_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     alt((tag("<"), tag(">"), line_ending))(input)
 }

src/parser/regular_link.rs

@@ -19,7 +19,7 @@ use crate::parser::parser_context::ContextElement;
 use crate::parser::parser_context::ExitMatcherNode;
 use crate::parser::util::exit_matcher_parser;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn regular_link<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -30,7 +30,7 @@ pub fn regular_link<'r, 's>(
     ))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn regular_link_without_description<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -43,7 +43,7 @@ pub fn regular_link_without_description<'r, 's>(
     Ok((remaining, RegularLink { source }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn regular_link_with_description<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -58,7 +58,7 @@ pub fn regular_link_with_description<'r, 's>(
     Ok((remaining, RegularLink { source }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn pathreg<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let (remaining, path) = escaped(
         take_till1(|c| match c {
@@ -71,7 +71,7 @@ pub fn pathreg<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str,
     Ok((remaining, path))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn description<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -92,7 +92,7 @@ pub fn description<'r, 's>(
     Ok((remaining, children))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn description_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     tag("]]")(input)
 }

src/parser/sexp.rs

@@ -120,7 +120,7 @@ impl<'s> Token<'s> {
     }
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn sexp_with_padding<'s>(input: &'s str) -> Res<&'s str, Token<'s>> {
     let (remaining, _) = multispace0(input)?;
     let (remaining, tkn) = token(remaining)?;
@@ -128,18 +128,18 @@ pub fn sexp_with_padding<'s>(input: &'s str) -> Res<&'s str, Token<'s>> {
     Ok((remaining, tkn))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn sexp<'s>(input: &'s str) -> Res<&'s str, Token<'s>> {
     let (remaining, tkn) = token(input)?;
     Ok((remaining, tkn))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn token<'s>(input: &'s str) -> Res<&'s str, Token<'s>> {
     alt((list, atom))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn list<'s>(input: &'s str) -> Res<&'s str, Token<'s>> {
     let (remaining, _) = tag("(")(input)?;
     let (remaining, children) = delimited(
@@ -151,13 +151,13 @@ fn list<'s>(input: &'s str) -> Res<&'s str, Token<'s>> {
     Ok((remaining, Token::List(children)))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn atom<'s>(input: &'s str) -> Res<&'s str, Token<'s>> {
     not(peek(tag(")")))(input)?;
     alt((text_with_properties, quoted_atom, unquoted_atom))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn unquoted_atom<'s>(input: &'s str) -> Res<&'s str, Token<'s>> {
     let (remaining, body) = take_till1(|c| match c {
         ' ' | '\t' | '\r' | '\n' | ')' => true,
@@ -166,7 +166,7 @@ fn unquoted_atom<'s>(input: &'s str) -> Res<&'s str, Token<'s>> {
     Ok((remaining, Token::Atom(body)))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn quoted_atom<'s>(input: &'s str) -> Res<&'s str, Token<'s>> {
     let (remaining, _) = tag(r#"""#)(input)?;
     let (remaining, _) = escaped(

src/parser/statistics_cookie.rs

@@ -9,7 +9,7 @@ use crate::error::Res;
 use crate::parser::parser_with_context::parser_with_context;
 use crate::parser::StatisticsCookie;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn statistics_cookie<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -20,7 +20,7 @@ pub fn statistics_cookie<'r, 's>(
     ))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn percent_statistics_cookie<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -31,7 +31,7 @@ pub fn percent_statistics_cookie<'r, 's>(
     Ok((remaining, StatisticsCookie { source }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn fraction_statistics_cookie<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,

src/parser/subscript_and_superscript.rs

@@ -28,7 +28,7 @@ use crate::parser::util::get_one_before;
 use crate::parser::Subscript;
 use crate::parser::Superscript;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn subscript<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, Subscript<'s>> {
     // We check for the underscore first before checking the pre-character as a minor optimization to avoid walking up the context tree to find the document root unnecessarily.
     let (remaining, _) = tag("_")(input)?;
@@ -39,7 +39,7 @@ pub fn subscript<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s st
     Ok((remaining, Subscript { source }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn superscript<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -53,7 +53,7 @@ pub fn superscript<'r, 's>(
     Ok((remaining, Superscript { source }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn pre<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, ()> {
     let document_root = context.get_document_root().unwrap();
     let preceding_character = get_one_before(document_root, input)
@@ -76,7 +76,7 @@ enum ScriptBody<'s> {
     WithBraces(Vec<Object<'s>>),
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn script_body<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, ScriptBody<'s>> {
     alt((
         map(parser_with_context!(script_asterisk)(context), |body| {
@@ -91,12 +91,12 @@ fn script_body<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str,
     ))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn script_asterisk<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     tag("*")(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn script_alphanum<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let (remaining, _sign) = opt(recognize(one_of("+-")))(input)?;
     let (remaining, _script) = many_till(
@@ -107,7 +107,7 @@ fn script_alphanum<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s
     Ok((remaining, source))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn script_alphanum_character<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -117,7 +117,7 @@ fn script_alphanum_character<'r, 's>(
     }))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn end_script_alphanum_character<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -129,7 +129,7 @@ fn end_script_alphanum_character<'r, 's>(
     Ok((remaining, final_char))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn script_with_braces<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -156,7 +156,7 @@ fn script_with_braces<'r, 's>(
     Ok((remaining, children))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn script_with_braces_end<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -190,7 +190,7 @@ fn script_with_braces_end<'r, 's>(
     ))));
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn get_bracket_depth<'r, 's>(
     context: Context<'r, 's>,
 ) -> Option<&'r SubscriptSuperscriptBrace<'s>> {

src/parser/table.rs

@@ -30,7 +30,7 @@ use crate::parser::Table;
 /// Parse an org-mode-style table
 ///
 /// This is not the table.el style.
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn org_mode_table<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, Table<'s>> {
     start_of_line(context, input)?;
     peek(tuple((space0, tag("|"))))(input)?;
@@ -55,13 +55,13 @@ pub fn org_mode_table<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&
     Ok((remaining, Table { source, children }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn table_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     start_of_line(context, input)?;
     recognize(tuple((space0, not(tag("|")))))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn org_mode_table_row<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -72,7 +72,7 @@ pub fn org_mode_table_row<'r, 's>(
     ))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn org_mode_table_row_rule<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -89,7 +89,7 @@ pub fn org_mode_table_row_rule<'r, 's>(
     ))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn org_mode_table_row_regular<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -103,7 +103,7 @@ pub fn org_mode_table_row_regular<'r, 's>(
     Ok((remaining, TableRow { source, children }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn org_mode_table_cell<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -128,7 +128,7 @@ pub fn org_mode_table_cell<'r, 's>(
     Ok((remaining, TableCell { source, children }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn org_mode_table_cell_end<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -136,7 +136,7 @@ fn org_mode_table_cell_end<'r, 's>(
     recognize(tuple((space0, alt((tag("|"), peek(line_ending))))))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn table_cell_set_object<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,

src/parser/target.rs

@@ -20,7 +20,7 @@ use crate::parser::util::get_consumed;
 use crate::parser::util::get_one_before;
 use crate::parser::Target;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn target<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, Target<'s>> {
     let (remaining, _) = tag("<<")(input)?;
     let (remaining, _) = peek(verify(anychar, |c| {
@@ -54,7 +54,7 @@ pub fn target<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str,
     Ok((remaining, Target { source }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn target_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     recognize(one_of("<>\n"))(input)
 }

src/parser/text_markup.rs

@@ -12,6 +12,7 @@ use nom::combinator::recognize;
 use nom::combinator::verify;
 use nom::multi::many_till;
 use nom::sequence::terminated;
+#[cfg(feature = "tracing")]
 use tracing::span;
 
 use super::radio_link::RematchObject;
@@ -37,7 +38,7 @@ use crate::parser::StrikeThrough;
 use crate::parser::Underline;
 use crate::parser::Verbatim;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn text_markup<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, Object<'s>> {
     alt((
         map(parser_with_context!(bold)(context), Object::Bold),
@@ -52,7 +53,7 @@ pub fn text_markup<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s
     ))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn bold<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, Bold<'s>> {
     let text_markup_object_specialized = text_markup_object("*");
     let (remaining, children) = text_markup_object_specialized(context, input)?;
@@ -60,7 +61,7 @@ pub fn bold<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, Bo
     Ok((remaining, Bold { source, children }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn italic<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, Italic<'s>> {
     let text_markup_object_specialized = text_markup_object("/");
     let (remaining, children) = text_markup_object_specialized(context, input)?;
@@ -68,7 +69,7 @@ pub fn italic<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str,
     Ok((remaining, Italic { source, children }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn underline<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, Underline<'s>> {
     let text_markup_object_specialized = text_markup_object("_");
     let (remaining, children) = text_markup_object_specialized(context, input)?;
@@ -76,7 +77,7 @@ pub fn underline<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s st
     Ok((remaining, Underline { source, children }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn strike_through<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -87,7 +88,7 @@ pub fn strike_through<'r, 's>(
     Ok((remaining, StrikeThrough { source, children }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn verbatim<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, Verbatim<'s>> {
     let text_markup_string_specialized = text_markup_string("=");
     let (remaining, contents) = text_markup_string_specialized(context, input)?;
@@ -95,7 +96,7 @@ pub fn verbatim<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str
     Ok((remaining, Verbatim { source, contents }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn code<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, Code<'s>> {
     let text_markup_string_specialized = text_markup_string("~");
     let (remaining, contents) = text_markup_string_specialized(context, input)?;
@@ -110,7 +111,7 @@ fn text_markup_object(
     move |context: Context, input: &str| _text_markup_object(context, input, marker_symbol.as_str())
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn _text_markup_object<'r, 's, 'x>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -135,7 +136,9 @@ fn _text_markup_object<'r, 's, 'x>(
     )(remaining)?;
 
     {
+        #[cfg(feature = "tracing")]
         let span = span!(tracing::Level::DEBUG, "Checking parent exit.");
+        #[cfg(feature = "tracing")]
         let _enter = span.enter();
         if exit_matcher_parser(context, remaining).is_ok() {
             return Err(nom::Err::Error(CustomError::MyError(MyError(
@@ -156,7 +159,7 @@ fn text_markup_string(
     move |context: Context, input: &str| _text_markup_string(context, input, marker_symbol.as_str())
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn _text_markup_string<'r, 's, 'x>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -181,7 +184,9 @@ fn _text_markup_string<'r, 's, 'x>(
     ))(remaining)?;
 
     {
+        #[cfg(feature = "tracing")]
         let span = span!(tracing::Level::DEBUG, "Checking parent exit.");
+        #[cfg(feature = "tracing")]
         let _enter = span.enter();
         if exit_matcher_parser(context, remaining).is_ok() {
             return Err(nom::Err::Error(CustomError::MyError(MyError(
@@ -195,7 +200,7 @@ fn _text_markup_string<'r, 's, 'x>(
     Ok((remaining, contents))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn pre<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, ()> {
     let document_root = context.get_document_root().unwrap();
     let preceding_character = get_one_before(document_root, input)
@@ -215,7 +220,7 @@ pub fn pre<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, ()>
     Ok((input, ()))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn post<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, ()> {
     let (remaining, _) = alt((recognize(one_of(" \r\n\t-.,;:!?')}[\">")), line_ending))(input)?;
     Ok((remaining, ()))
@@ -228,7 +233,7 @@ fn text_markup_end(
     move |context: Context, input: &str| _text_markup_end(context, input, marker_symbol.as_str())
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn _text_markup_end<'r, 's, 'x>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -244,7 +249,7 @@ fn _text_markup_end<'r, 's, 'x>(
 }
 
 impl<'x> RematchObject<'x> for Bold<'x> {
-    #[tracing::instrument(ret, level = "debug")]
+    #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
     fn rematch_object<'r, 's>(
         &'x self,
         _context: Context<'r, 's>,
@@ -257,7 +262,7 @@ impl<'x> RematchObject<'x> for Bold<'x> {
     }
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn _rematch_text_markup_object<'r, 's, 'x>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -279,7 +284,9 @@ fn _rematch_text_markup_object<'r, 's, 'x>(
         rematch_target(&parser_context, original_match_children, remaining)?;
 
     {
+        #[cfg(feature = "tracing")]
         let span = span!(tracing::Level::DEBUG, "Checking parent exit.");
+        #[cfg(feature = "tracing")]
         let _enter = span.enter();
         if exit_matcher_parser(context, remaining).is_ok() {
             return Err(nom::Err::Error(CustomError::MyError(MyError(

src/parser/timestamp.rs

@@ -22,7 +22,7 @@ use crate::parser::util::exit_matcher_parser;
 use crate::parser::util::get_consumed;
 use crate::parser::Timestamp;
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn timestamp<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, Timestamp<'s>> {
     // TODO: This would be more efficient if we didn't throw away the parse result of the first half of an active/inactive date range timestamp if the parse fails (as in, the first thing active_date_range_timestamp parses is a active_timestamp but then we throw that away if it doesn't turn out to be a full active_date_range_timestamp despite the active_timestamp parse being completely valid). I am going with the simplest/cleanest approach for the first implementation.
     alt((
@@ -37,7 +37,7 @@ pub fn timestamp<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s st
     ))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn diary_timestamp<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -51,7 +51,7 @@ fn diary_timestamp<'r, 's>(
     Ok((remaining, Timestamp { source }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn sexp<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let parser_context =
         context.with_additional_node(ContextElement::ExitMatcherNode(ExitMatcherNode {
@@ -70,12 +70,12 @@ fn sexp<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s st
     Ok((remaining, body))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn sexp_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     alt((tag(")>"), recognize(one_of(">\n"))))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn active_timestamp<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -103,7 +103,7 @@ fn active_timestamp<'r, 's>(
     Ok((remaining, Timestamp { source }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn inactive_timestamp<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -131,7 +131,7 @@ fn inactive_timestamp<'r, 's>(
     Ok((remaining, Timestamp { source }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn active_date_range_timestamp<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -147,7 +147,7 @@ fn active_date_range_timestamp<'r, 's>(
     Ok((remaining, Timestamp { source }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn active_time_range_timestamp<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -182,7 +182,7 @@ fn active_time_range_timestamp<'r, 's>(
     Ok((remaining, Timestamp { source }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn inactive_date_range_timestamp<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -198,7 +198,7 @@ fn inactive_date_range_timestamp<'r, 's>(
     Ok((remaining, Timestamp { source }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn inactive_time_range_timestamp<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -233,7 +233,7 @@ fn inactive_time_range_timestamp<'r, 's>(
     Ok((remaining, Timestamp { source }))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn date<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let (remaining, _year) = verify(digit1, |year: &str| year.len() == 4)(input)?;
     let (remaining, _) = tag("-")(remaining)?;
@@ -247,7 +247,7 @@ fn date<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s st
     Ok((remaining, source))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn dayname<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let parser_context =
         context.with_additional_node(ContextElement::ExitMatcherNode(ExitMatcherNode {
@@ -266,14 +266,14 @@ fn dayname<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s
     Ok((remaining, body))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn dayname_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     recognize(verify(anychar, |c| {
         c.is_whitespace() || "+-]>0123456789\n".contains(*c)
     }))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn time<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let (remaining, _hour) =
         verify(digit1, |hour: &str| hour.len() >= 1 && hour.len() <= 2)(input)?;
@@ -284,7 +284,7 @@ fn time<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s st
     Ok((remaining, source))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn time_rest<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     let (remaining, body) = recognize(verify(
         many_till(anychar, parser_with_context!(exit_matcher_parser)(context)),
@@ -294,7 +294,7 @@ fn time_rest<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &
     Ok((remaining, body))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn active_time_rest_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     alt((
         recognize(verify(anychar, |c| ">\n".contains(*c))),
@@ -306,7 +306,7 @@ fn active_time_rest_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res
     ))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn inactive_time_rest_end<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -321,7 +321,7 @@ fn inactive_time_rest_end<'r, 's>(
     ))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn time_range_rest_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     // We pop off the most recent context element to get a context tree with just the active/inactive_time_rest_end exit matcher (removing this function from the exit matcher chain) because the 2nd time in the range does not end when a "-TIME" pattern is found.
     let parent_node = context.iter().next().expect("Two context elements are added to the tree when adding this exit matcher, so it should be impossible for this to return None.");
@@ -331,7 +331,7 @@ fn time_range_rest_end<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<
     exit_contents
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn repeater<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     // + for cumulative type
     // ++ for catch-up type
@@ -344,7 +344,7 @@ fn repeater<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'
     Ok((remaining, source))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 fn warning_delay<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     // - for all type
     // -- for first type

src/parser/util.rs

@@ -107,13 +107,13 @@ pub fn get_consumed<'s>(input: &'s str, remaining: &'s str) -> &'s str {
 /// A line containing only whitespace and then a line break
 ///
 /// It is up to the caller to ensure this is called at the start of a line.
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn blank_line(input: &str) -> Res<&str, &str> {
     not(eof)(input)?;
     recognize(tuple((space0, alt((line_ending, eof)))))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn element_trailing_whitespace<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -122,7 +122,7 @@ pub fn element_trailing_whitespace<'r, 's>(
     alt((eof, recognize(many0(blank_line))))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn maybe_consume_trailing_whitespace_if_not_exiting<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -137,7 +137,7 @@ pub fn maybe_consume_trailing_whitespace_if_not_exiting<'r, 's>(
     }
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn maybe_consume_trailing_whitespace<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -151,13 +151,13 @@ pub fn maybe_consume_trailing_whitespace<'r, 's>(
     }
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn trailing_whitespace(input: &str) -> Res<&str, &str> {
     alt((eof, recognize(tuple((line_ending, many0(blank_line))))))(input)
 }
 
 /// Check that we are at the start of a line
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn start_of_line<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, ()> {
     let document_root = context.get_document_root().unwrap();
     let preceding_character = get_one_before(document_root, input)
@@ -178,7 +178,7 @@ pub fn start_of_line<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'
 }
 
 /// Check that we are at the start of a line
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn preceded_by_whitespace<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -202,13 +202,13 @@ pub fn preceded_by_whitespace<'r, 's>(
 /// Pull one non-whitespace character.
 ///
 /// This function only operates on spaces, tabs, carriage returns, and line feeds. It does not handle fancy unicode whitespace.
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn non_whitespace_character(input: &str) -> Res<&str, char> {
     none_of(" \t\r\n")(input)
 }
 
 /// Check that we are at the start of a line
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn exit_matcher_parser<'r, 's>(
     context: Context<'r, 's>,
     input: &'s str,
@@ -216,19 +216,19 @@ pub fn exit_matcher_parser<'r, 's>(
     peek(|i| context.check_exit_matcher(i))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn always_fail<'r, 's>(_context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     Err(nom::Err::Error(CustomError::MyError(MyError(
         "Always fail",
     ))))
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn whitespace_eof(input: &str) -> Res<&str, &str> {
     recognize(tuple((multispace0, eof)))(input)
 }
 
-#[tracing::instrument(ret, level = "debug")]
+#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
 pub fn text_until_exit<'r, 's>(context: Context<'r, 's>, input: &'s str) -> Res<&'s str, &'s str> {
     recognize(verify(
         many_till(anychar, parser_with_context!(exit_matcher_parser)(context)),