Bump version to 0.1.2 and change README to markdown.

crates.io does not support org-mode for README files so I am changing this to markdown.

.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/pipeline-rustfmt.yaml

@@ -81,14 +81,6 @@ spec:
             value: $(params.PULL_BASE_SHA)
           - name: deleteExisting
             value: "true"
-      - name: detect-tag
-        taskRef:
-          name: detect-tag
-        workspaces:
-          - name: repo
-            workspace: git-source
-        runAfter:
-          - fetch-repository
       - name: build-image
         taskRef:
           name: kaniko
@@ -118,7 +110,6 @@ spec:
             workspace: docker-credentials
         runAfter:
           - fetch-repository
-          - detect-tag
       - name: rustfmt
         taskRef:
           name: run-docker-image

.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

@@ -1,37 +1,42 @@
 [package]
 name = "organic"
-version = "0.1.0"
+version = "0.1.2"
 authors = ["Tom Alexander <tom@fizz.buzz>"]
 description = "An org-mode parser."
 edition = "2021"
 license = "0BSD"
 repository = "https://code.fizz.buzz/talexander/organic"
-readme = "README.org"
+readme = "README.md"
 keywords = ["emacs", "org-mode"]
-categories = ["template-engine"]
+categories = ["parsing"]
+resolver = "2"
 
 [lib]
 name = "organic"
 path = "src/lib.rs"
 
 [[bin]]
-name = "toy"
+# This bin exists for development purposes only. The real target of this crate is the library.
+name = "compare"
 path = "src/main.rs"
 
 [dependencies]
 nom = "7.1.1"
-opentelemetry = "0.17.0"
+opentelemetry = { version = "0.20.0", optional = true, default-features = false, features = ["trace", "rt-tokio"] }
-opentelemetry-jaeger = "0.16.0"
+opentelemetry-otlp = { version = "0.13.0", optional = true }
-tracing = "0.1.37"
+opentelemetry-semantic-conventions = { version = "0.12.0", optional = true }
-tracing-opentelemetry = "0.17.2"
+tokio = { version = "1.30.0", optional = true, default-features = false, features = ["rt", "rt-multi-thread"] }
-tracing-subscriber = {version="0.3.16", features=["env-filter"]}
+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

@@ -45,17 +45,12 @@ integrationtest:
 unittest:
 > cargo test --lib -- --test-threads $(TESTJOBS)
 
-.PHONY: run
-run:
-> cargo run
-
-.PHONY: debug
-debug:
-> RUST_LOG=debug cargo run
-
 .PHONY: jaeger
 jaeger:
-> docker run -d --rm --name toylanguagedocker -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:
@@ -63,4 +58,4 @@ jaegerweb:
 
 .PHONY: jaegerstop
 jaegerstop:
-> docker stop toylanguagedocker
+> docker stop organicdocker

README.md

@@ -0,0 +1,13 @@
+# Organic - Free Range Org-Mode
+
+Organic is an emacs-less implementation of an [org-mode](https://orgmode.org/) parser.
+
+
+## Project Status
+
+This project is a personal learning project to grow my experience in [rust](https://www.rust-lang.org/). It is under development and at this time I would not recommend anyone use this code. The goal is to turn this into a project others can use, at which point more information will appear in this README.
+
+
+## License
+
+This project is released under the public-domain-equivalent [0BSD license](https://www.tldrlegal.com/license/bsd-0-clause-license). This license puts no restrictions on the use of this code (you do not even have to include the copyright notice or license text when using it). HOWEVER, this project has a couple permissively licensed dependencies which do require their copyright notices and/or license texts to be included. I am not a lawyer and this is not legal advice but it is my layperson's understanding that if you distribute a binary with this library linked in, you will need to abide by their terms since their code will also be linked in your binary. I try to keep the dependencies to a minimum and the most restrictive dependency I will ever include is a permissively licensed one.

README.org

@@ -1,10 +0,0 @@
-#+options: toc:nil
-#+title: Organic - Free Range Org-Mode
-
-Organic is an emacs-less implementation of an [[https://orgmode.org/][org-mode]] parser.
-
-* Project Status
-This project is a personal learning project to grow my experience in [[https://www.rust-lang.org/][rust]]. It is under development and at this time I would not recommend anyone use this code. The goal is to turn this into a project others can use, at which point more information will appear in this README.
-
-* License
-This project is released under the public-domain-equivalent [[https://www.tldrlegal.com/license/bsd-0-clause-license][0BSD license]]. This license puts no restrictions on the use of this code (you do not even have to include the copyright notice or license text when using it). HOWEVER, this project has a couple permissively licensed dependencies which do require their copyright notices and/or license texts to be included. I am not a lawyer and this is not legal advice but it is my layperson's understanding that if you distribute a binary with this library linked in, you will need to abide by their terms since their code will also be linked in your binary. I try to keep the dependencies to a minimum and the most restrictive dependency I will ever include is a permissively licensed one.

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)

notes/exit_matcher_loop_notes.txt

@@ -1,35 +0,0 @@
-Headings add exit matcher for heading
-
-Paragraphs add exit matcher for elements (but it should be sans paragraph)
-
-
-
-
-* foo
-* bar
-* baz
-
-context tree -> ()
-
-match * foo
-
-context tree -> exit(heading matcher)
-
-check exit
-invoke heading matcher
-check exit
-invoke heading matcher
-check exit
-invoke heading matcher
-adds second heading matcher exit
-
-
-Ways around this:
-- Always parse SOMETHING before checking for exit
-  - Doesn't always seem possible
-- Disable exit matchers during exit check
-  - Seems like it would break syntax
-- Have separate parsers for the beginning of the exit condition (for example, checking for just the headline instead of the full heading parser)
-  - Won't be possible with paragraphs ending at any other element
-- Check exit matchers in parent parser
-  - Will this work? seems like it would just create larger loops

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()
+    let tracer = opentelemetry_otlp::new_pipeline()
-    //     .pretty()
+        .tracing()
-    //     .with_file(true)
+        .with_exporter(exporter)
-    //     .with_line_number(true)
+        .with_trace_config(opentelemetry::sdk::trace::config().with_resource(
-    //     .with_thread_ids(false)
+            opentelemetry::sdk::Resource::new(vec![opentelemetry::KeyValue::new(
-    //     .with_target(false);
+                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 subscriber = tracing_subscriber::Registry::default();
-    let tracer = opentelemetry_jaeger::new_pipeline()
+    let level_filter_layer = tracing_subscriber::EnvFilter::try_from_default_env()
-        .with_service_name("toy_language")
+        .unwrap_or(tracing_subscriber::EnvFilter::new("WARN"));
-        .install_simple()?;
+    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()
+    subscriber
-        // .with(env_filter)
+        .with(level_filter_layer)
-        .with(opentelemetry)
+        .with(tracing_layer)
-        // .with(stdout)
         .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,17 +1,74 @@
 #![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;
 
-const TEST_DOC: &'static str = include_str!("../toy_language.txt");
+#[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()?;
-    let parsed = document(TEST_DOC);
+    run_compare(
-    println!("{}\n\n\n", TEST_DOC);
+        std::env::args()
-    println!("{:#?}", parsed);
+            .nth(1)
+            .expect("Pass a single file into this script."),
+    )?;
     shutdown_telemetry()?;
     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");
+    let org_sexp =
+        emacs_parse_org_document(todo_org_path.as_ref()).expect("Use emacs to parse org file.");
+    let (_remaining, parsed_sexp) =
+        sexp_with_padding(org_sexp.as_str()).expect("Sexp Parse failure");
+
+    println!("{}\n\n\n", org_contents.as_str());
+    println!("{}", org_sexp);
+    println!("{:#?}", rust_parsed);
+
+    // We do the diffing after printing out both parsed forms in case the diffing panics
+    let diff_result =
+        compare_document(&parsed_sexp, &rust_parsed).expect("Compare parsed documents.");
+    diff_result
+        .print()
+        .expect("Print document parse tree diff.");
+
+    if diff_result.is_bad() {
+        Err("Diff results do not match.")?;
+    }
+    if remaining != "" {
+        Err(format!("There was unparsed text remaining: {}", remaining))?;
+    }
+
+    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)),

toy_language.txt

@@ -1,3 +0,0 @@
-foo bar baz
-
-lorem ipsum