better trace event levels, otel.name attribute

Author: Protryon

tokio-postgres/src/client.rs

@@ -9,7 +9,7 @@ use crate::simple_query::SimpleQueryStream;
 #[cfg(feature = "runtime")]
 use crate::tls::MakeTlsConnect;
 use crate::tls::TlsConnect;
-use crate::trace::make_span;
+use crate::trace::{make_span, SpanOperation};
 use crate::types::{Oid, ToSql, Type};
 #[cfg(feature = "runtime")]
 use crate::Socket;
@@ -258,8 +258,7 @@ impl Client {
         query: &str,
         parameter_types: &[Type],
     ) -> Result<Statement, Error> {
-        let span = make_span(&self.inner);
-        span.record("db.operation", "prepare");
+        let span = make_span(&self.inner, SpanOperation::Prepare);
 
         prepare::prepare(&self.inner, query, parameter_types)
             .instrument(span)

tokio-postgres/src/prepare.rs

@@ -2,7 +2,7 @@ use crate::client::InnerClient;
 use crate::codec::FrontendMessage;
 use crate::connection::RequestMessages;
 use crate::error::SqlState;
-use crate::trace::make_span;
+use crate::trace::{make_span, SpanOperation};
 use crate::types::{Field, Kind, Oid, Type};
 use crate::{query, slice_iter};
 use crate::{Column, Error, Statement};
@@ -116,8 +116,7 @@ fn prepare_rec<'a>(
     query: &'a str,
     types: &'a [Type],
 ) -> Pin<Box<dyn Future<Output = Result<Statement, Error>> + 'a + Send>> {
-    let span = make_span(client);
-    span.record("db.operation", "prepare");
+    let span = make_span(client, SpanOperation::Prepare);
     Box::pin(prepare(client, query, types).instrument(span))
 }
 

tokio-postgres/src/query.rs

@@ -1,7 +1,7 @@
 use crate::client::{InnerClient, Responses};
 use crate::codec::FrontendMessage;
 use crate::connection::RequestMessages;
-use crate::trace::make_span;
+use crate::trace::{make_span, SpanOperation};
 use crate::types::{BorrowToSql, IsNull};
 use crate::{Error, Portal, Row, Statement};
 use bytes::{Bytes, BytesMut};
@@ -84,7 +84,7 @@ where
     I: IntoIterator<Item = P>,
     I::IntoIter: ExactSizeIterator,
 {
-    let span = make_span(client);
+    let span = make_span(client, SpanOperation::Query);
     span.record("db.operation", "query");
 
     let buf = encode_with_logs(client, &span, &statement, params)?;
@@ -108,9 +108,8 @@ pub async fn query_portal(
     portal: &Portal,
     max_rows: i32,
 ) -> Result<RowStream, Error> {
-    let span = make_span(client);
+    let span = make_span(client, SpanOperation::Portal);
     span.record("db.statement", portal.statement().query());
-    span.record("db.operation", "portal");
 
     let buf = client.with_buf(|buf| {
         frontend::execute(portal.name(), max_rows, buf).map_err(Error::encode)?;
@@ -152,8 +151,7 @@ where
     I: IntoIterator<Item = P>,
     I::IntoIter: ExactSizeIterator,
 {
-    let span = make_span(client);
-    span.record("db.operation", "execute");
+    let span = make_span(client, SpanOperation::Execute);
 
     let buf = encode_with_logs(client, &span, &statement, params)?;
 

tokio-postgres/src/trace.rs

@@ -1,9 +1,83 @@
-use tracing::{field::Empty, Span};
+use tracing::{field::Empty, Level, Span};
 
 use crate::client::{Addr, InnerClient};
 
-pub(crate) fn make_span(client: &InnerClient) -> Span {
-    let span = tracing::debug_span!("query",
+pub(crate) enum SpanOperation {
+    Query,
+    Portal,
+    Execute,
+    Prepare,
+}
+
+impl SpanOperation {
+    const fn name(&self) -> &'static str {
+        match self {
+            SpanOperation::Query => "query",
+            SpanOperation::Portal => "portal",
+            SpanOperation::Execute => "execute",
+            SpanOperation::Prepare => "prepare",
+        }
+    }
+
+    const fn level(&self) -> Level {
+        match self {
+            SpanOperation::Query => Level::DEBUG,
+            SpanOperation::Portal => Level::DEBUG,
+            SpanOperation::Execute => Level::DEBUG,
+            SpanOperation::Prepare => Level::TRACE,
+        }
+    }
+}
+
+macro_rules! span_dynamic_lvl {
+    ( $(target: $target:expr,)? $(parent: $parent:expr,)? $lvl:expr, $($tt:tt)* ) => {
+        match $lvl {
+            tracing::Level::ERROR => {
+                tracing::span!(
+                    $(target: $target,)?
+                    $(parent: $parent,)?
+                    tracing::Level::ERROR,
+                    $($tt)*
+                )
+            }
+            tracing::Level::WARN => {
+                tracing::span!(
+                    $(target: $target,)?
+                    $(parent: $parent,)?
+                    tracing::Level::WARN,
+                    $($tt)*
+                )
+            }
+            tracing::Level::INFO => {
+                tracing::span!(
+                    $(target: $target,)?
+                    $(parent: $parent,)?
+                    tracing::Level::INFO,
+                    $($tt)*
+                )
+            }
+            tracing::Level::DEBUG => {
+                tracing::span!(
+                    $(target: $target,)?
+                    $(parent: $parent,)?
+                    tracing::Level::DEBUG,
+                    $($tt)*
+                )
+            }
+            tracing::Level::TRACE => {
+                tracing::span!(
+                    $(target: $target,)?
+                    $(parent: $parent,)?
+                    tracing::Level::TRACE,
+                    $($tt)*
+                )
+            }
+        }
+    };
+}
+
+pub(crate) fn make_span(client: &InnerClient, operation: SpanOperation) -> Span {
+    let span = span_dynamic_lvl!(operation.level(), "query",
         db.system = "postgresql",
         server.address = Empty,
         server.socket.address = Empty,
@@ -12,13 +86,13 @@ pub(crate) fn make_span(client: &InnerClient) -> Span {
         network.transport = Empty,
         db.name = %client.db_name(),
         db.user = %client.db_user(),
-        otel.name = %format!("psql {}", client.db_name()),
+        otel.name = %format!("PSQL {} {}", operation.name(), client.db_name()),
         otel.kind = "Client",
 
         // to set when output
         otel.status_code = Empty,
         exception.message = Empty,
-        db.operation = Empty,
+        db.operation = operation.name(),
 
         // for queries
         db.statement = Empty,