diff --git a/Cargo.lock b/Cargo.lock index 45bce9e..a8dbfbe 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1184,12 +1184,14 @@ dependencies = [ name = "datafusion-tracing" version = "51.0.0" dependencies = [ + "async-trait", "comfy-table", "datafusion", "delegate", "futures", "insta", "pin-project", + "similar", "tokio", "tracing", "tracing-futures", @@ -1812,6 +1814,7 @@ checksum = "8bb03732005da905c88227371639bf1ad885cc712789c011c31c5fb3ab3ccf02" name = "integration-utils" version = "51.0.0" dependencies = [ + "async-trait", "datafusion", "datafusion-tracing", "instrumented-object-store", diff --git a/Cargo.toml b/Cargo.toml index 7ed43f0..7150c5f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -37,6 +37,7 @@ authors = ["DataDog "] rust-version = "1.86.0" [workspace.dependencies] +async-trait = "0.1" datafusion = { version = "51.0.0", default-features = false } datafusion-tracing = { path = "datafusion-tracing", version = "51.0.0" } futures = "0.3" diff --git a/README.md b/README.md index 6bfad71..ab4fb31 100644 --- a/README.md +++ b/README.md @@ -73,7 +73,8 @@ use datafusion::{ prelude::*, }; use datafusion_tracing::{ - instrument_with_info_spans, pretty_format_compact_batch, InstrumentationOptions, + instrument_rules_with_info_spans, instrument_with_info_spans, + pretty_format_compact_batch, InstrumentationOptions, RuleInstrumentationOptions, }; use std::sync::Arc; use tracing::field; @@ -83,8 +84,8 @@ async fn main() -> Result<()> { // Initialize tracing subscriber as usual // (See examples/otlp.rs for a complete example). - // Set up tracing options (you can customize these). - let options = InstrumentationOptions::builder() + // Set up execution plan tracing options (you can customize these). + let exec_options = InstrumentationOptions::builder() .record_metrics(true) .preview_limit(5) .preview_fn(Arc::new(|batch: &RecordBatch| { @@ -95,7 +96,7 @@ async fn main() -> Result<()> { .build(); let instrument_rule = instrument_with_info_spans!( - options: options, + options: exec_options, env = field::Empty, region = field::Empty, ); @@ -105,8 +106,19 @@ async fn main() -> Result<()> { .with_physical_optimizer_rule(instrument_rule) .build(); + // Instrument all rules (analyzer, logical optimizer, physical optimizer) + // Physical plan creation tracing is automatically enabled when physical_optimizer is set + let rule_options = RuleInstrumentationOptions::full().with_plan_diff(); + let session_state = instrument_rules_with_info_spans!( + options: rule_options, + state: session_state + ); + let ctx = SessionContext::new_with_state(session_state); + // Execute a query - the entire lifecycle is now traced: + // SQL Parsing -> Logical Plan -> Analyzer Rules -> Optimizer Rules -> + // Physical Plan Creation -> Physical Optimizer Rules -> Execution let results = ctx.sql("SELECT 1").await?.collect().await?; println!( "Query Results:\n{}", diff --git a/datafusion-tracing/Cargo.toml b/datafusion-tracing/Cargo.toml index 8c8d081..6a85228 100644 --- a/datafusion-tracing/Cargo.toml +++ b/datafusion-tracing/Cargo.toml @@ -33,11 +33,13 @@ documentation = "https://docs.rs/datafusion-tracing" homepage = "https://github.com/datafusion-contrib/datafusion-tracing" [dependencies] +async-trait = { workspace = true } comfy-table = { version = "7.2" } datafusion = { workspace = true } delegate = "0.13" futures = { workspace = true } pin-project = "1.1" +similar = { version = "2.7", default-features = false, features = ["text"] } tracing = { workspace = true } tracing-futures = { workspace = true } unicode-width = "0.2" diff --git a/datafusion-tracing/src/instrumented_macros.rs b/datafusion-tracing/src/exec_instrument_macros.rs similarity index 100% rename from datafusion-tracing/src/instrumented_macros.rs rename to datafusion-tracing/src/exec_instrument_macros.rs diff --git a/datafusion-tracing/src/instrument_rule.rs b/datafusion-tracing/src/exec_instrument_rule.rs similarity index 97% rename from datafusion-tracing/src/instrument_rule.rs rename to datafusion-tracing/src/exec_instrument_rule.rs index 42688a9..8002aea 100644 --- a/datafusion-tracing/src/instrument_rule.rs +++ b/datafusion-tracing/src/exec_instrument_rule.rs @@ -17,8 +17,8 @@ // // This product includes software developed at Datadog (https://www.datadoghq.com/) Copyright 2025 Datadog, Inc. -use crate::instrumented::InstrumentedExec; -use crate::instrumented::SpanCreateFn; +use crate::instrumented_exec::InstrumentedExec; +use crate::instrumented_exec::SpanCreateFn; use crate::options::InstrumentationOptions; use datafusion::common::runtime::{JoinSetTracer, set_join_set_tracer}; use datafusion::common::tree_node::{Transformed, TransformedResult, TreeNode}; diff --git a/datafusion-tracing/src/instrumented.rs b/datafusion-tracing/src/instrumented_exec.rs similarity index 100% rename from datafusion-tracing/src/instrumented.rs rename to datafusion-tracing/src/instrumented_exec.rs diff --git a/datafusion-tracing/src/lib.rs b/datafusion-tracing/src/lib.rs index eb2c20b..9439ff6 100644 --- a/datafusion-tracing/src/lib.rs +++ b/datafusion-tracing/src/lib.rs @@ -63,7 +63,8 @@ //! prelude::*, //! }; //! use datafusion_tracing::{ -//! instrument_with_info_spans, pretty_format_compact_batch, InstrumentationOptions, +//! instrument_rules_with_info_spans, instrument_with_info_spans, +//! pretty_format_compact_batch, InstrumentationOptions, RuleInstrumentationOptions, //! }; //! use std::sync::Arc; //! use tracing::field; @@ -73,8 +74,8 @@ //! // Initialize tracing subscriber as usual //! // (See examples/otlp.rs for a complete example). //! -//! // Set up tracing options (you can customize these). -//! let options = InstrumentationOptions::builder() +//! // Set up execution plan tracing options (you can customize these). +//! let exec_options = InstrumentationOptions::builder() //! .record_metrics(true) //! .preview_limit(5) //! .preview_fn(Arc::new(|batch: &RecordBatch| { @@ -85,7 +86,7 @@ //! .build(); //! //! let instrument_rule = instrument_with_info_spans!( -//! options: options, +//! options: exec_options, //! env = field::Empty, //! region = field::Empty, //! ); @@ -95,8 +96,19 @@ //! .with_physical_optimizer_rule(instrument_rule) //! .build(); //! +//! // Instrument all rules (analyzer, logical optimizer, physical optimizer) +//! // Physical plan creation tracing is automatically enabled when physical_optimizer is set +//! let rule_options = RuleInstrumentationOptions::full().with_plan_diff(); +//! let session_state = instrument_rules_with_info_spans!( +//! options: rule_options, +//! state: session_state +//! ); +//! //! let ctx = SessionContext::new_with_state(session_state); //! +//! // Execute a query - the entire lifecycle is now traced: +//! // SQL Parsing -> Logical Plan -> Analyzer Rules -> Optimizer Rules -> +//! // Physical Plan Creation -> Physical Optimizer Rules -> Execution //! let results = ctx.sql("SELECT 1").await?.collect().await?; //! println!( //! "Query Results:\n{}", @@ -110,21 +122,33 @@ //! A more complete example can be found in the [examples directory](https://github.com/datafusion-contrib/datafusion-tracing/tree/main/examples). //! -mod instrument_rule; -mod instrumented; -mod instrumented_macros; +// Execution plan instrumentation (wraps ExecutionPlan nodes with tracing) +mod exec_instrument_macros; +mod exec_instrument_rule; +mod instrumented_exec; + +// Rule instrumentation (wraps analyzer/optimizer/physical optimizer rules with tracing) +mod rule_instrumentation; +mod rule_instrumentation_macros; + +// Shared utilities mod metrics; mod node; mod options; +mod planner; mod preview; mod preview_utils; +mod rule_options; mod utils; // Hide implementation details from documentation. -// This function is only public because it needs to be accessed by the macros, -// but it's not intended for direct use by consumers of this crate. +// These functions are only public because they need to be accessed by the macros, +// but they're not intended for direct use by consumers of this crate. +#[doc(hidden)] +pub use exec_instrument_rule::new_instrument_rule; #[doc(hidden)] -pub use instrument_rule::new_instrument_rule; +pub use rule_instrumentation::instrument_session_state; pub use options::InstrumentationOptions; pub use preview_utils::pretty_format_compact_batch; +pub use rule_options::RuleInstrumentationOptions; diff --git a/datafusion-tracing/src/options.rs b/datafusion-tracing/src/options.rs index 0481021..525083e 100644 --- a/datafusion-tracing/src/options.rs +++ b/datafusion-tracing/src/options.rs @@ -43,6 +43,24 @@ pub struct InstrumentationOptions { pub custom_fields: HashMap, } +impl std::fmt::Debug for InstrumentationOptions { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("InstrumentationOptions") + .field("record_metrics", &self.record_metrics) + .field("preview_limit", &self.preview_limit) + .field( + "preview_fn", + &if self.preview_fn.is_some() { + "Some(PreviewFn)" + } else { + "None" + }, + ) + .field("custom_fields", &self.custom_fields) + .finish() + } +} + impl InstrumentationOptions { /// Creates a new builder for `InstrumentationOptions`. pub fn builder() -> InstrumentationOptionsBuilder { diff --git a/datafusion-tracing/src/planner.rs b/datafusion-tracing/src/planner.rs new file mode 100644 index 0000000..5e0c0c4 --- /dev/null +++ b/datafusion-tracing/src/planner.rs @@ -0,0 +1,126 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +// +// This product includes software developed at Datadog (https://www.datadoghq.com/) Copyright 2025 Datadog, Inc. + +use async_trait::async_trait; +use datafusion::common::Result; +use datafusion::execution::SessionStateBuilder; +use datafusion::execution::context::{QueryPlanner, SessionState}; +use datafusion::logical_expr::LogicalPlan; +use datafusion::physical_plan::{ExecutionPlan, displayable}; +use std::sync::Arc; +use tracing::{Instrument, Level}; + +/// A `QueryPlanner` that instruments the creation of the physical plan. +/// +/// This is automatically applied when instrumenting a `SessionState` with physical +/// optimizer instrumentation enabled (PhaseOnly or Full). +#[derive(Debug)] +pub(crate) struct TracingQueryPlanner { + inner: Arc, + level: Level, +} + +impl TracingQueryPlanner { + /// Create a new `TracingQueryPlanner` that wraps the provided inner planner at a specific level. + fn new_with_level(inner: Arc, level: Level) -> Self { + Self { inner, level } + } + + /// Wraps the query planner of an existing `SessionState` with tracing instrumentation at a specific level. + /// + /// This preserves any custom `QueryPlanner` that may already be configured in the state, + /// ensuring that tracing is added as a layer on top of existing functionality. + pub(crate) fn instrument_state_with_level( + state: SessionState, + level: Level, + ) -> SessionState { + let current_planner = state.query_planner().clone(); + let wrapped_planner = Arc::new(Self::new_with_level(current_planner, level)); + + SessionStateBuilder::from(state) + .with_query_planner(wrapped_planner) + .build() + } +} + +#[async_trait] +impl QueryPlanner for TracingQueryPlanner { + async fn create_physical_plan( + &self, + logical_plan: &LogicalPlan, + session_state: &SessionState, + ) -> Result> { + let span = match self.level { + Level::TRACE => tracing::trace_span!( + "create_physical_plan", + logical_plan = tracing::field::Empty, + physical_plan = tracing::field::Empty, + error = tracing::field::Empty + ), + Level::DEBUG => tracing::debug_span!( + "create_physical_plan", + logical_plan = tracing::field::Empty, + physical_plan = tracing::field::Empty, + error = tracing::field::Empty + ), + Level::INFO => tracing::info_span!( + "create_physical_plan", + logical_plan = tracing::field::Empty, + physical_plan = tracing::field::Empty, + error = tracing::field::Empty + ), + Level::WARN => tracing::warn_span!( + "create_physical_plan", + logical_plan = tracing::field::Empty, + physical_plan = tracing::field::Empty, + error = tracing::field::Empty + ), + Level::ERROR => tracing::error_span!( + "create_physical_plan", + logical_plan = tracing::field::Empty, + physical_plan = tracing::field::Empty, + error = tracing::field::Empty + ), + }; + + // Record the logical plan as a formatted string with schema + let logical_plan_str = logical_plan.display_indent_schema().to_string(); + span.record("logical_plan", logical_plan_str.as_str()); + + let physical_plan = self + .inner + .create_physical_plan(logical_plan, session_state) + .instrument(span.clone()) + .await; + + match &physical_plan { + Ok(plan) => { + // Record the physical plan as a formatted string + let physical_plan_str = + displayable(plan.as_ref()).indent(true).to_string(); + span.record("physical_plan", physical_plan_str.as_str()); + } + Err(e) => { + span.record("error", e.to_string().as_str()); + } + } + + physical_plan + } +} diff --git a/datafusion-tracing/src/rule_instrumentation.rs b/datafusion-tracing/src/rule_instrumentation.rs new file mode 100644 index 0000000..7e8182d --- /dev/null +++ b/datafusion-tracing/src/rule_instrumentation.rs @@ -0,0 +1,865 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +// +// This product includes software developed at Datadog (https://www.datadoghq.com/) Copyright 2025 Datadog, Inc. + +use crate::planner::TracingQueryPlanner; +use crate::rule_options::RuleInstrumentationOptions; +use datafusion::common::config::ConfigOptions; +use datafusion::common::tree_node::{Transformed, TreeNodeRewriter}; +use datafusion::common::{DataFusionError, Result}; +use datafusion::execution::SessionState; +use datafusion::execution::session_state::SessionStateBuilder; +use datafusion::logical_expr::LogicalPlan; +use datafusion::optimizer::analyzer::AnalyzerRule; +use datafusion::optimizer::optimizer::{ApplyOrder, OptimizerConfig, OptimizerRule}; +use datafusion::physical_optimizer::PhysicalOptimizerRule; +use datafusion::physical_plan::{ExecutionPlan, displayable}; +use similar::{ChangeTag, TextDiff}; +use std::cell::RefCell; +use std::fmt::Debug; +use std::sync::Arc; +use tracing::Level; +use tracing::Span; + +/// Type alias for a function that creates a phase span given the phase name. +/// Example phase names: "analyze_logical_plan", "optimize_logical_plan", "optimize_physical_plan". +pub(crate) type PhaseSpanCreateFn = dyn Fn(&str) -> Span + Send + Sync; + +/// Context for an active phase span, including optional plan capture for diffing. +struct PhaseSpanContext { + /// The entered span guard - keeps the span open until this context is dropped. + _entered: tracing::span::EnteredSpan, + /// The plan state at the start of the phase (for computing diff). + /// Only captured if plan_diff option is enabled. + plan_before: Option, + /// List of rule names that modified the plan during this phase. + effective_rules: Vec, +} + +// Thread-local storage for phase span contexts. +// +// Why thread-local is correct here: +// - DataFusion's analyzer and optimizer loops run synchronously on a single thread. +// Each phase (analyze, optimize, physical optimize) processes all its rules sequentially +// before returning control. +// - Sentinel rules at the start/end of each rule list toggle the phase span: +// first call opens it, second call closes it. +// - The optimizer may run multiple passes, each getting its own phase span. +// OPTIMIZER_PASS_TRACKER tracks which pass we're on, and resets when the parent span +// changes (indicating a new query). +// - Concurrent sessions on different threads each get their own thread-local storage. +// - If sessions somehow share a thread (e.g., sequential queries), the sentinel +// close ensures the previous phase span ends before any new phase begins. +thread_local! { + static ANALYZER_PHASE_SPAN: RefCell> = const { RefCell::new(None) }; + static OPTIMIZER_PHASE_SPAN: RefCell> = const { RefCell::new(None) }; + static PHYSICAL_OPTIMIZER_PHASE_SPAN: RefCell> = const { RefCell::new(None) }; + /// Tracks optimizer pass count and the parent span ID to detect new queries. + static OPTIMIZER_PASS_TRACKER: RefCell = const { RefCell::new(OptimizerPassTracker::new()) }; +} + +/// Tracks the optimizer pass count, resetting when a new query starts. +/// A new query is detected by a change in the parent span ID. +struct OptimizerPassTracker { + parent_span_id: Option, + pass_count: usize, +} + +impl OptimizerPassTracker { + const fn new() -> Self { + Self { + parent_span_id: None, + pass_count: 0, + } + } + + /// Gets the current pass number, resetting if this is a new query (different parent span). + fn get_and_increment( + &mut self, + current_parent_id: Option, + ) -> usize { + if self.parent_span_id != current_parent_id { + // New query detected - reset counter + self.parent_span_id = current_parent_id; + self.pass_count = 0; + } + let pass = self.pass_count; + self.pass_count += 1; + pass + } +} + +/// Records that a rule modified the plan in the current phase. +fn record_modified_rule( + storage: &'static std::thread::LocalKey>>, + rule_name: &str, +) { + storage.with(|cell| { + if let Some(ref mut ctx) = *cell.borrow_mut() { + ctx.effective_rules.push(rule_name.to_string()); + } + }); +} + +// ============================================================================ +// Sentinel rules for opening/closing phase spans (toggle pattern) +// ============================================================================ + +/// Sentinel analyzer rule that toggles the phase span. +/// First call opens the span, second call closes it. +struct AnalyzerPhaseSentinel { + phase_span_create_fn: Arc, + plan_diff: bool, +} + +impl Debug for AnalyzerPhaseSentinel { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("AnalyzerPhaseSentinel").finish() + } +} + +impl AnalyzerRule for AnalyzerPhaseSentinel { + fn analyze(&self, plan: LogicalPlan, _config: &ConfigOptions) -> Result { + ANALYZER_PHASE_SPAN.with(|cell| { + let mut guard = cell.borrow_mut(); + if guard.is_none() { + // Open the phase span + let span = (self.phase_span_create_fn)("analyze_logical_plan"); + let plan_before = if self.plan_diff { + Some(plan.display_indent_schema().to_string()) + } else { + None + }; + *guard = Some(PhaseSpanContext { + _entered: span.entered(), + plan_before, + effective_rules: Vec::new(), + }); + } else { + // Close the phase span - record modified rules and compute diff + if let Some(ctx) = guard.take() { + let current = Span::current(); + if !ctx.effective_rules.is_empty() { + current.record( + "datafusion.effective_rules", + ctx.effective_rules.join(", "), + ); + } + if let Some(before) = &ctx.plan_before { + let after = plan.display_indent_schema().to_string(); + if before != &after { + let diff = generate_plan_diff(before, &after); + current.record("datafusion.plan_diff", diff); + } + } + // ctx._entered drops here, closing the span + } + } + }); + Ok(plan) + } + + fn name(&self) -> &str { + "__tracing_analyzer_phase" + } +} + +/// Sentinel optimizer rule that toggles the phase span. +/// First call opens the span, second call closes it. +struct OptimizerPhaseSentinel { + phase_span_create_fn: Arc, + plan_diff: bool, +} + +impl Debug for OptimizerPhaseSentinel { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("OptimizerPhaseSentinel").finish() + } +} + +impl OptimizerRule for OptimizerPhaseSentinel { + fn name(&self) -> &str { + "__tracing_optimizer_phase" + } + + fn apply_order(&self) -> Option { + None + } + + #[allow(deprecated)] + fn supports_rewrite(&self) -> bool { + true + } + + fn rewrite( + &self, + plan: LogicalPlan, + config: &dyn OptimizerConfig, + ) -> Result, DataFusionError> { + OPTIMIZER_PHASE_SPAN.with(|cell| { + let mut guard = cell.borrow_mut(); + if guard.is_none() { + // Get pass number, resetting if this is a new query (different parent span) + let current_parent_id = Span::current().id(); + let pass = OPTIMIZER_PASS_TRACKER.with(|tracker| { + tracker.borrow_mut().get_and_increment(current_parent_id) + }); + + // Open the phase span + let span = (self.phase_span_create_fn)("optimize_logical_plan"); + + // Record pass information (1-indexed for human readability) + let max_passes = config.options().optimizer.max_passes; + span.record("datafusion.optimizer.pass", pass + 1); + span.record("datafusion.optimizer.max_passes", max_passes as i64); + + let plan_before = if self.plan_diff { + Some(plan.display_indent_schema().to_string()) + } else { + None + }; + *guard = Some(PhaseSpanContext { + _entered: span.entered(), + plan_before, + effective_rules: Vec::new(), + }); + } else { + // Close the phase span - record modified rules and compute diff + if let Some(ctx) = guard.take() { + let current = Span::current(); + if !ctx.effective_rules.is_empty() { + current.record( + "datafusion.effective_rules", + ctx.effective_rules.join(", "), + ); + } + if let Some(before) = &ctx.plan_before { + let after = plan.display_indent_schema().to_string(); + if before != &after { + let diff = generate_plan_diff(before, &after); + current.record("datafusion.plan_diff", diff); + } + } + // ctx._entered drops here, closing the span + } + } + }); + Ok(Transformed::no(plan)) + } +} + +/// Sentinel physical optimizer rule that toggles the phase span. +/// First call opens the span, second call closes it. +struct PhysicalOptimizerPhaseSentinel { + phase_span_create_fn: Arc, + plan_diff: bool, +} + +impl Debug for PhysicalOptimizerPhaseSentinel { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("PhysicalOptimizerPhaseSentinel").finish() + } +} + +impl PhysicalOptimizerRule for PhysicalOptimizerPhaseSentinel { + fn optimize( + &self, + plan: Arc, + _config: &ConfigOptions, + ) -> Result> { + PHYSICAL_OPTIMIZER_PHASE_SPAN.with(|cell| { + let mut guard = cell.borrow_mut(); + if guard.is_none() { + // Open the phase span + let span = (self.phase_span_create_fn)("optimize_physical_plan"); + let plan_before = if self.plan_diff { + Some(displayable(plan.as_ref()).indent(true).to_string()) + } else { + None + }; + *guard = Some(PhaseSpanContext { + _entered: span.entered(), + plan_before, + effective_rules: Vec::new(), + }); + } else { + // Close the phase span - record modified rules and compute diff + if let Some(ctx) = guard.take() { + let current = Span::current(); + if !ctx.effective_rules.is_empty() { + current.record( + "datafusion.effective_rules", + ctx.effective_rules.join(", "), + ); + } + if let Some(before) = &ctx.plan_before { + let after = displayable(plan.as_ref()).indent(true).to_string(); + if before != &after { + let diff = generate_plan_diff(before, &after); + current.record("datafusion.plan_diff", diff); + } + } + // ctx._entered drops here, closing the span + } + } + }); + Ok(plan) + } + + fn name(&self) -> &str { + "__tracing_physical_optimizer_phase" + } + + fn schema_check(&self) -> bool { + true + } +} + +/// A rewriter that applies an optimizer rule to each node in the tree. +/// This is used internally by `InstrumentedOptimizerRule` to manually handle +/// tree traversal when the inner rule specifies an `apply_order`. +struct InnerRuleRewriter<'a> { + apply_order: ApplyOrder, + rule: &'a dyn OptimizerRule, + config: &'a dyn OptimizerConfig, +} + +impl<'a> InnerRuleRewriter<'a> { + fn new( + apply_order: ApplyOrder, + rule: &'a dyn OptimizerRule, + config: &'a dyn OptimizerConfig, + ) -> Self { + Self { + apply_order, + rule, + config, + } + } +} + +impl TreeNodeRewriter for InnerRuleRewriter<'_> { + type Node = LogicalPlan; + + fn f_down(&mut self, node: LogicalPlan) -> Result> { + if self.apply_order == ApplyOrder::TopDown { + self.rule.rewrite(node, self.config) + } else { + Ok(Transformed::no(node)) + } + } + + fn f_up(&mut self, node: LogicalPlan) -> Result> { + if self.apply_order == ApplyOrder::BottomUp { + self.rule.rewrite(node, self.config) + } else { + Ok(Transformed::no(node)) + } + } +} + +/// Generate a unified diff between two plans +fn generate_plan_diff(before: &str, after: &str) -> String { + let diff = TextDiff::from_lines(before, after); + let mut output = String::new(); + + for change in diff.iter_all_changes() { + let sign = match change.tag() { + ChangeTag::Delete => "-", + ChangeTag::Insert => "+", + ChangeTag::Equal => " ", + }; + output.push_str(&format!("{}{}", sign, change)); + } + + output +} + +/// Type for function that creates a span for a rule execution. +/// It takes the rule name as input. +pub(crate) type RuleSpanCreateFn = dyn Fn(&str) -> Span + Send + Sync; + +/// A wrapper for an `AnalyzerRule` that adds tracing instrumentation. +struct InstrumentedAnalyzerRule { + inner: Arc, + options: RuleInstrumentationOptions, + span_create_fn: Arc, +} + +impl Debug for InstrumentedAnalyzerRule { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("InstrumentedAnalyzerRule") + .field("inner", &self.inner) + .field("options", &self.options) + .finish() + } +} + +impl InstrumentedAnalyzerRule { + /// Creates a new instrumented analyzer rule. + fn new( + inner: Arc, + options: RuleInstrumentationOptions, + span_create_fn: Arc, + ) -> Self { + Self { + inner, + options, + span_create_fn, + } + } +} + +impl AnalyzerRule for InstrumentedAnalyzerRule { + fn analyze(&self, plan: LogicalPlan, config: &ConfigOptions) -> Result { + let plan_before = plan.clone(); + + let span = (self.span_create_fn)(self.name()); + let _enter = span.enter(); + + let result = self.inner.analyze(plan, config); + + match &result { + Ok(plan_after) => { + // Check if the plan was modified + let modified = if &plan_before != plan_after { + // Double-check by comparing the string representations + let before_str = plan_before.display_indent_schema().to_string(); + let after_str = plan_after.display_indent_schema().to_string(); + + if before_str != after_str { + if self.options.plan_diff { + let diff = generate_plan_diff(&before_str, &after_str); + span.record("datafusion.plan_diff", diff); + } + true + } else { + false + } + } else { + false + }; + + // Update otel.name to signal modification status and record in phase + if modified { + span.record("otel.name", format!("{} (modified)", self.name())); + record_modified_rule(&ANALYZER_PHASE_SPAN, self.name()); + } + } + Err(e) => { + tracing::error!(error = %e, "AnalyzerRule failed"); + } + } + + result + } + + fn name(&self) -> &str { + self.inner.name() + } +} + +/// A wrapper for an `OptimizerRule` that adds tracing instrumentation. +struct InstrumentedOptimizerRule { + inner: Arc, + options: RuleInstrumentationOptions, + span_create_fn: Arc, +} + +impl Debug for InstrumentedOptimizerRule { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("InstrumentedOptimizerRule") + .field("inner", &self.inner) + .field("options", &self.options) + .finish() + } +} + +impl InstrumentedOptimizerRule { + /// Creates a new instrumented optimizer rule. + fn new( + inner: Arc, + options: RuleInstrumentationOptions, + span_create_fn: Arc, + ) -> Self { + Self { + inner, + options, + span_create_fn, + } + } +} + +impl OptimizerRule for InstrumentedOptimizerRule { + fn name(&self) -> &str { + self.inner.name() + } + + fn apply_order(&self) -> Option { + // Always return None - we handle the tree traversal ourselves. + // This ensures we get a single span per rule application instead of + // one span per node when the optimizer would normally handle recursion. + None + } + + #[allow(deprecated)] + fn supports_rewrite(&self) -> bool { + self.inner.supports_rewrite() + } + + fn rewrite( + &self, + plan: LogicalPlan, + config: &dyn OptimizerConfig, + ) -> Result, DataFusionError> { + let plan_before = if self.options.plan_diff { + Some(plan.display_indent_schema().to_string()) + } else { + None + }; + + // Create a single span for the entire rule application + let span = (self.span_create_fn)(self.name()); + let _enter = span.enter(); + + // Apply the rule - handling tree traversal ourselves if needed + let result = match self.inner.apply_order() { + // Inner rule wants the optimizer to handle recursion. + // We do it ourselves to keep everything under one span. + Some(apply_order) => plan.rewrite_with_subqueries( + &mut InnerRuleRewriter::new(apply_order, self.inner.as_ref(), config), + ), + // Inner rule handles its own recursion + None => self.inner.rewrite(plan, config), + }; + + // Process result and update span + match &result { + Ok(transformed) => { + let modified = if transformed.transformed { + // Double-check by comparing string representations + if let Some(before_str) = &plan_before { + let after_str = + transformed.data.display_indent_schema().to_string(); + if before_str != &after_str { + if self.options.plan_diff { + let diff = generate_plan_diff(before_str, &after_str); + span.record("datafusion.plan_diff", diff); + } + true + } else { + false + } + } else { + true + } + } else { + false + }; + + if modified { + span.record("otel.name", format!("{} (modified)", self.name())); + record_modified_rule(&OPTIMIZER_PHASE_SPAN, self.name()); + } + } + Err(e) => { + tracing::error!(error = %e, "OptimizerRule failed"); + } + } + + result + } +} + +/// A wrapper for a `PhysicalOptimizerRule` that adds tracing instrumentation. +struct InstrumentedPhysicalOptimizerRule { + inner: Arc, + options: RuleInstrumentationOptions, + span_create_fn: Arc, +} + +impl Debug for InstrumentedPhysicalOptimizerRule { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("InstrumentedPhysicalOptimizerRule") + .field("inner", &self.inner) + .field("options", &self.options) + .finish() + } +} + +impl InstrumentedPhysicalOptimizerRule { + /// Creates a new instrumented physical optimizer rule. + fn new( + inner: Arc, + options: RuleInstrumentationOptions, + span_create_fn: Arc, + ) -> Self { + Self { + inner, + options, + span_create_fn, + } + } +} + +impl PhysicalOptimizerRule for InstrumentedPhysicalOptimizerRule { + fn optimize( + &self, + plan: Arc, + config: &ConfigOptions, + ) -> Result> { + self.optimize_inner(plan, config) + } + + fn name(&self) -> &str { + self.inner.name() + } + + fn schema_check(&self) -> bool { + self.inner.schema_check() + } +} + +impl InstrumentedPhysicalOptimizerRule { + fn optimize_inner( + &self, + plan: Arc, + config: &ConfigOptions, + ) -> Result> { + let plan_clone = Arc::clone(&plan); + let plan_before_str = displayable(plan.as_ref()).indent(true).to_string(); + + let span = (self.span_create_fn)(self.name()); + let _enter = span.enter(); + + let result = self.inner.optimize(plan, config); + + match &result { + Ok(new_plan) => { + // Check if the plan was modified (different Arc means new plan was created) + let modified = if !Arc::ptr_eq(&plan_clone, new_plan) { + // Double-check by comparing the string representations + let after_str = + displayable(new_plan.as_ref()).indent(true).to_string(); + + if plan_before_str != after_str { + if self.options.plan_diff { + let diff = generate_plan_diff(&plan_before_str, &after_str); + span.record("datafusion.plan_diff", diff); + } + true + } else { + false + } + } else { + false + }; + + // Update otel.name to signal modification status and record in phase + if modified { + span.record("otel.name", format!("{} (modified)", self.name())); + record_modified_rule(&PHYSICAL_OPTIMIZER_PHASE_SPAN, self.name()); + } + } + Err(e) => { + tracing::error!(error = %e, "PhysicalOptimizerRule failed"); + } + } + + result + } +} + +/// Instruments a `SessionState` with tracing for all rule phases. +/// +/// This is the internal function called by the `instrument_rules_with_*_spans!` macros. +/// It wraps analyzer, optimizer, and physical optimizer rules with tracing spans, +/// and automatically instruments the query planner when physical optimizer is enabled. +#[doc(hidden)] +pub fn instrument_session_state( + state: SessionState, + options: RuleInstrumentationOptions, + span_create_fn: Arc, + phase_span_create_fn: Arc, + span_level: Level, +) -> SessionState { + // Instrument Analyzer rules + let analyzers = instrument_analyzer_rules( + state.analyzer().rules.clone(), + &options, + &span_create_fn, + &phase_span_create_fn, + ); + + // Instrument Optimizer rules + let optimizers = instrument_optimizer_rules( + Vec::from(state.optimizers()), + &options, + &span_create_fn, + &phase_span_create_fn, + ); + + // Instrument Physical Optimizer rules + let physical_optimizers = instrument_physical_optimizer_rules( + Vec::from(state.physical_optimizers()), + &options, + &span_create_fn, + &phase_span_create_fn, + ); + + // Rebuild SessionState with instrumented rules + let state = SessionStateBuilder::from(state) + .with_analyzer_rules(analyzers) + .with_optimizer_rules(optimizers) + .with_physical_optimizer_rules(physical_optimizers) + .build(); + + // Automatically instrument the query planner when physical optimizer is enabled + if options.physical_optimizer.phase_span_enabled() { + TracingQueryPlanner::instrument_state_with_level(state, span_level) + } else { + state + } +} + +/// Instruments analyzer rules with phase sentinel and optional rule-level spans. +fn instrument_analyzer_rules( + rules: Vec>, + options: &RuleInstrumentationOptions, + span_create_fn: &Arc, + phase_span_create_fn: &Arc, +) -> Vec> { + let level = options.analyzer; + if !level.phase_span_enabled() || rules.is_empty() { + return rules; + } + + let mut result = Vec::with_capacity(rules.len() + 2); + + // Sentinel at start opens the phase span + result.push(Arc::new(AnalyzerPhaseSentinel { + phase_span_create_fn: phase_span_create_fn.clone(), + plan_diff: options.plan_diff, + }) as Arc); + + // Wrap rules with instrumentation (if Full) or pass through (if PhaseOnly) + for rule in rules { + if level.rule_spans_enabled() { + result.push(Arc::new(InstrumentedAnalyzerRule::new( + rule, + options.clone(), + span_create_fn.clone(), + )) as Arc); + } else { + result.push(rule); + } + } + + // Sentinel at end closes the phase span + result.push(Arc::new(AnalyzerPhaseSentinel { + phase_span_create_fn: phase_span_create_fn.clone(), + plan_diff: options.plan_diff, + }) as Arc); + + result +} + +/// Instruments optimizer rules with phase sentinel and optional rule-level spans. +fn instrument_optimizer_rules( + rules: Vec>, + options: &RuleInstrumentationOptions, + span_create_fn: &Arc, + phase_span_create_fn: &Arc, +) -> Vec> { + let level = options.optimizer; + if !level.phase_span_enabled() || rules.is_empty() { + return rules; + } + + let mut result = Vec::with_capacity(rules.len() + 2); + + // Sentinel at start opens the phase span + result.push(Arc::new(OptimizerPhaseSentinel { + phase_span_create_fn: phase_span_create_fn.clone(), + plan_diff: options.plan_diff, + }) as Arc); + + // Wrap rules with instrumentation (if Full) or pass through (if PhaseOnly) + for rule in rules { + if level.rule_spans_enabled() { + result.push(Arc::new(InstrumentedOptimizerRule::new( + rule, + options.clone(), + span_create_fn.clone(), + )) as Arc); + } else { + result.push(rule); + } + } + + // Sentinel at end closes the phase span + result.push(Arc::new(OptimizerPhaseSentinel { + phase_span_create_fn: phase_span_create_fn.clone(), + plan_diff: options.plan_diff, + }) as Arc); + + result +} + +/// Instruments physical optimizer rules with phase sentinel and optional rule-level spans. +fn instrument_physical_optimizer_rules( + rules: Vec>, + options: &RuleInstrumentationOptions, + span_create_fn: &Arc, + phase_span_create_fn: &Arc, +) -> Vec> { + let level = options.physical_optimizer; + if !level.phase_span_enabled() || rules.is_empty() { + return rules; + } + + let mut result = Vec::with_capacity(rules.len() + 2); + + // Sentinel at start opens the phase span + result.push(Arc::new(PhysicalOptimizerPhaseSentinel { + phase_span_create_fn: phase_span_create_fn.clone(), + plan_diff: options.plan_diff, + }) as Arc); + + // Wrap rules with instrumentation (if Full) or pass through (if PhaseOnly) + for rule in rules { + if level.rule_spans_enabled() { + result.push(Arc::new(InstrumentedPhysicalOptimizerRule::new( + rule, + options.clone(), + span_create_fn.clone(), + )) + as Arc); + } else { + result.push(rule); + } + } + + // Sentinel at end closes the phase span + result.push(Arc::new(PhysicalOptimizerPhaseSentinel { + phase_span_create_fn: phase_span_create_fn.clone(), + plan_diff: options.plan_diff, + }) as Arc); + + result +} diff --git a/datafusion-tracing/src/rule_instrumentation_macros.rs b/datafusion-tracing/src/rule_instrumentation_macros.rs new file mode 100644 index 0000000..539c21e --- /dev/null +++ b/datafusion-tracing/src/rule_instrumentation_macros.rs @@ -0,0 +1,297 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +// +// This product includes software developed at Datadog (https://www.datadoghq.com/) Copyright 2025 Datadog, Inc. + +/// Instruments a `SessionState` with tracing spans for all rule phases. +/// +/// This macro wraps analyzer, optimizer, and physical optimizer rules with tracing spans +/// at the specified level. Rule spans are grouped under phase spans +/// ("analyze_logical_plan", "optimize_logical_plan", "optimize_physical_plan"). +/// +/// When physical optimizer instrumentation is enabled, the query planner is also +/// automatically instrumented to trace physical plan creation. +/// +/// # Syntax +/// +/// ```ignore +/// instrument_rules_with_spans!( +/// $level, +/// options: $options, +/// state: $session_state, +/// $($fields)* +/// ) +/// ``` +/// +/// # Arguments +/// +/// * `$level` - The tracing level (e.g., `tracing::Level::INFO`) +/// * `options` - A `RuleInstrumentationOptions` instance +/// * `state` - A `SessionState` to instrument +/// * `$fields` - Optional additional span fields +/// +/// # Example +/// +/// ```rust,ignore +/// use datafusion_tracing::{instrument_rules_with_info_spans, RuleInstrumentationOptions}; +/// +/// let options = RuleInstrumentationOptions::full().with_plan_diff(); +/// let session_state = instrument_rules_with_info_spans!( +/// options: options, +/// state: session_state +/// ); +/// ``` +#[macro_export] +macro_rules! instrument_rules_with_spans { + (target: $target:expr, $lvl:expr, options: $options:expr, state: $state:expr, $($fields:tt)*) => {{ + let options = $options; + let span_create_fn = std::sync::Arc::new(move |rule_name: &str| { + tracing::span!( + target: $target, + $lvl, + "Rule", + otel.name = rule_name, + datafusion.plan_diff = tracing::field::Empty, + $($fields)* + ) + }); + let phase_span_create_fn = std::sync::Arc::new(move |phase_name: &str| { + tracing::span!( + target: $target, + $lvl, + "Phase", + otel.name = phase_name, + // Fields recorded by sentinels at phase close + datafusion.effective_rules = tracing::field::Empty, + datafusion.plan_diff = tracing::field::Empty, + // Fields recorded by optimizer phase sentinel (pass tracking) + datafusion.optimizer.pass = tracing::field::Empty, + datafusion.optimizer.max_passes = tracing::field::Empty + ) + }); + $crate::instrument_session_state($state, options, span_create_fn, phase_span_create_fn, $lvl) + }}; + (target: $target:expr, $lvl:expr, options: $options:expr, state: $state:expr) => { + $crate::instrument_rules_with_spans!(target: $target, $lvl, options: $options, state: $state,) + }; + ($lvl:expr, options: $options:expr, state: $state:expr, $($fields:tt)*) => { + $crate::instrument_rules_with_spans!(target: module_path!(), $lvl, options: $options, state: $state, $($fields)*) + }; + ($lvl:expr, options: $options:expr, state: $state:expr) => { + $crate::instrument_rules_with_spans!(target: module_path!(), $lvl, options: $options, state: $state) + }; +} + +/// Instruments a `SessionState` with TRACE-level tracing spans. +/// +/// This is a convenience wrapper around [`instrument_rules_with_spans!`] that automatically +/// sets the tracing level to `TRACE`. +/// +/// See [`instrument_rules_with_spans!`] for detailed documentation. +/// +/// # Example +/// +/// ```rust,ignore +/// use datafusion_tracing::{instrument_rules_with_trace_spans, RuleInstrumentationOptions}; +/// +/// let options = RuleInstrumentationOptions::full(); +/// let session_state = instrument_rules_with_trace_spans!( +/// options: options, +/// state: session_state +/// ); +/// ``` +#[macro_export] +macro_rules! instrument_rules_with_trace_spans { + (target: $target:expr, options: $options:expr, state: $state:expr, $($field:tt)*) => { + $crate::instrument_rules_with_spans!( + target: $target, + tracing::Level::TRACE, + options: $options, + state: $state, + $($field)* + ) + }; + (options: $options:expr, state: $state:expr, $($field:tt)*) => { + $crate::instrument_rules_with_trace_spans!(target: module_path!(), options: $options, state: $state, $($field)*) + }; + (target: $target:expr, options: $options:expr, state: $state:expr) => { + $crate::instrument_rules_with_trace_spans!(target: $target, options: $options, state: $state,) + }; + (options: $options:expr, state: $state:expr) => { + $crate::instrument_rules_with_trace_spans!(target: module_path!(), options: $options, state: $state) + }; +} + +/// Instruments a `SessionState` with DEBUG-level tracing spans. +/// +/// This is a convenience wrapper around [`instrument_rules_with_spans!`] that automatically +/// sets the tracing level to `DEBUG`. +/// +/// See [`instrument_rules_with_spans!`] for detailed documentation. +/// +/// # Example +/// +/// ```rust,ignore +/// use datafusion_tracing::{instrument_rules_with_debug_spans, RuleInstrumentationOptions}; +/// +/// let options = RuleInstrumentationOptions::full(); +/// let session_state = instrument_rules_with_debug_spans!( +/// options: options, +/// state: session_state +/// ); +/// ``` +#[macro_export] +macro_rules! instrument_rules_with_debug_spans { + (target: $target:expr, options: $options:expr, state: $state:expr, $($field:tt)*) => { + $crate::instrument_rules_with_spans!( + target: $target, + tracing::Level::DEBUG, + options: $options, + state: $state, + $($field)* + ) + }; + (options: $options:expr, state: $state:expr, $($field:tt)*) => { + $crate::instrument_rules_with_debug_spans!(target: module_path!(), options: $options, state: $state, $($field)*) + }; + (target: $target:expr, options: $options:expr, state: $state:expr) => { + $crate::instrument_rules_with_debug_spans!(target: $target, options: $options, state: $state,) + }; + (options: $options:expr, state: $state:expr) => { + $crate::instrument_rules_with_debug_spans!(target: module_path!(), options: $options, state: $state) + }; +} + +/// Instruments a `SessionState` with INFO-level tracing spans. +/// +/// This is a convenience wrapper around [`instrument_rules_with_spans!`] that automatically +/// sets the tracing level to `INFO`. +/// +/// See [`instrument_rules_with_spans!`] for detailed documentation. +/// +/// # Example +/// +/// ```rust,ignore +/// use datafusion_tracing::{instrument_rules_with_info_spans, RuleInstrumentationOptions}; +/// +/// let options = RuleInstrumentationOptions::full().with_plan_diff(); +/// let session_state = instrument_rules_with_info_spans!( +/// options: options, +/// state: session_state +/// ); +/// ``` +#[macro_export] +macro_rules! instrument_rules_with_info_spans { + (target: $target:expr, options: $options:expr, state: $state:expr, $($field:tt)*) => { + $crate::instrument_rules_with_spans!( + target: $target, + tracing::Level::INFO, + options: $options, + state: $state, + $($field)* + ) + }; + (options: $options:expr, state: $state:expr, $($field:tt)*) => { + $crate::instrument_rules_with_info_spans!(target: module_path!(), options: $options, state: $state, $($field)*) + }; + (target: $target:expr, options: $options:expr, state: $state:expr) => { + $crate::instrument_rules_with_info_spans!(target: $target, options: $options, state: $state,) + }; + (options: $options:expr, state: $state:expr) => { + $crate::instrument_rules_with_info_spans!(target: module_path!(), options: $options, state: $state) + }; +} + +/// Instruments a `SessionState` with WARN-level tracing spans. +/// +/// This is a convenience wrapper around [`instrument_rules_with_spans!`] that automatically +/// sets the tracing level to `WARN`. +/// +/// See [`instrument_rules_with_spans!`] for detailed documentation. +/// +/// # Example +/// +/// ```rust,ignore +/// use datafusion_tracing::{instrument_rules_with_warn_spans, RuleInstrumentationOptions}; +/// +/// let options = RuleInstrumentationOptions::full(); +/// let session_state = instrument_rules_with_warn_spans!( +/// options: options, +/// state: session_state +/// ); +/// ``` +#[macro_export] +macro_rules! instrument_rules_with_warn_spans { + (target: $target:expr, options: $options:expr, state: $state:expr, $($field:tt)*) => { + $crate::instrument_rules_with_spans!( + target: $target, + tracing::Level::WARN, + options: $options, + state: $state, + $($field)* + ) + }; + (options: $options:expr, state: $state:expr, $($field:tt)*) => { + $crate::instrument_rules_with_warn_spans!(target: module_path!(), options: $options, state: $state, $($field)*) + }; + (target: $target:expr, options: $options:expr, state: $state:expr) => { + $crate::instrument_rules_with_warn_spans!(target: $target, options: $options, state: $state,) + }; + (options: $options:expr, state: $state:expr) => { + $crate::instrument_rules_with_warn_spans!(target: module_path!(), options: $options, state: $state) + }; +} + +/// Instruments a `SessionState` with ERROR-level tracing spans. +/// +/// This is a convenience wrapper around [`instrument_rules_with_spans!`] that automatically +/// sets the tracing level to `ERROR`. +/// +/// See [`instrument_rules_with_spans!`] for detailed documentation. +/// +/// # Example +/// +/// ```rust,ignore +/// use datafusion_tracing::{instrument_rules_with_error_spans, RuleInstrumentationOptions}; +/// +/// let options = RuleInstrumentationOptions::full(); +/// let session_state = instrument_rules_with_error_spans!( +/// options: options, +/// state: session_state +/// ); +/// ``` +#[macro_export] +macro_rules! instrument_rules_with_error_spans { + (target: $target:expr, options: $options:expr, state: $state:expr, $($field:tt)*) => { + $crate::instrument_rules_with_spans!( + target: $target, + tracing::Level::ERROR, + options: $options, + state: $state, + $($field)* + ) + }; + (options: $options:expr, state: $state:expr, $($field:tt)*) => { + $crate::instrument_rules_with_error_spans!(target: module_path!(), options: $options, state: $state, $($field)*) + }; + (target: $target:expr, options: $options:expr, state: $state:expr) => { + $crate::instrument_rules_with_error_spans!(target: $target, options: $options, state: $state,) + }; + (options: $options:expr, state: $state:expr) => { + $crate::instrument_rules_with_error_spans!(target: module_path!(), options: $options, state: $state) + }; +} diff --git a/datafusion-tracing/src/rule_options.rs b/datafusion-tracing/src/rule_options.rs new file mode 100644 index 0000000..d7b88a8 --- /dev/null +++ b/datafusion-tracing/src/rule_options.rs @@ -0,0 +1,201 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. +// +// This product includes software developed at Datadog (https://www.datadoghq.com/) Copyright 2025 Datadog, Inc. + +/// Instrumentation level for a phase (analyzer, optimizer, or physical optimizer). +/// +/// Rule spans always require a parent phase span, so the levels are hierarchical: +/// - `Disabled`: no spans (default) +/// - `PhaseOnly`: only the phase span +/// - `Full`: phase span + individual rule spans +#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)] +pub(crate) enum InstrumentationLevel { + /// No instrumentation for this phase (default). + #[default] + Disabled, + /// Only phase-level span (e.g., "optimize_logical_plan"), no individual rule spans. + /// Useful for reducing trace verbosity while still tracking phase timing. + PhaseOnly, + /// Full instrumentation: phase span + individual rule spans. + Full, +} + +impl InstrumentationLevel { + /// Returns true if the phase span should be created. + pub fn phase_span_enabled(&self) -> bool { + matches!(self, Self::PhaseOnly | Self::Full) + } + + /// Returns true if individual rule spans should be created. + pub fn rule_spans_enabled(&self) -> bool { + matches!(self, Self::Full) + } +} + +/// Configuration options for instrumented DataFusion rules (Analyzer, Optimizer, Physical Optimizer). +#[derive(Clone, Debug)] +pub struct RuleInstrumentationOptions { + /// Whether to include a unified diff of plan changes in the span. + pub(crate) plan_diff: bool, + + /// Instrumentation level for analyzer rules. + pub(crate) analyzer: InstrumentationLevel, + + /// Instrumentation level for logical optimizer rules. + pub(crate) optimizer: InstrumentationLevel, + + /// Instrumentation level for physical optimizer rules. + pub(crate) physical_optimizer: InstrumentationLevel, +} + +impl Default for RuleInstrumentationOptions { + fn default() -> Self { + Self { + plan_diff: false, + analyzer: InstrumentationLevel::Disabled, + optimizer: InstrumentationLevel::Disabled, + physical_optimizer: InstrumentationLevel::Disabled, + } + } +} + +impl RuleInstrumentationOptions { + /// Creates a new builder for `RuleInstrumentationOptions`. + pub fn builder() -> RuleInstrumentationOptionsBuilder { + RuleInstrumentationOptionsBuilder::default() + } + + /// Creates options with all phases enabled at `Full` level. + /// + /// This is a convenience constructor for the common case of enabling + /// full instrumentation for all rule phases. + /// + /// # Example + /// + /// ``` + /// use datafusion_tracing::RuleInstrumentationOptions; + /// + /// let options = RuleInstrumentationOptions::full(); + /// ``` + pub fn full() -> Self { + Self { + plan_diff: false, + analyzer: InstrumentationLevel::Full, + optimizer: InstrumentationLevel::Full, + physical_optimizer: InstrumentationLevel::Full, + } + } + + /// Creates options with all phases enabled at `PhaseOnly` level. + /// + /// This creates phase-level spans without individual rule spans, + /// useful for reducing trace verbosity while still tracking phase timing. + pub fn phase_only() -> Self { + Self { + plan_diff: false, + analyzer: InstrumentationLevel::PhaseOnly, + optimizer: InstrumentationLevel::PhaseOnly, + physical_optimizer: InstrumentationLevel::PhaseOnly, + } + } + + /// Returns a new options with plan diff enabled. + pub fn with_plan_diff(mut self) -> Self { + self.plan_diff = true; + self + } +} + +/// The builder for `RuleInstrumentationOptions`. +#[derive(Default)] +pub struct RuleInstrumentationOptionsBuilder { + plan_diff: bool, + analyzer: InstrumentationLevel, + optimizer: InstrumentationLevel, + physical_optimizer: InstrumentationLevel, +} + +impl RuleInstrumentationOptionsBuilder { + /// Enables plan diff in spans. + pub fn plan_diff(mut self) -> Self { + self.plan_diff = true; + self + } + + /// Enables all phases at `Full` level. + pub fn all(mut self) -> Self { + self.analyzer = InstrumentationLevel::Full; + self.optimizer = InstrumentationLevel::Full; + self.physical_optimizer = InstrumentationLevel::Full; + self + } + + /// Enables all phases at `PhaseOnly` level. + pub fn all_phase_only(mut self) -> Self { + self.analyzer = InstrumentationLevel::PhaseOnly; + self.optimizer = InstrumentationLevel::PhaseOnly; + self.physical_optimizer = InstrumentationLevel::PhaseOnly; + self + } + + /// Enables analyzer instrumentation at `Full` level. + pub fn analyzer(mut self) -> Self { + self.analyzer = InstrumentationLevel::Full; + self + } + + /// Enables analyzer instrumentation at `PhaseOnly` level. + pub fn analyzer_phase_only(mut self) -> Self { + self.analyzer = InstrumentationLevel::PhaseOnly; + self + } + + /// Enables logical optimizer instrumentation at `Full` level. + pub fn optimizer(mut self) -> Self { + self.optimizer = InstrumentationLevel::Full; + self + } + + /// Enables logical optimizer instrumentation at `PhaseOnly` level. + pub fn optimizer_phase_only(mut self) -> Self { + self.optimizer = InstrumentationLevel::PhaseOnly; + self + } + + /// Enables physical optimizer instrumentation at `Full` level. + pub fn physical_optimizer(mut self) -> Self { + self.physical_optimizer = InstrumentationLevel::Full; + self + } + + /// Enables physical optimizer instrumentation at `PhaseOnly` level. + pub fn physical_optimizer_phase_only(mut self) -> Self { + self.physical_optimizer = InstrumentationLevel::PhaseOnly; + self + } + + /// Consumes the builder and creates a `RuleInstrumentationOptions` instance. + pub fn build(self) -> RuleInstrumentationOptions { + RuleInstrumentationOptions { + plan_diff: self.plan_diff, + analyzer: self.analyzer, + optimizer: self.optimizer, + physical_optimizer: self.physical_optimizer, + } + } +} diff --git a/examples/otlp.rs b/examples/otlp.rs index 4b7e3b1..e7d80c6 100644 --- a/examples/otlp.rs +++ b/examples/otlp.rs @@ -53,7 +53,7 @@ use std::time::Duration; use datafusion::{common::internal_datafusion_err, error::Result}; -use integration_utils::{init_session, run_traced_query}; +use integration_utils::{SessionBuilder, run_traced_query}; use opentelemetry::{KeyValue, trace::TracerProvider}; use opentelemetry_otlp::WithExportConfig; use opentelemetry_sdk::{Resource, trace::Sampler}; @@ -80,7 +80,14 @@ async fn main() -> Result<()> { #[instrument(level = "info")] async fn run_otlp_example() -> Result<()> { // Initialize the DataFusion session context. - let ctx = init_session(true, true, 5, true).await?; + let ctx = SessionBuilder::new() + .record_object_store() + .record_metrics() + .preview_limit(5) + .compact_preview() + .plan_diff() + .build() + .await?; // Run the SQL query with tracing enabled. run_traced_query(&ctx, QUERY_NAME).await?; diff --git a/integration-utils/Cargo.toml b/integration-utils/Cargo.toml index 484219b..d6f3203 100644 --- a/integration-utils/Cargo.toml +++ b/integration-utils/Cargo.toml @@ -31,6 +31,7 @@ rust-version = { workspace = true } workspace = true [dependencies] +async-trait = { workspace = true } datafusion = { workspace = true, features = ["nested_expressions", "parquet", "sql"] } datafusion-tracing = { workspace = true } instrumented-object-store = { workspace = true } diff --git a/integration-utils/src/lib.rs b/integration-utils/src/lib.rs index 3666c05..6fafc75 100644 --- a/integration-utils/src/lib.rs +++ b/integration-utils/src/lib.rs @@ -36,11 +36,17 @@ //! //! ```rust //! use datafusion::prelude::*; -//! use integration_utils::{init_session, run_traced_query}; +//! use integration_utils::{SessionBuilder, run_traced_query}; //! //! # async fn example() -> datafusion::error::Result<()> { -//! // Initialize a session with all tracing options enabled -//! let ctx = init_session(true, true, 5, true).await?; +//! // Initialize a session with tracing options via builder +//! let ctx = SessionBuilder::new() +//! .record_object_store() +//! .record_metrics() +//! .preview_limit(5) +//! .compact_preview() +//! .build() +//! .await?; //! //! // Run a traced query - results and execution details will be logged //! run_traced_query(&ctx, "simple_query").await?; @@ -56,13 +62,14 @@ use datafusion::arrow::util::pretty::pretty_format_batches; use datafusion::common::internal_datafusion_err; use datafusion::datasource::file_format::parquet::ParquetFormat; use datafusion::datasource::listing::ListingOptions; -use datafusion::physical_plan::{ExecutionPlan, collect, displayable}; +use datafusion::physical_plan::collect; use datafusion::{ error::Result, execution::SessionStateBuilder, physical_optimizer::PhysicalOptimizerRule, prelude::*, }; use datafusion_tracing::{ - InstrumentationOptions, instrument_with_info_spans, pretty_format_compact_batch, + InstrumentationOptions, RuleInstrumentationOptions, instrument_rules_with_info_spans, + instrument_with_info_spans, pretty_format_compact_batch, }; use instrumented_object_store::instrument_object_store; use tracing::{field, info, instrument}; @@ -75,11 +82,13 @@ pub async fn run_traced_query(ctx: &SessionContext, query_name: &str) -> Result< let query = read_query(query_name)?; - // Parse the SQL query into a DataFusion dataframe. + // Parse SQL and create logical plan. let df = parse_sql(ctx, query.as_str()).await?; // Generate a physical execution plan from the logical plan. - let physical_plan = create_physical_plan(df).await?; + // All phases are instrumented by instrument_rules_with_info_spans!: + // analyzer, logical optimizer, physical plan creation, and physical optimizer. + let physical_plan = df.create_physical_plan().await?; // Execute the physical plan and collect results. let results = collect(physical_plan.clone(), ctx.task_ctx()).await?; @@ -89,41 +98,104 @@ pub async fn run_traced_query(ctx: &SessionContext, query_name: &str) -> Result< Ok(()) } -#[instrument(level = "info")] -pub async fn init_session( +/// Builder for creating a test [`SessionContext`] with tracing instrumentation. +#[derive(Debug, Default, Clone)] +pub struct SessionBuilder { record_object_store: bool, record_metrics: bool, preview_limit: usize, compact_preview: bool, -) -> Result { - // Configure the session state with instrumentation for query execution. - let session_state = SessionStateBuilder::new() - .with_default_features() - .with_config(SessionConfig::default().with_target_partitions(8)) // Enforce target partitions to ensure consistent test results regardless of the number of CPU cores. - .with_physical_optimizer_rule(create_instrumentation_rule( - record_metrics, - preview_limit, - compact_preview, - )) - .build(); - - let ctx = SessionContext::new_with_state(session_state); - - // Instrument the local filesystem object store for tracing file access. - let local_store = Arc::new(object_store::local::LocalFileSystem::new()); - let object_store = if record_object_store { - instrument_object_store(local_store, "local_fs") - } else { - local_store - }; + plan_diff: bool, +} + +impl SessionBuilder { + /// Returns the configured preview limit. + pub fn get_preview_limit(&self) -> usize { + self.preview_limit + } +} + +impl SessionBuilder { + /// Creates a new session builder with default settings. + pub fn new() -> Self { + Self::default() + } - // Register the instrumented object store for handling file:// URLs. - ctx.register_object_store(&Url::parse("file://").unwrap(), object_store); + /// Enables object store instrumentation for tracing file access. + pub fn record_object_store(mut self) -> Self { + self.record_object_store = true; + self + } - // Register the tpch tables. - register_tpch_tables(&ctx).await?; + /// Enables recording execution metrics in spans. + pub fn record_metrics(mut self) -> Self { + self.record_metrics = true; + self + } - Ok(ctx) + /// Sets the maximum number of rows to preview in span fields. + pub fn preview_limit(mut self, value: usize) -> Self { + self.preview_limit = value; + self + } + + /// Enables compact preview formatting. + pub fn compact_preview(mut self) -> Self { + self.compact_preview = true; + self + } + + /// Enables unified diffs of plan changes in rule spans. + pub fn plan_diff(mut self) -> Self { + self.plan_diff = true; + self + } + + /// Builds and returns the configured [`SessionContext`]. + #[instrument(level = "info", skip(self))] + pub async fn build(self) -> Result { + // Configure the session state with instrumentation for query execution. + let session_state = SessionStateBuilder::new() + .with_default_features() + .with_config(SessionConfig::default().with_target_partitions(8)) // Enforce target partitions to ensure consistent test results regardless of the number of CPU cores. + .with_physical_optimizer_rule(create_instrumentation_rule( + self.record_metrics, + self.preview_limit, + self.compact_preview, + )) + .build(); + + // Instrument all rules (analyzer, logical optimizer, physical optimizer) + // Rules are grouped under phase spans (analyze_logical_plan, optimize_logical_plan, optimize_physical_plan) + // Physical plan creation tracing is automatically enabled when physical_optimizer is set + let rule_options = if self.plan_diff { + RuleInstrumentationOptions::full().with_plan_diff() + } else { + RuleInstrumentationOptions::full() + }; + let session_state = instrument_rules_with_info_spans!( + options: rule_options, + state: session_state + ); + + let ctx = SessionContext::new_with_state(session_state); + + // Instrument the local filesystem object store for tracing file access. + let local_store = Arc::new(object_store::local::LocalFileSystem::new()); + let object_store = if self.record_object_store { + instrument_object_store(local_store, "local_fs") + } else { + local_store + }; + + // Register the instrumented object store for handling file:// URLs. + ctx.register_object_store(&Url::parse("file://").unwrap(), object_store); + + // Register the tpch tables. + register_tpch_tables(&ctx).await?; + + Ok(ctx) + } } /// Creates an instrumentation rule that captures metrics and provides previews of data during execution. @@ -220,16 +292,3 @@ pub async fn parse_sql(ctx: &SessionContext, sql: &str) -> Result { Ok(df) } - -#[instrument(level = "info", skip(df), fields(physical_plan))] -pub async fn create_physical_plan(df: DataFrame) -> Result> { - // Create a physical plan from the DataFrame. - let physical_plan = df.create_physical_plan().await?; - - // Record the physical plan as part of the current span. - let physical_plan_str = displayable(physical_plan.as_ref()).indent(true).to_string(); - tracing::Span::current().record("physical_plan", physical_plan_str.as_str()); - info!("Physical Plan:\n{}", physical_plan_str); - - Ok(physical_plan) -} diff --git a/tests/integration_tests.rs b/tests/integration_tests.rs index b0191f0..45d491f 100644 --- a/tests/integration_tests.rs +++ b/tests/integration_tests.rs @@ -23,7 +23,7 @@ use std::sync::{Arc, Mutex, Once, OnceLock}; use datafusion::error::Result; use insta::{assert_json_snapshot, assert_snapshot}; -use integration_utils::{init_session, run_traced_query}; +use integration_utils::{SessionBuilder, run_traced_query}; use serde_json::Value; use tracing::{Instrument, Level}; use tracing_subscriber::fmt::format::FmtSpan; @@ -44,14 +44,8 @@ static SUBSCRIBER_INIT: Once = Once::new(); struct QueryTestCase<'a> { /// The SQL query to run. sql_query: &'a str, - /// Whether to instrument the object store for this test. - record_object_store: bool, - /// Whether to collect (record) metrics for this test. - should_record_metrics: bool, - /// Maximum number of rows to preview in logs. - row_limit: usize, - /// Use compact formatting for the row preview. - use_compact_preview: bool, + /// Session configuration (metrics, preview, object store, etc.) + session: SessionBuilder, /// Indices of spans for which preview assertions should be skipped. ignored_preview_spans: &'a [usize], /// Whether to ignore the full trace in assertions. @@ -66,26 +60,30 @@ impl<'a> QueryTestCase<'a> { } } + // --- Passthrough methods delegating to SessionBuilder --- + fn with_object_store_collection(mut self) -> Self { - self.record_object_store = true; + self.session = self.session.record_object_store(); self } fn with_metrics_collection(mut self) -> Self { - self.should_record_metrics = true; + self.session = self.session.record_metrics(); self } fn with_row_limit(mut self, limit: usize) -> Self { - self.row_limit = limit; + self.session = self.session.preview_limit(limit); self } fn with_compact_preview(mut self) -> Self { - self.use_compact_preview = true; + self.session = self.session.compact_preview(); self } + // --- Test-specific methods --- + fn ignore_preview_spans(mut self, spans: &'a [usize]) -> Self { self.ignored_preview_spans = spans; self @@ -203,13 +201,8 @@ async fn execute_test_case(test_name: &str, test_case: &QueryTestCase<'_>) -> Re let log_buffer = init_tracing(); // Initialize the DataFusion session with the requested options. - let ctx = init_session( - test_case.record_object_store, - test_case.should_record_metrics, - test_case.row_limit, - test_case.use_compact_preview, - ) - .await?; + // plan_diff disabled for tests to avoid non-deterministic output + let ctx = test_case.session.clone().build().await?; // Run the SQL query with tracing enabled. run_traced_query(&ctx, test_case.sql_query) @@ -231,7 +224,7 @@ async fn execute_test_case(test_name: &str, test_case: &QueryTestCase<'_>) -> Re let _insta_guard = insta_settings::settings().bind_to_scope(); // If we have a preview row_limit, do dedicated assertions on the previews. - if test_case.row_limit > 0 { + if test_case.session.get_preview_limit() > 0 { let mut preview_id = 0; for json_line in &json_lines { if let Some(span_name) = extract_json_field_value(json_line, "otel.name") { diff --git a/tests/snapshots/01_basic_trace.snap b/tests/snapshots/01_basic_trace.snap index 1b3a573..1a95d33 100644 --- a/tests/snapshots/01_basic_trace.snap +++ b/tests/snapshots/01_basic_trace.snap @@ -50,6 +50,1331 @@ expression: json_lines "level": "INFO", "message": "close", "span": { + "name": "Rule", + "otel.name": "resolve_grouping_function" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "name": "Phase", + "otel.name": "analyze_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "type_coercion" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "name": "Phase", + "otel.name": "analyze_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Phase", + "otel.name": "analyze_logical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_nested_union" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "simplify_expressions" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "replace_distinct_aggregate" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_join" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "decorrelate_predicate_subquery" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "scalar_subquery_to_join" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "decorrelate_lateral_join" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "extract_equijoin_predicate" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_duplicated_expr" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_filter" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_cross_join" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_limit" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "propagate_empty_relation" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_one_union" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "filter_null_join_keys" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_outer_join" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "push_down_limit" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "push_down_filter" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "single_distinct_aggregation_to_group_by" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_group_by_constant" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "common_sub_expression_eliminate" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "optimize_projections (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "datafusion.effective_rules": "optimize_projections", + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "OutputRequirements (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "aggregate_statistics" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "join_selection" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitedDistinctAggregation" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "FilterPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "EnforceDistribution" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "CombinePartialFinalAggregate" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "EnforceSorting" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "OptimizeAggregateOrder" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "ProjectionPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "coalesce_batches" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "coalesce_async_exec_input" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "OutputRequirements (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitAggregation" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitPushPastWindows" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "ProjectionPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "EnsureCooperative" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "FilterPushdown(Post)" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "SanityCheckPlan" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "Instrument" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "datafusion.effective_rules": "OutputRequirements, OutputRequirements", + "name": "Phase", + "otel.name": "optimize_physical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "01_basic" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", "name": "create_physical_plan", "physical_plan": "ProjectionExec: expr=[1 as Int64(1)]\n PlaceholderRowExec\n" }, @@ -63,7 +1388,7 @@ expression: json_lines "query_name": "select_one" } ], - "target": "integration_utils", + "target": "datafusion_tracing::planner", "time.busy": "0.00ms", "time.idle": "0.00ms" }, diff --git a/tests/snapshots/02_basic_metrics_trace.snap b/tests/snapshots/02_basic_metrics_trace.snap index a809c95..24331c3 100644 --- a/tests/snapshots/02_basic_metrics_trace.snap +++ b/tests/snapshots/02_basic_metrics_trace.snap @@ -50,6 +50,1331 @@ expression: json_lines "level": "INFO", "message": "close", "span": { + "name": "Rule", + "otel.name": "resolve_grouping_function" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "name": "Phase", + "otel.name": "analyze_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "type_coercion" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "name": "Phase", + "otel.name": "analyze_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Phase", + "otel.name": "analyze_logical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_nested_union" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "simplify_expressions" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "replace_distinct_aggregate" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_join" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "decorrelate_predicate_subquery" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "scalar_subquery_to_join" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "decorrelate_lateral_join" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "extract_equijoin_predicate" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_duplicated_expr" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_filter" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_cross_join" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_limit" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "propagate_empty_relation" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_one_union" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "filter_null_join_keys" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_outer_join" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "push_down_limit" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "push_down_filter" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "single_distinct_aggregation_to_group_by" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_group_by_constant" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "common_sub_expression_eliminate" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "optimize_projections (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "datafusion.effective_rules": "optimize_projections", + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "OutputRequirements (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "aggregate_statistics" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "join_selection" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitedDistinctAggregation" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "FilterPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "EnforceDistribution" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "CombinePartialFinalAggregate" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "EnforceSorting" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "OptimizeAggregateOrder" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "ProjectionPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "coalesce_batches" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "coalesce_async_exec_input" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "OutputRequirements (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitAggregation" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitPushPastWindows" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "ProjectionPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "EnsureCooperative" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "FilterPushdown(Post)" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "SanityCheckPlan" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "Instrument" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "datafusion.effective_rules": "OutputRequirements, OutputRequirements", + "name": "Phase", + "otel.name": "optimize_physical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "02_basic_metrics" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", "name": "create_physical_plan", "physical_plan": "ProjectionExec: expr=[1 as Int64(1)]\n PlaceholderRowExec\n" }, @@ -63,7 +1388,7 @@ expression: json_lines "query_name": "select_one" } ], - "target": "integration_utils", + "target": "datafusion_tracing::planner", "time.busy": "0.00ms", "time.idle": "0.00ms" }, diff --git a/tests/snapshots/03_basic_preview_trace.snap b/tests/snapshots/03_basic_preview_trace.snap index 311caef..ce13363 100644 --- a/tests/snapshots/03_basic_preview_trace.snap +++ b/tests/snapshots/03_basic_preview_trace.snap @@ -50,6 +50,1331 @@ expression: json_lines "level": "INFO", "message": "close", "span": { + "name": "Rule", + "otel.name": "resolve_grouping_function" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "name": "Phase", + "otel.name": "analyze_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "type_coercion" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "name": "Phase", + "otel.name": "analyze_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Phase", + "otel.name": "analyze_logical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_nested_union" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "simplify_expressions" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "replace_distinct_aggregate" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_join" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "decorrelate_predicate_subquery" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "scalar_subquery_to_join" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "decorrelate_lateral_join" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "extract_equijoin_predicate" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_duplicated_expr" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_filter" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_cross_join" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_limit" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "propagate_empty_relation" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_one_union" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "filter_null_join_keys" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_outer_join" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "push_down_limit" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "push_down_filter" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "single_distinct_aggregation_to_group_by" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_group_by_constant" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "common_sub_expression_eliminate" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "optimize_projections (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "datafusion.effective_rules": "optimize_projections", + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "OutputRequirements (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "aggregate_statistics" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "join_selection" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitedDistinctAggregation" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "FilterPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "EnforceDistribution" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "CombinePartialFinalAggregate" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "EnforceSorting" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "OptimizeAggregateOrder" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "ProjectionPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "coalesce_batches" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "coalesce_async_exec_input" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "OutputRequirements (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitAggregation" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitPushPastWindows" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "ProjectionPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "EnsureCooperative" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "FilterPushdown(Post)" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "SanityCheckPlan" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "Instrument" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "datafusion.effective_rules": "OutputRequirements, OutputRequirements", + "name": "Phase", + "otel.name": "optimize_physical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "03_basic_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", "name": "create_physical_plan", "physical_plan": "ProjectionExec: expr=[1 as Int64(1)]\n PlaceholderRowExec\n" }, @@ -63,7 +1388,7 @@ expression: json_lines "query_name": "select_one" } ], - "target": "integration_utils", + "target": "datafusion_tracing::planner", "time.busy": "0.00ms", "time.idle": "0.00ms" }, diff --git a/tests/snapshots/04_basic_compact_preview_trace.snap b/tests/snapshots/04_basic_compact_preview_trace.snap index f1501cc..813d0b7 100644 --- a/tests/snapshots/04_basic_compact_preview_trace.snap +++ b/tests/snapshots/04_basic_compact_preview_trace.snap @@ -50,6 +50,1331 @@ expression: json_lines "level": "INFO", "message": "close", "span": { + "name": "Rule", + "otel.name": "resolve_grouping_function" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "name": "Phase", + "otel.name": "analyze_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "type_coercion" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "name": "Phase", + "otel.name": "analyze_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Phase", + "otel.name": "analyze_logical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_nested_union" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "simplify_expressions" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "replace_distinct_aggregate" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_join" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "decorrelate_predicate_subquery" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "scalar_subquery_to_join" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "decorrelate_lateral_join" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "extract_equijoin_predicate" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_duplicated_expr" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_filter" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_cross_join" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_limit" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "propagate_empty_relation" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_one_union" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "filter_null_join_keys" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_outer_join" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "push_down_limit" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "push_down_filter" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "single_distinct_aggregation_to_group_by" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_group_by_constant" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "common_sub_expression_eliminate" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "optimize_projections (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "datafusion.effective_rules": "optimize_projections", + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "OutputRequirements (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "aggregate_statistics" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "join_selection" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitedDistinctAggregation" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "FilterPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "EnforceDistribution" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "CombinePartialFinalAggregate" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "EnforceSorting" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "OptimizeAggregateOrder" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "ProjectionPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "coalesce_batches" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "coalesce_async_exec_input" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "OutputRequirements (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitAggregation" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitPushPastWindows" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "ProjectionPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "EnsureCooperative" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "FilterPushdown(Post)" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "SanityCheckPlan" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "Instrument" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "datafusion.effective_rules": "OutputRequirements, OutputRequirements", + "name": "Phase", + "otel.name": "optimize_physical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "04_basic_compact_preview" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", "name": "create_physical_plan", "physical_plan": "ProjectionExec: expr=[1 as Int64(1)]\n PlaceholderRowExec\n" }, @@ -63,7 +1388,7 @@ expression: json_lines "query_name": "select_one" } ], - "target": "integration_utils", + "target": "datafusion_tracing::planner", "time.busy": "0.00ms", "time.idle": "0.00ms" }, diff --git a/tests/snapshots/05_basic_all_options_trace.snap b/tests/snapshots/05_basic_all_options_trace.snap index 133397d..be7990a 100644 --- a/tests/snapshots/05_basic_all_options_trace.snap +++ b/tests/snapshots/05_basic_all_options_trace.snap @@ -50,6 +50,1331 @@ expression: json_lines "level": "INFO", "message": "close", "span": { + "name": "Rule", + "otel.name": "resolve_grouping_function" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "name": "Phase", + "otel.name": "analyze_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "type_coercion" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "name": "Phase", + "otel.name": "analyze_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Phase", + "otel.name": "analyze_logical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_nested_union" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "simplify_expressions" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "replace_distinct_aggregate" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_join" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "decorrelate_predicate_subquery" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "scalar_subquery_to_join" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "decorrelate_lateral_join" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "extract_equijoin_predicate" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_duplicated_expr" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_filter" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_cross_join" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_limit" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "propagate_empty_relation" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_one_union" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "filter_null_join_keys" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_outer_join" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "push_down_limit" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "push_down_filter" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "single_distinct_aggregation_to_group_by" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_group_by_constant" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "common_sub_expression_eliminate" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "optimize_projections (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "datafusion.effective_rules": "optimize_projections", + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "OutputRequirements (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "aggregate_statistics" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "join_selection" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitedDistinctAggregation" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "FilterPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "EnforceDistribution" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "CombinePartialFinalAggregate" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "EnforceSorting" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "OptimizeAggregateOrder" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "ProjectionPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "coalesce_batches" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "coalesce_async_exec_input" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "OutputRequirements (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitAggregation" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitPushPastWindows" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "ProjectionPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "EnsureCooperative" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "FilterPushdown(Post)" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "SanityCheckPlan" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "Instrument" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "datafusion.effective_rules": "OutputRequirements, OutputRequirements", + "name": "Phase", + "otel.name": "optimize_physical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "05_basic_all_options" + }, + { + "name": "run_traced_query", + "query_name": "select_one" + }, + { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", + "name": "create_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "logical_plan": "Projection: Int64(1) [Int64(1):Int64]\n EmptyRelation: rows=1 []", "name": "create_physical_plan", "physical_plan": "ProjectionExec: expr=[1 as Int64(1)]\n PlaceholderRowExec\n" }, @@ -63,7 +1388,7 @@ expression: json_lines "query_name": "select_one" } ], - "target": "integration_utils", + "target": "datafusion_tracing::planner", "time.busy": "0.00ms", "time.idle": "0.00ms" }, diff --git a/tests/snapshots/06_object_store_all_options_trace.snap b/tests/snapshots/06_object_store_all_options_trace.snap index b07676b..a6c56e7 100644 --- a/tests/snapshots/06_object_store_all_options_trace.snap +++ b/tests/snapshots/06_object_store_all_options_trace.snap @@ -46,6 +46,1313 @@ expression: json_lines "time.busy": "0.00ms", "time.idle": "0.00ms" }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "resolve_grouping_function" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "name": "Phase", + "otel.name": "analyze_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "type_coercion" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "name": "Phase", + "otel.name": "analyze_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Phase", + "otel.name": "analyze_logical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_nested_union" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "simplify_expressions" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "replace_distinct_aggregate" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_join" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "decorrelate_predicate_subquery" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "scalar_subquery_to_join" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "decorrelate_lateral_join" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "extract_equijoin_predicate" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_duplicated_expr" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_filter" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_cross_join" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_limit" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "propagate_empty_relation" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_one_union" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "filter_null_join_keys" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_outer_join" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "push_down_limit" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "push_down_filter" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "single_distinct_aggregation_to_group_by" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_group_by_constant" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "common_sub_expression_eliminate" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "optimize_projections (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "datafusion.effective_rules": "optimize_projections", + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_nested_union" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "simplify_expressions" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "replace_distinct_aggregate" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_join" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "decorrelate_predicate_subquery" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "scalar_subquery_to_join" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "decorrelate_lateral_join" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "extract_equijoin_predicate" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_duplicated_expr" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_filter" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_cross_join" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_limit" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "propagate_empty_relation" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_one_union" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "filter_null_join_keys" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_outer_join" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "push_down_limit" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "push_down_filter" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "single_distinct_aggregation_to_group_by" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_group_by_constant" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "common_sub_expression_eliminate" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "optimize_projections (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "datafusion.effective_rules": "optimize_projections", + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, { "level": "INFO", "message": "close", @@ -65,10 +1372,646 @@ expression: json_lines "query_name": "order_nations" }, { + "logical_plan": "Sort: nation.n_name ASC NULLS LAST [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]\n TableScan: nation projection=[n_nationkey, n_name, n_regionkey, n_comment] [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]", + "name": "create_physical_plan" + } + ], + "target": "instrumented_object_store::instrumented_object_store", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "OutputRequirements (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "logical_plan": "Sort: nation.n_name ASC NULLS LAST [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]\n TableScan: nation projection=[n_nationkey, n_name, n_regionkey, n_comment] [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "aggregate_statistics" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "logical_plan": "Sort: nation.n_name ASC NULLS LAST [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]\n TableScan: nation projection=[n_nationkey, n_name, n_regionkey, n_comment] [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "join_selection" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "logical_plan": "Sort: nation.n_name ASC NULLS LAST [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]\n TableScan: nation projection=[n_nationkey, n_name, n_regionkey, n_comment] [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitedDistinctAggregation" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "logical_plan": "Sort: nation.n_name ASC NULLS LAST [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]\n TableScan: nation projection=[n_nationkey, n_name, n_regionkey, n_comment] [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "FilterPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "logical_plan": "Sort: nation.n_name ASC NULLS LAST [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]\n TableScan: nation projection=[n_nationkey, n_name, n_regionkey, n_comment] [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "EnforceDistribution" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "logical_plan": "Sort: nation.n_name ASC NULLS LAST [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]\n TableScan: nation projection=[n_nationkey, n_name, n_regionkey, n_comment] [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "CombinePartialFinalAggregate" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "logical_plan": "Sort: nation.n_name ASC NULLS LAST [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]\n TableScan: nation projection=[n_nationkey, n_name, n_regionkey, n_comment] [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "EnforceSorting" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "logical_plan": "Sort: nation.n_name ASC NULLS LAST [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]\n TableScan: nation projection=[n_nationkey, n_name, n_regionkey, n_comment] [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "OptimizeAggregateOrder" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "logical_plan": "Sort: nation.n_name ASC NULLS LAST [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]\n TableScan: nation projection=[n_nationkey, n_name, n_regionkey, n_comment] [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "ProjectionPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "logical_plan": "Sort: nation.n_name ASC NULLS LAST [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]\n TableScan: nation projection=[n_nationkey, n_name, n_regionkey, n_comment] [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "coalesce_batches" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "logical_plan": "Sort: nation.n_name ASC NULLS LAST [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]\n TableScan: nation projection=[n_nationkey, n_name, n_regionkey, n_comment] [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "coalesce_async_exec_input" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "logical_plan": "Sort: nation.n_name ASC NULLS LAST [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]\n TableScan: nation projection=[n_nationkey, n_name, n_regionkey, n_comment] [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]", "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" } ], - "target": "instrumented_object_store::instrumented_object_store", + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "OutputRequirements (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "logical_plan": "Sort: nation.n_name ASC NULLS LAST [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]\n TableScan: nation projection=[n_nationkey, n_name, n_regionkey, n_comment] [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitAggregation" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "logical_plan": "Sort: nation.n_name ASC NULLS LAST [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]\n TableScan: nation projection=[n_nationkey, n_name, n_regionkey, n_comment] [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitPushPastWindows" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "logical_plan": "Sort: nation.n_name ASC NULLS LAST [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]\n TableScan: nation projection=[n_nationkey, n_name, n_regionkey, n_comment] [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "logical_plan": "Sort: nation.n_name ASC NULLS LAST [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]\n TableScan: nation projection=[n_nationkey, n_name, n_regionkey, n_comment] [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "ProjectionPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "logical_plan": "Sort: nation.n_name ASC NULLS LAST [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]\n TableScan: nation projection=[n_nationkey, n_name, n_regionkey, n_comment] [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "EnsureCooperative" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "logical_plan": "Sort: nation.n_name ASC NULLS LAST [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]\n TableScan: nation projection=[n_nationkey, n_name, n_regionkey, n_comment] [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "FilterPushdown(Post)" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "logical_plan": "Sort: nation.n_name ASC NULLS LAST [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]\n TableScan: nation projection=[n_nationkey, n_name, n_regionkey, n_comment] [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "SanityCheckPlan" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "logical_plan": "Sort: nation.n_name ASC NULLS LAST [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]\n TableScan: nation projection=[n_nationkey, n_name, n_regionkey, n_comment] [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "Instrument" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "logical_plan": "Sort: nation.n_name ASC NULLS LAST [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]\n TableScan: nation projection=[n_nationkey, n_name, n_regionkey, n_comment] [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "datafusion.effective_rules": "OutputRequirements, OutputRequirements", + "name": "Phase", + "otel.name": "optimize_physical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "06_object_store_all_options" + }, + { + "name": "run_traced_query", + "query_name": "order_nations" + }, + { + "logical_plan": "Sort: nation.n_name ASC NULLS LAST [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]\n TableScan: nation projection=[n_nationkey, n_name, n_regionkey, n_comment] [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]", + "name": "create_physical_plan" + } + ], + "target": "integration_utils", "time.busy": "0.00ms", "time.idle": "0.00ms" }, @@ -76,6 +2019,7 @@ expression: json_lines "level": "INFO", "message": "close", "span": { + "logical_plan": "Sort: nation.n_name ASC NULLS LAST [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]\n TableScan: nation projection=[n_nationkey, n_name, n_regionkey, n_comment] [n_nationkey:Int64, n_name:Utf8View, n_regionkey:Int64, n_comment:Utf8View]", "name": "create_physical_plan", "physical_plan": "SortExec: expr=[n_name@1 ASC NULLS LAST], preserve_partitioning=[false]\n DataSourceExec: file_groups={1 group: [[/nation.parquet]]}, projection=[n_nationkey, n_name, n_regionkey, n_comment], file_type=parquet\n" }, @@ -89,7 +2033,7 @@ expression: json_lines "query_name": "order_nations" } ], - "target": "integration_utils", + "target": "datafusion_tracing::planner", "time.busy": "0.00ms", "time.idle": "0.00ms" }, diff --git a/tests/snapshots/08_recursive_trace.snap b/tests/snapshots/08_recursive_trace.snap index 8f578bb..5dd126f 100644 --- a/tests/snapshots/08_recursive_trace.snap +++ b/tests/snapshots/08_recursive_trace.snap @@ -50,6 +50,1949 @@ expression: json_lines "level": "INFO", "message": "close", "span": { + "name": "Rule", + "otel.name": "resolve_grouping_function" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "name": "Phase", + "otel.name": "analyze_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "type_coercion" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "name": "Phase", + "otel.name": "analyze_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Phase", + "otel.name": "analyze_logical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_nested_union" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "simplify_expressions (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "replace_distinct_aggregate" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_join" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "decorrelate_predicate_subquery" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "scalar_subquery_to_join" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "decorrelate_lateral_join" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "extract_equijoin_predicate" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_duplicated_expr" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_filter" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_cross_join" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_limit" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "propagate_empty_relation" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_one_union" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "filter_null_join_keys" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_outer_join" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "push_down_limit" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "push_down_filter (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "single_distinct_aggregation_to_group_by" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_group_by_constant" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "common_sub_expression_eliminate" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "optimize_projections (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "datafusion.effective_rules": "simplify_expressions, push_down_filter, optimize_projections", + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_nested_union" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "simplify_expressions (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "replace_distinct_aggregate" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_join" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "decorrelate_predicate_subquery" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "scalar_subquery_to_join" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "decorrelate_lateral_join" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "extract_equijoin_predicate" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_duplicated_expr" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_filter" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_cross_join" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_limit" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "propagate_empty_relation" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_one_union" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "filter_null_join_keys" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_outer_join" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "push_down_limit" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "push_down_filter (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "single_distinct_aggregation_to_group_by" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_group_by_constant" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "common_sub_expression_eliminate" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "optimize_projections (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "datafusion.effective_rules": "simplify_expressions, push_down_filter, optimize_projections", + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "OutputRequirements (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "aggregate_statistics" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "join_selection" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitedDistinctAggregation" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "FilterPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "EnforceDistribution (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "CombinePartialFinalAggregate" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "EnforceSorting" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "OptimizeAggregateOrder" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "ProjectionPushdown (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "coalesce_batches (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "coalesce_async_exec_input" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "OutputRequirements (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitAggregation" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitPushPastWindows" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "ProjectionPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "EnsureCooperative" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "FilterPushdown(Post)" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "SanityCheckPlan" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "Instrument" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "datafusion.effective_rules": "OutputRequirements, EnforceDistribution, ProjectionPushdown, coalesce_batches, OutputRequirements", + "name": "Phase", + "otel.name": "optimize_physical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "08_recursive" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", "name": "create_physical_plan", "physical_plan": "RecursiveQueryExec: name=numbers, is_distinct=false\n ProjectionExec: expr=[1 as n]\n PlaceholderRowExec\n CoalescePartitionsExec\n ProjectionExec: expr=[n@0 + 1 as numbers.n + Int64(1)]\n CoalesceBatchesExec: target_batch_size=8192\n FilterExec: n@0 < 3\n RepartitionExec: partitioning=RoundRobinBatch(8), input_partitions=1\n WorkTableExec: name=numbers\n" }, @@ -63,7 +2006,7 @@ expression: json_lines "query_name": "recursive" } ], - "target": "integration_utils", + "target": "datafusion_tracing::planner", "time.busy": "0.00ms", "time.idle": "0.00ms" }, diff --git a/tests/snapshots/09_recursive_all_options_trace.snap b/tests/snapshots/09_recursive_all_options_trace.snap index c1af16b..0418554 100644 --- a/tests/snapshots/09_recursive_all_options_trace.snap +++ b/tests/snapshots/09_recursive_all_options_trace.snap @@ -50,6 +50,1949 @@ expression: json_lines "level": "INFO", "message": "close", "span": { + "name": "Rule", + "otel.name": "resolve_grouping_function" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "name": "Phase", + "otel.name": "analyze_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "type_coercion" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "name": "Phase", + "otel.name": "analyze_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Phase", + "otel.name": "analyze_logical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_nested_union" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "simplify_expressions (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "replace_distinct_aggregate" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_join" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "decorrelate_predicate_subquery" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "scalar_subquery_to_join" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "decorrelate_lateral_join" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "extract_equijoin_predicate" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_duplicated_expr" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_filter" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_cross_join" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_limit" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "propagate_empty_relation" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_one_union" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "filter_null_join_keys" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_outer_join" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "push_down_limit" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "push_down_filter (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "single_distinct_aggregation_to_group_by" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_group_by_constant" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "common_sub_expression_eliminate" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "optimize_projections (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "datafusion.effective_rules": "simplify_expressions, push_down_filter, optimize_projections", + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_nested_union" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "simplify_expressions (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "replace_distinct_aggregate" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_join" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "decorrelate_predicate_subquery" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "scalar_subquery_to_join" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "decorrelate_lateral_join" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "extract_equijoin_predicate" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_duplicated_expr" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_filter" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_cross_join" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_limit" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "propagate_empty_relation" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_one_union" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "filter_null_join_keys" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_outer_join" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "push_down_limit" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "push_down_filter (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "single_distinct_aggregation_to_group_by" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_group_by_constant" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "common_sub_expression_eliminate" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "optimize_projections (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "datafusion.effective_rules": "simplify_expressions, push_down_filter, optimize_projections", + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "OutputRequirements (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "aggregate_statistics" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "join_selection" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitedDistinctAggregation" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "FilterPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "EnforceDistribution (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "CombinePartialFinalAggregate" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "EnforceSorting" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "OptimizeAggregateOrder" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "ProjectionPushdown (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "coalesce_batches (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "coalesce_async_exec_input" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "OutputRequirements (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitAggregation" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitPushPastWindows" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "ProjectionPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "EnsureCooperative" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "FilterPushdown(Post)" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "SanityCheckPlan" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "Instrument" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "datafusion.effective_rules": "OutputRequirements, EnforceDistribution, ProjectionPushdown, coalesce_batches, OutputRequirements", + "name": "Phase", + "otel.name": "optimize_physical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "09_recursive_all_options" + }, + { + "name": "run_traced_query", + "query_name": "recursive" + }, + { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", + "name": "create_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "logical_plan": "SubqueryAlias: numbers [n:Int64]\n Projection: n AS n [n:Int64]\n RecursiveQuery: is_distinct=false [n:Int64]\n Projection: Int64(1) AS n [n:Int64]\n EmptyRelation: rows=1 []\n Projection: numbers.n + Int64(1) [numbers.n + Int64(1):Int64]\n Filter: numbers.n < Int64(3) [n:Int64]\n TableScan: numbers projection=[n] [n:Int64]", "name": "create_physical_plan", "physical_plan": "RecursiveQueryExec: name=numbers, is_distinct=false\n ProjectionExec: expr=[1 as n]\n PlaceholderRowExec\n CoalescePartitionsExec\n ProjectionExec: expr=[n@0 + 1 as numbers.n + Int64(1)]\n CoalesceBatchesExec: target_batch_size=8192\n FilterExec: n@0 < 3\n RepartitionExec: partitioning=RoundRobinBatch(8), input_partitions=1\n WorkTableExec: name=numbers\n" }, @@ -63,7 +2006,7 @@ expression: json_lines "query_name": "recursive" } ], - "target": "integration_utils", + "target": "datafusion_tracing::planner", "time.busy": "0.00ms", "time.idle": "0.00ms" }, diff --git a/tests/snapshots/10_topk_lineitem_trace.snap b/tests/snapshots/10_topk_lineitem_trace.snap index 39a93f1..37bc515 100644 --- a/tests/snapshots/10_topk_lineitem_trace.snap +++ b/tests/snapshots/10_topk_lineitem_trace.snap @@ -50,6 +50,2568 @@ expression: json_lines "level": "INFO", "message": "close", "span": { + "name": "Rule", + "otel.name": "resolve_grouping_function" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "name": "Phase", + "otel.name": "analyze_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "type_coercion (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "name": "Phase", + "otel.name": "analyze_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "datafusion.effective_rules": "type_coercion", + "name": "Phase", + "otel.name": "analyze_logical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_nested_union" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "simplify_expressions (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "replace_distinct_aggregate" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_join" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "decorrelate_predicate_subquery" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "scalar_subquery_to_join" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "decorrelate_lateral_join" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "extract_equijoin_predicate" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_duplicated_expr" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_filter" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_cross_join" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_limit" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "propagate_empty_relation" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_one_union" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "filter_null_join_keys" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_outer_join" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "push_down_limit (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "push_down_filter (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "single_distinct_aggregation_to_group_by" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_group_by_constant" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "common_sub_expression_eliminate" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "optimize_projections (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "datafusion.effective_rules": "simplify_expressions, push_down_limit, push_down_filter, optimize_projections", + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 1, + "name": "Phase", + "otel.name": "optimize_logical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_nested_union" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "simplify_expressions" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "replace_distinct_aggregate" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_join" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "decorrelate_predicate_subquery" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "scalar_subquery_to_join" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "decorrelate_lateral_join" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "extract_equijoin_predicate" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_duplicated_expr" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_filter" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_cross_join" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_limit" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "propagate_empty_relation" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_one_union" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "filter_null_join_keys" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_outer_join" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "push_down_limit (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "push_down_filter (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "single_distinct_aggregation_to_group_by" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_group_by_constant" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "common_sub_expression_eliminate" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "optimize_projections (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "datafusion.effective_rules": "push_down_limit, push_down_filter, optimize_projections", + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 2, + "name": "Phase", + "otel.name": "optimize_logical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_nested_union" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 3, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "simplify_expressions" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 3, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "replace_distinct_aggregate" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 3, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_join" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 3, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "decorrelate_predicate_subquery" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 3, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "scalar_subquery_to_join" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 3, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "decorrelate_lateral_join" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 3, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "extract_equijoin_predicate" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 3, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_duplicated_expr" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 3, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_filter" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 3, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_cross_join" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 3, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_limit" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 3, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "propagate_empty_relation" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 3, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_one_union" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 3, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "filter_null_join_keys" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 3, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_outer_join" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 3, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "push_down_limit" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 3, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "push_down_filter (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 3, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "single_distinct_aggregation_to_group_by" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 3, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "eliminate_group_by_constant" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 3, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "common_sub_expression_eliminate" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 3, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "optimize_projections (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 3, + "name": "Phase", + "otel.name": "optimize_logical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "datafusion.effective_rules": "push_down_filter, optimize_projections", + "datafusion.optimizer.max_passes": 3, + "datafusion.optimizer.pass": 3, + "name": "Phase", + "otel.name": "optimize_logical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "OutputRequirements (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "logical_plan": "Sort: lineitem.l_orderkey ASC NULLS LAST, lineitem.l_linenumber ASC NULLS LAST, fetch=3 [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Projection: lineitem.l_orderkey, lineitem.l_linenumber, lineitem.l_shipmode, lineitem.l_quantity [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Filter: lineitem.l_shipmode = Utf8View(\"SHIP\") [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]\n TableScan: lineitem projection=[l_orderkey, l_linenumber, l_quantity, l_shipmode], partial_filters=[lineitem.l_shipmode = Utf8View(\"SHIP\")] [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "aggregate_statistics" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "logical_plan": "Sort: lineitem.l_orderkey ASC NULLS LAST, lineitem.l_linenumber ASC NULLS LAST, fetch=3 [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Projection: lineitem.l_orderkey, lineitem.l_linenumber, lineitem.l_shipmode, lineitem.l_quantity [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Filter: lineitem.l_shipmode = Utf8View(\"SHIP\") [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]\n TableScan: lineitem projection=[l_orderkey, l_linenumber, l_quantity, l_shipmode], partial_filters=[lineitem.l_shipmode = Utf8View(\"SHIP\")] [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "join_selection" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "logical_plan": "Sort: lineitem.l_orderkey ASC NULLS LAST, lineitem.l_linenumber ASC NULLS LAST, fetch=3 [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Projection: lineitem.l_orderkey, lineitem.l_linenumber, lineitem.l_shipmode, lineitem.l_quantity [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Filter: lineitem.l_shipmode = Utf8View(\"SHIP\") [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]\n TableScan: lineitem projection=[l_orderkey, l_linenumber, l_quantity, l_shipmode], partial_filters=[lineitem.l_shipmode = Utf8View(\"SHIP\")] [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitedDistinctAggregation" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "logical_plan": "Sort: lineitem.l_orderkey ASC NULLS LAST, lineitem.l_linenumber ASC NULLS LAST, fetch=3 [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Projection: lineitem.l_orderkey, lineitem.l_linenumber, lineitem.l_shipmode, lineitem.l_quantity [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Filter: lineitem.l_shipmode = Utf8View(\"SHIP\") [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]\n TableScan: lineitem projection=[l_orderkey, l_linenumber, l_quantity, l_shipmode], partial_filters=[lineitem.l_shipmode = Utf8View(\"SHIP\")] [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "FilterPushdown (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "logical_plan": "Sort: lineitem.l_orderkey ASC NULLS LAST, lineitem.l_linenumber ASC NULLS LAST, fetch=3 [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Projection: lineitem.l_orderkey, lineitem.l_linenumber, lineitem.l_shipmode, lineitem.l_quantity [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Filter: lineitem.l_shipmode = Utf8View(\"SHIP\") [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]\n TableScan: lineitem projection=[l_orderkey, l_linenumber, l_quantity, l_shipmode], partial_filters=[lineitem.l_shipmode = Utf8View(\"SHIP\")] [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "EnforceDistribution (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "logical_plan": "Sort: lineitem.l_orderkey ASC NULLS LAST, lineitem.l_linenumber ASC NULLS LAST, fetch=3 [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Projection: lineitem.l_orderkey, lineitem.l_linenumber, lineitem.l_shipmode, lineitem.l_quantity [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Filter: lineitem.l_shipmode = Utf8View(\"SHIP\") [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]\n TableScan: lineitem projection=[l_orderkey, l_linenumber, l_quantity, l_shipmode], partial_filters=[lineitem.l_shipmode = Utf8View(\"SHIP\")] [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "CombinePartialFinalAggregate" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "logical_plan": "Sort: lineitem.l_orderkey ASC NULLS LAST, lineitem.l_linenumber ASC NULLS LAST, fetch=3 [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Projection: lineitem.l_orderkey, lineitem.l_linenumber, lineitem.l_shipmode, lineitem.l_quantity [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Filter: lineitem.l_shipmode = Utf8View(\"SHIP\") [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]\n TableScan: lineitem projection=[l_orderkey, l_linenumber, l_quantity, l_shipmode], partial_filters=[lineitem.l_shipmode = Utf8View(\"SHIP\")] [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "EnforceSorting (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "logical_plan": "Sort: lineitem.l_orderkey ASC NULLS LAST, lineitem.l_linenumber ASC NULLS LAST, fetch=3 [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Projection: lineitem.l_orderkey, lineitem.l_linenumber, lineitem.l_shipmode, lineitem.l_quantity [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Filter: lineitem.l_shipmode = Utf8View(\"SHIP\") [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]\n TableScan: lineitem projection=[l_orderkey, l_linenumber, l_quantity, l_shipmode], partial_filters=[lineitem.l_shipmode = Utf8View(\"SHIP\")] [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "OptimizeAggregateOrder" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "logical_plan": "Sort: lineitem.l_orderkey ASC NULLS LAST, lineitem.l_linenumber ASC NULLS LAST, fetch=3 [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Projection: lineitem.l_orderkey, lineitem.l_linenumber, lineitem.l_shipmode, lineitem.l_quantity [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Filter: lineitem.l_shipmode = Utf8View(\"SHIP\") [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]\n TableScan: lineitem projection=[l_orderkey, l_linenumber, l_quantity, l_shipmode], partial_filters=[lineitem.l_shipmode = Utf8View(\"SHIP\")] [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "ProjectionPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "logical_plan": "Sort: lineitem.l_orderkey ASC NULLS LAST, lineitem.l_linenumber ASC NULLS LAST, fetch=3 [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Projection: lineitem.l_orderkey, lineitem.l_linenumber, lineitem.l_shipmode, lineitem.l_quantity [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Filter: lineitem.l_shipmode = Utf8View(\"SHIP\") [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]\n TableScan: lineitem projection=[l_orderkey, l_linenumber, l_quantity, l_shipmode], partial_filters=[lineitem.l_shipmode = Utf8View(\"SHIP\")] [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "coalesce_batches (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "logical_plan": "Sort: lineitem.l_orderkey ASC NULLS LAST, lineitem.l_linenumber ASC NULLS LAST, fetch=3 [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Projection: lineitem.l_orderkey, lineitem.l_linenumber, lineitem.l_shipmode, lineitem.l_quantity [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Filter: lineitem.l_shipmode = Utf8View(\"SHIP\") [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]\n TableScan: lineitem projection=[l_orderkey, l_linenumber, l_quantity, l_shipmode], partial_filters=[lineitem.l_shipmode = Utf8View(\"SHIP\")] [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "coalesce_async_exec_input" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "logical_plan": "Sort: lineitem.l_orderkey ASC NULLS LAST, lineitem.l_linenumber ASC NULLS LAST, fetch=3 [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Projection: lineitem.l_orderkey, lineitem.l_linenumber, lineitem.l_shipmode, lineitem.l_quantity [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Filter: lineitem.l_shipmode = Utf8View(\"SHIP\") [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]\n TableScan: lineitem projection=[l_orderkey, l_linenumber, l_quantity, l_shipmode], partial_filters=[lineitem.l_shipmode = Utf8View(\"SHIP\")] [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "OutputRequirements (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "logical_plan": "Sort: lineitem.l_orderkey ASC NULLS LAST, lineitem.l_linenumber ASC NULLS LAST, fetch=3 [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Projection: lineitem.l_orderkey, lineitem.l_linenumber, lineitem.l_shipmode, lineitem.l_quantity [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Filter: lineitem.l_shipmode = Utf8View(\"SHIP\") [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]\n TableScan: lineitem projection=[l_orderkey, l_linenumber, l_quantity, l_shipmode], partial_filters=[lineitem.l_shipmode = Utf8View(\"SHIP\")] [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitAggregation" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "logical_plan": "Sort: lineitem.l_orderkey ASC NULLS LAST, lineitem.l_linenumber ASC NULLS LAST, fetch=3 [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Projection: lineitem.l_orderkey, lineitem.l_linenumber, lineitem.l_shipmode, lineitem.l_quantity [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Filter: lineitem.l_shipmode = Utf8View(\"SHIP\") [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]\n TableScan: lineitem projection=[l_orderkey, l_linenumber, l_quantity, l_shipmode], partial_filters=[lineitem.l_shipmode = Utf8View(\"SHIP\")] [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitPushPastWindows" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "logical_plan": "Sort: lineitem.l_orderkey ASC NULLS LAST, lineitem.l_linenumber ASC NULLS LAST, fetch=3 [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Projection: lineitem.l_orderkey, lineitem.l_linenumber, lineitem.l_shipmode, lineitem.l_quantity [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Filter: lineitem.l_shipmode = Utf8View(\"SHIP\") [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]\n TableScan: lineitem projection=[l_orderkey, l_linenumber, l_quantity, l_shipmode], partial_filters=[lineitem.l_shipmode = Utf8View(\"SHIP\")] [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "LimitPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "logical_plan": "Sort: lineitem.l_orderkey ASC NULLS LAST, lineitem.l_linenumber ASC NULLS LAST, fetch=3 [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Projection: lineitem.l_orderkey, lineitem.l_linenumber, lineitem.l_shipmode, lineitem.l_quantity [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Filter: lineitem.l_shipmode = Utf8View(\"SHIP\") [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]\n TableScan: lineitem projection=[l_orderkey, l_linenumber, l_quantity, l_shipmode], partial_filters=[lineitem.l_shipmode = Utf8View(\"SHIP\")] [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "ProjectionPushdown" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "logical_plan": "Sort: lineitem.l_orderkey ASC NULLS LAST, lineitem.l_linenumber ASC NULLS LAST, fetch=3 [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Projection: lineitem.l_orderkey, lineitem.l_linenumber, lineitem.l_shipmode, lineitem.l_quantity [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Filter: lineitem.l_shipmode = Utf8View(\"SHIP\") [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]\n TableScan: lineitem projection=[l_orderkey, l_linenumber, l_quantity, l_shipmode], partial_filters=[lineitem.l_shipmode = Utf8View(\"SHIP\")] [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "EnsureCooperative" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "logical_plan": "Sort: lineitem.l_orderkey ASC NULLS LAST, lineitem.l_linenumber ASC NULLS LAST, fetch=3 [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Projection: lineitem.l_orderkey, lineitem.l_linenumber, lineitem.l_shipmode, lineitem.l_quantity [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Filter: lineitem.l_shipmode = Utf8View(\"SHIP\") [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]\n TableScan: lineitem projection=[l_orderkey, l_linenumber, l_quantity, l_shipmode], partial_filters=[lineitem.l_shipmode = Utf8View(\"SHIP\")] [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "FilterPushdown(Post) (modified)" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "logical_plan": "Sort: lineitem.l_orderkey ASC NULLS LAST, lineitem.l_linenumber ASC NULLS LAST, fetch=3 [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Projection: lineitem.l_orderkey, lineitem.l_linenumber, lineitem.l_shipmode, lineitem.l_quantity [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Filter: lineitem.l_shipmode = Utf8View(\"SHIP\") [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]\n TableScan: lineitem projection=[l_orderkey, l_linenumber, l_quantity, l_shipmode], partial_filters=[lineitem.l_shipmode = Utf8View(\"SHIP\")] [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "SanityCheckPlan" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "logical_plan": "Sort: lineitem.l_orderkey ASC NULLS LAST, lineitem.l_linenumber ASC NULLS LAST, fetch=3 [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Projection: lineitem.l_orderkey, lineitem.l_linenumber, lineitem.l_shipmode, lineitem.l_quantity [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Filter: lineitem.l_shipmode = Utf8View(\"SHIP\") [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]\n TableScan: lineitem projection=[l_orderkey, l_linenumber, l_quantity, l_shipmode], partial_filters=[lineitem.l_shipmode = Utf8View(\"SHIP\")] [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "name": "Rule", + "otel.name": "Instrument" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "logical_plan": "Sort: lineitem.l_orderkey ASC NULLS LAST, lineitem.l_linenumber ASC NULLS LAST, fetch=3 [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Projection: lineitem.l_orderkey, lineitem.l_linenumber, lineitem.l_shipmode, lineitem.l_quantity [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Filter: lineitem.l_shipmode = Utf8View(\"SHIP\") [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]\n TableScan: lineitem projection=[l_orderkey, l_linenumber, l_quantity, l_shipmode], partial_filters=[lineitem.l_shipmode = Utf8View(\"SHIP\")] [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]", + "name": "create_physical_plan" + }, + { + "name": "Phase", + "otel.name": "optimize_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "datafusion.effective_rules": "OutputRequirements, FilterPushdown, EnforceDistribution, EnforceSorting, coalesce_batches, OutputRequirements, FilterPushdown(Post)", + "name": "Phase", + "otel.name": "optimize_physical_plan" + }, + "spans": [ + { + "name": "test", + "test_name": "10_topk_lineitem" + }, + { + "name": "run_traced_query", + "query_name": "topk_lineitem" + }, + { + "logical_plan": "Sort: lineitem.l_orderkey ASC NULLS LAST, lineitem.l_linenumber ASC NULLS LAST, fetch=3 [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Projection: lineitem.l_orderkey, lineitem.l_linenumber, lineitem.l_shipmode, lineitem.l_quantity [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Filter: lineitem.l_shipmode = Utf8View(\"SHIP\") [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]\n TableScan: lineitem projection=[l_orderkey, l_linenumber, l_quantity, l_shipmode], partial_filters=[lineitem.l_shipmode = Utf8View(\"SHIP\")] [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]", + "name": "create_physical_plan" + } + ], + "target": "integration_utils", + "time.busy": "0.00ms", + "time.idle": "0.00ms" + }, + { + "level": "INFO", + "message": "close", + "span": { + "logical_plan": "Sort: lineitem.l_orderkey ASC NULLS LAST, lineitem.l_linenumber ASC NULLS LAST, fetch=3 [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Projection: lineitem.l_orderkey, lineitem.l_linenumber, lineitem.l_shipmode, lineitem.l_quantity [l_orderkey:Int64, l_linenumber:Int32, l_shipmode:Utf8View, l_quantity:Decimal128(15, 2)]\n Filter: lineitem.l_shipmode = Utf8View(\"SHIP\") [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]\n TableScan: lineitem projection=[l_orderkey, l_linenumber, l_quantity, l_shipmode], partial_filters=[lineitem.l_shipmode = Utf8View(\"SHIP\")] [l_orderkey:Int64, l_linenumber:Int32, l_quantity:Decimal128(15, 2), l_shipmode:Utf8View]", "name": "create_physical_plan", "physical_plan": "SortPreservingMergeExec: [l_orderkey@0 ASC NULLS LAST, l_linenumber@1 ASC NULLS LAST], fetch=3\n SortExec: TopK(fetch=3), expr=[l_orderkey@0 ASC NULLS LAST, l_linenumber@1 ASC NULLS LAST], preserve_partitioning=[true]\n ProjectionExec: expr=[l_orderkey@0 as l_orderkey, l_linenumber@1 as l_linenumber, l_shipmode@3 as l_shipmode, l_quantity@2 as l_quantity]\n CoalesceBatchesExec: target_batch_size=8192\n FilterExec: l_shipmode@3 = SHIP\n DataSourceExec: file_groups={8 groups: [[/lineitem.parquet:0..2516294], [/lineitem.parquet:2516294..5032588], [/lineitem.parquet:5032588..7548882], [/lineitem.parquet:7548882..10065176], [/lineitem.parquet:10065176..12581470], [/lineitem.parquet:12581470..15097764], [/lineitem.parquet:15097764..17614058], [/lineitem.parquet:17614058..20130345]]}, projection=[l_orderkey, l_linenumber, l_quantity, l_shipmode], file_type=parquet, predicate=l_shipmode@3 = SHIP AND DynamicFilter [ empty ], pruning_predicate=l_shipmode_null_count@2 != row_count@3 AND l_shipmode_min@0 <= SHIP AND SHIP <= l_shipmode_max@1, required_guarantees=[l_shipmode in (SHIP)]\n" }, @@ -63,7 +2625,7 @@ expression: json_lines "query_name": "topk_lineitem" } ], - "target": "integration_utils", + "target": "datafusion_tracing::planner", "time.busy": "0.00ms", "time.idle": "0.00ms" },