From cd1b4ba785b85d46e05a39a1cc00ea5b15a616d8 Mon Sep 17 00:00:00 2001
From: Tom Alexander <tom@fizz.buzz>
Date: Thu, 10 Aug 2023 20:04:59 -0400
Subject: [PATCH] Make the tracing macros optional.

---
 src/parser/angle_link.rs                |  6 ++--
 src/parser/citation.rs                  | 16 +++++-----
 src/parser/citation_reference.rs        | 14 ++++-----
 src/parser/clock.rs                     |  6 ++--
 src/parser/comment.rs                   |  4 +--
 src/parser/diary_sexp.rs                |  2 +-
 src/parser/document.rs                  | 16 +++++-----
 src/parser/drawer.rs                    |  6 ++--
 src/parser/dynamic_block.rs             |  8 ++---
 src/parser/element.rs                   |  2 +-
 src/parser/element_parser.rs            |  2 +-
 src/parser/entity.rs                    |  6 ++--
 src/parser/export_snippet.rs            |  6 ++--
 src/parser/fixed_width_area.rs          |  4 +--
 src/parser/footnote_definition.rs       |  6 ++--
 src/parser/footnote_reference.rs        | 14 ++++-----
 src/parser/greater_block.rs             |  8 ++---
 src/parser/horizontal_rule.rs           |  2 +-
 src/parser/inline_babel_call.rs         | 16 +++++-----
 src/parser/inline_source_block.rs       | 21 ++++++++-----
 src/parser/keyword.rs                   |  2 +-
 src/parser/latex_environment.rs         | 11 ++++---
 src/parser/latex_fragment.rs            | 26 ++++++++--------
 src/parser/lesser_block.rs              | 14 ++++-----
 src/parser/line_break.rs                |  4 +--
 src/parser/object_parser.rs             |  8 ++---
 src/parser/org_macro.rs                 |  8 ++---
 src/parser/paragraph.rs                 |  4 +--
 src/parser/parser_context.rs            |  2 +-
 src/parser/plain_link.rs                | 12 ++++----
 src/parser/plain_list.rs                | 21 ++++++++-----
 src/parser/plain_text.rs                |  6 ++--
 src/parser/planning.rs                  |  4 +--
 src/parser/property_drawer.rs           | 10 +++----
 src/parser/radio_link.rs                |  8 ++---
 src/parser/regular_link.rs              | 12 ++++----
 src/parser/sexp.rs                      | 14 ++++-----
 src/parser/statistics_cookie.rs         |  6 ++--
 src/parser/subscript_and_superscript.rs | 22 +++++++-------
 src/parser/table.rs                     | 16 +++++-----
 src/parser/target.rs                    |  4 +--
 src/parser/text_markup.rs               | 35 +++++++++++++---------
 src/parser/timestamp.rs                 | 40 ++++++++++++-------------
 src/parser/util.rs                      | 24 +++++++--------
 44 files changed, 250 insertions(+), 228 deletions(-)

diff --git a/src/parser/angle_link.rs b/src/parser/angle_link.rs
index 1a79ebe..5ee81b1 100644
--- a/src/parser/angle_link.rs
+++ b/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)
 }
diff --git a/src/parser/citation.rs b/src/parser/citation.rs
index fa8a5ee..6d7e0a7 100644
--- a/src/parser/citation.rs
+++ b/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.");
diff --git a/src/parser/citation_reference.rs b/src/parser/citation_reference.rs
index 18eba3b..4c3d8fe 100644
--- a/src/parser/citation_reference.rs
+++ b/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.");
diff --git a/src/parser/clock.rs b/src/parser/clock.rs
index 361f114..ea8ce4a 100644
--- a/src/parser/clock.rs
+++ b/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("["),
diff --git a/src/parser/comment.rs b/src/parser/comment.rs
index b5ce097..de75f1e 100644
--- a/src/parser/comment.rs
+++ b/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)?;
diff --git a/src/parser/diary_sexp.rs b/src/parser/diary_sexp.rs
index 87f4e83..9f3b208 100644
--- a/src/parser/diary_sexp.rs
+++ b/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)?;
diff --git a/src/parser/document.rs b/src/parser/document.rs
index 9a08331..0807f3b 100644
--- a/src/parser/document.rs
+++ b/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)
 }
diff --git a/src/parser/drawer.rs b/src/parser/drawer.rs
index 69ebd4a..6f74617 100644
--- a/src/parser/drawer.rs
+++ b/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((
diff --git a/src/parser/dynamic_block.rs b/src/parser/dynamic_block.rs
index d9eac68..dd76b79 100644
--- a/src/parser/dynamic_block.rs
+++ b/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((
diff --git a/src/parser/element.rs b/src/parser/element.rs
index 3052ece..9795ec6 100644
--- a/src/parser/element.rs
+++ b/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,
diff --git a/src/parser/element_parser.rs b/src/parser/element_parser.rs
index 0612a78..11a2b45 100644
--- a/src/parser/element_parser.rs
+++ b/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,
diff --git a/src/parser/entity.rs b/src/parser/entity.rs
index ce39235..6289505 100644
--- a/src/parser/entity.rs
+++ b/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)?;
 
diff --git a/src/parser/export_snippet.rs b/src/parser/export_snippet.rs
index 9e54118..851ba5e 100644
--- a/src/parser/export_snippet.rs
+++ b/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(
diff --git a/src/parser/fixed_width_area.rs b/src/parser/fixed_width_area.rs
index 293aa0d..182dfec 100644
--- a/src/parser/fixed_width_area.rs
+++ b/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,
diff --git a/src/parser/footnote_definition.rs b/src/parser/footnote_definition.rs
index 61318dc..775701f 100644
--- a/src/parser/footnote_definition.rs
+++ b/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,
diff --git a/src/parser/footnote_reference.rs b/src/parser/footnote_reference.rs
index ff2b117..5cb797e 100644
--- a/src/parser/footnote_reference.rs
+++ b/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>> {
diff --git a/src/parser/greater_block.rs b/src/parser/greater_block.rs
index 4adb620..7164e9a 100644
--- a/src/parser/greater_block.rs
+++ b/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(
diff --git a/src/parser/horizontal_rule.rs b/src/parser/horizontal_rule.rs
index 4157629..37fb99d 100644
--- a/src/parser/horizontal_rule.rs
+++ b/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,
diff --git a/src/parser/inline_babel_call.rs b/src/parser/inline_babel_call.rs
index 215f40e..4c412bf 100644
--- a/src/parser/inline_babel_call.rs
+++ b/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() {
diff --git a/src/parser/inline_source_block.rs b/src/parser/inline_source_block.rs
index 777e3fc..1b71faf 100644
--- a/src/parser/inline_source_block.rs
+++ b/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>> {
diff --git a/src/parser/keyword.rs b/src/parser/keyword.rs
index 0581132..d5a33e6 100644
--- a/src/parser/keyword.rs
+++ b/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.
diff --git a/src/parser/latex_environment.rs b/src/parser/latex_environment.rs
index 7b6e653..fc90b18 100644
--- a/src/parser/latex_environment.rs
+++ b/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,
diff --git a/src/parser/latex_fragment.rs b/src/parser/latex_fragment.rs
index f12daaf..71f7b7c 100644
--- a/src/parser/latex_fragment.rs
+++ b/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)
diff --git a/src/parser/lesser_block.rs b/src/parser/lesser_block.rs
index ace7a8b..3b7c68c 100644
--- a/src/parser/lesser_block.rs
+++ b/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)
 }
diff --git a/src/parser/line_break.rs b/src/parser/line_break.rs
index 820187c..635fd6b 100644
--- a/src/parser/line_break.rs
+++ b/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)
diff --git a/src/parser/object_parser.rs b/src/parser/object_parser.rs
index ad77955..3176a60 100644
--- a/src/parser/object_parser.rs
+++ b/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,
diff --git a/src/parser/org_macro.rs b/src/parser/org_macro.rs
index 43335e7..6a14d6e 100644
--- a/src/parser/org_macro.rs
+++ b/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;
diff --git a/src/parser/paragraph.rs b/src/parser/paragraph.rs
index 36ee0d8..4ce08c4 100644
--- a/src/parser/paragraph.rs
+++ b/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);
diff --git a/src/parser/parser_context.rs b/src/parser/parser_context.rs
index e7063e4..f0ff27e 100644
--- a/src/parser/parser_context.rs
+++ b/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,
diff --git a/src/parser/plain_link.rs b/src/parser/plain_link.rs
index b5d97fc..3882219 100644
--- a/src/parser/plain_link.rs
+++ b/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)
 }
diff --git a/src/parser/plain_list.rs b/src/parser/plain_list.rs
index b606d76..c19fc01 100644
--- a/src/parser/plain_list.rs
+++ b/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(
diff --git a/src/parser/plain_text.rs b/src/parser/plain_text.rs
index 497535c..76755fe 100644
--- a/src/parser/plain_text.rs
+++ b/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>,
diff --git a/src/parser/planning.rs b/src/parser/planning.rs
index 7f0b0bf..faea297 100644
--- a/src/parser/planning.rs
+++ b/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"),
diff --git a/src/parser/property_drawer.rs b/src/parser/property_drawer.rs
index ff8edbb..7d63a31 100644
--- a/src/parser/property_drawer.rs
+++ b/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,
diff --git a/src/parser/radio_link.rs b/src/parser/radio_link.rs
index 57fe3f8..c1d4d45 100644
--- a/src/parser/radio_link.rs
+++ b/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)
 }
diff --git a/src/parser/regular_link.rs b/src/parser/regular_link.rs
index 321addd..d5664ab 100644
--- a/src/parser/regular_link.rs
+++ b/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)
 }
diff --git a/src/parser/sexp.rs b/src/parser/sexp.rs
index 8ed62b5..2b06892 100644
--- a/src/parser/sexp.rs
+++ b/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(
diff --git a/src/parser/statistics_cookie.rs b/src/parser/statistics_cookie.rs
index 536fa03..30fdac7 100644
--- a/src/parser/statistics_cookie.rs
+++ b/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,
diff --git a/src/parser/subscript_and_superscript.rs b/src/parser/subscript_and_superscript.rs
index 5ac1df7..05e0455 100644
--- a/src/parser/subscript_and_superscript.rs
+++ b/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>> {
diff --git a/src/parser/table.rs b/src/parser/table.rs
index 9c2025c..286f555 100644
--- a/src/parser/table.rs
+++ b/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,
diff --git a/src/parser/target.rs b/src/parser/target.rs
index 1ed4831..6acd36e 100644
--- a/src/parser/target.rs
+++ b/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)
 }
diff --git a/src/parser/text_markup.rs b/src/parser/text_markup.rs
index 426bbfa..59a5d09 100644
--- a/src/parser/text_markup.rs
+++ b/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(
diff --git a/src/parser/timestamp.rs b/src/parser/timestamp.rs
index 0c2bacf..2680836 100644
--- a/src/parser/timestamp.rs
+++ b/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
diff --git a/src/parser/util.rs b/src/parser/util.rs
index b085946..47a64d4 100644
--- a/src/parser/util.rs
+++ b/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)),