diff --git a/quaint/src/connector/metrics.rs b/quaint/src/connector/metrics.rs
index a0c4ef426988..d855b5cf7d59 100644
--- a/quaint/src/connector/metrics.rs
+++ b/quaint/src/connector/metrics.rs
@@ -4,12 +4,19 @@ use crate::ast::{Params, Value};
 use crosstarget_utils::time::ElapsedTimeCounter;
 use std::future::Future;
 
-pub async fn query<'a, F, T, U>(tag: &'static str, query: &'a str, params: &'a [Value<'_>], f: F) -> crate::Result<T>
+pub async fn query<'a, F, T, U>(
+    tag: &'static str,
+    db_system_name: &'static str,
+    query: &'a str,
+    params: &'a [Value<'_>],
+    f: F,
+) -> crate::Result<T>
 where
     F: FnOnce() -> U + 'a,
     U: Future<Output = crate::Result<T>>,
 {
-    let span = info_span!("quaint:query", "db.statement" = %query);
+    let span =
+        info_span!("quaint:query", "db.system" = db_system_name, "db.statement" = %query, "otel.kind" = "client");
     do_query(tag, query, params, f).instrument(span).await
 }
 
diff --git a/quaint/src/connector/mssql/native/mod.rs b/quaint/src/connector/mssql/native/mod.rs
index 7383e503d0ab..fe7751ddf373 100644
--- a/quaint/src/connector/mssql/native/mod.rs
+++ b/quaint/src/connector/mssql/native/mod.rs
@@ -30,6 +30,7 @@ use tokio_util::compat::{Compat, TokioAsyncWriteCompatExt};
 pub use tiberius;
 
 static SQL_SERVER_DEFAULT_ISOLATION: IsolationLevel = IsolationLevel::ReadCommitted;
+const DB_SYSTEM_NAME: &str = "mssql";
 
 #[async_trait]
 impl TransactionCapable for Mssql {
@@ -130,7 +131,7 @@ impl Queryable for Mssql {
     }
 
     async fn query_raw(&self, sql: &str, params: &[Value<'_>]) -> crate::Result<ResultSet> {
-        metrics::query("mssql.query_raw", sql, params, move || async move {
+        metrics::query("mssql.query_raw", DB_SYSTEM_NAME, sql, params, move || async move {
             let mut client = self.client.lock().await;
 
             let mut query = tiberius::Query::new(sql);
@@ -193,7 +194,7 @@ impl Queryable for Mssql {
     }
 
     async fn execute_raw(&self, sql: &str, params: &[Value<'_>]) -> crate::Result<u64> {
-        metrics::query("mssql.execute_raw", sql, params, move || async move {
+        metrics::query("mssql.execute_raw", DB_SYSTEM_NAME, sql, params, move || async move {
             let mut query = tiberius::Query::new(sql);
 
             for param in params {
@@ -213,7 +214,7 @@ impl Queryable for Mssql {
     }
 
     async fn raw_cmd(&self, cmd: &str) -> crate::Result<()> {
-        metrics::query("mssql.raw_cmd", cmd, &[], move || async move {
+        metrics::query("mssql.raw_cmd", DB_SYSTEM_NAME, cmd, &[], move || async move {
             let mut client = self.client.lock().await;
             self.perform_io(client.simple_query(cmd)).await?.into_results().await?;
             Ok(())
diff --git a/quaint/src/connector/mysql/native/mod.rs b/quaint/src/connector/mysql/native/mod.rs
index b4b23ab94cb8..2c8a757a48e7 100644
--- a/quaint/src/connector/mysql/native/mod.rs
+++ b/quaint/src/connector/mysql/native/mod.rs
@@ -68,6 +68,8 @@ impl MysqlUrl {
     }
 }
 
+const DB_SYSTEM_NAME: &str = "mysql";
+
 /// A connector interface for the MySQL database.
 #[derive(Debug)]
 pub struct Mysql {
@@ -195,7 +197,7 @@ impl Queryable for Mysql {
     }
 
     async fn query_raw(&self, sql: &str, params: &[Value<'_>]) -> crate::Result<ResultSet> {
-        metrics::query("mysql.query_raw", sql, params, move || async move {
+        metrics::query("mysql.query_raw", DB_SYSTEM_NAME, sql, params, move || async move {
             self.prepared(sql, |stmt| async move {
                 let mut conn = self.conn.lock().await;
                 let rows: Vec<my::Row> = conn.exec(&stmt, conversion::conv_params(params)?).await?;
@@ -280,7 +282,7 @@ impl Queryable for Mysql {
     }
 
     async fn execute_raw(&self, sql: &str, params: &[Value<'_>]) -> crate::Result<u64> {
-        metrics::query("mysql.execute_raw", sql, params, move || async move {
+        metrics::query("mysql.execute_raw", DB_SYSTEM_NAME, sql, params, move || async move {
             self.prepared(sql, |stmt| async move {
                 let mut conn = self.conn.lock().await;
                 conn.exec_drop(stmt, conversion::conv_params(params)?).await?;
@@ -297,7 +299,7 @@ impl Queryable for Mysql {
     }
 
     async fn raw_cmd(&self, cmd: &str) -> crate::Result<()> {
-        metrics::query("mysql.raw_cmd", cmd, &[], move || async move {
+        metrics::query("mysql.raw_cmd", DB_SYSTEM_NAME, cmd, &[], move || async move {
             self.perform_io(|| async move {
                 let mut conn = self.conn.lock().await;
                 let mut result = cmd.run(&mut *conn).await?;
diff --git a/quaint/src/connector/postgres/native/mod.rs b/quaint/src/connector/postgres/native/mod.rs
index ad53908383fb..4cc1a3ee5aa8 100644
--- a/quaint/src/connector/postgres/native/mod.rs
+++ b/quaint/src/connector/postgres/native/mod.rs
@@ -55,6 +55,9 @@ impl Debug for PostgresClient {
     }
 }
 
+const DB_SYSTEM_NAME_POSTGRESQL: &str = "postgresql";
+const DB_SYSTEM_NAME_COCKROACHDB: &str = "cockroachdb";
+
 /// A connector interface for the PostgreSQL database.
 #[derive(Debug)]
 pub struct PostgreSql {
@@ -65,6 +68,7 @@ pub struct PostgreSql {
     is_healthy: AtomicBool,
     is_cockroachdb: bool,
     is_materialize: bool,
+    db_system_name: &'static str,
 }
 
 /// Key uniquely representing an SQL statement in the prepared statements cache.
@@ -285,6 +289,12 @@ impl PostgreSql {
             }
         }
 
+        let db_system_name = if is_cockroachdb {
+            DB_SYSTEM_NAME_COCKROACHDB
+        } else {
+            DB_SYSTEM_NAME_POSTGRESQL
+        };
+
         Ok(Self {
             client: PostgresClient(client),
             socket_timeout: url.query_params.socket_timeout,
@@ -293,6 +303,7 @@ impl PostgreSql {
             is_healthy: AtomicBool::new(true),
             is_cockroachdb,
             is_materialize,
+            db_system_name,
         })
     }
 
@@ -308,6 +319,7 @@ impl PostgreSql {
             is_healthy: AtomicBool::new(true),
             is_cockroachdb: false,
             is_materialize: false,
+            db_system_name: DB_SYSTEM_NAME_POSTGRESQL,
         })
     }
 
@@ -539,72 +551,84 @@ impl Queryable for PostgreSql {
     async fn query_raw(&self, sql: &str, params: &[Value<'_>]) -> crate::Result<ResultSet> {
         self.check_bind_variables_len(params)?;
 
-        metrics::query("postgres.query_raw", sql, params, move || async move {
-            let stmt = self.fetch_cached(sql, &[]).await?;
-
-            if stmt.params().len() != params.len() {
-                let kind = ErrorKind::IncorrectNumberOfParameters {
-                    expected: stmt.params().len(),
-                    actual: params.len(),
-                };
-
-                return Err(Error::builder(kind).build());
-            }
+        metrics::query(
+            "postgres.query_raw",
+            self.db_system_name,
+            sql,
+            params,
+            move || async move {
+                let stmt = self.fetch_cached(sql, &[]).await?;
+
+                if stmt.params().len() != params.len() {
+                    let kind = ErrorKind::IncorrectNumberOfParameters {
+                        expected: stmt.params().len(),
+                        actual: params.len(),
+                    };
+
+                    return Err(Error::builder(kind).build());
+                }
 
-            let rows = self
-                .perform_io(self.client.0.query(&stmt, conversion::conv_params(params).as_slice()))
-                .await?;
+                let rows = self
+                    .perform_io(self.client.0.query(&stmt, conversion::conv_params(params).as_slice()))
+                    .await?;
 
-            let col_types = stmt
-                .columns()
-                .iter()
-                .map(|c| PGColumnType::from_pg_type(c.type_()))
-                .map(ColumnType::from)
-                .collect::<Vec<_>>();
-            let mut result = ResultSet::new(stmt.to_column_names(), col_types, Vec::new());
+                let col_types = stmt
+                    .columns()
+                    .iter()
+                    .map(|c| PGColumnType::from_pg_type(c.type_()))
+                    .map(ColumnType::from)
+                    .collect::<Vec<_>>();
+                let mut result = ResultSet::new(stmt.to_column_names(), col_types, Vec::new());
 
-            for row in rows {
-                result.rows.push(row.get_result_row()?);
-            }
+                for row in rows {
+                    result.rows.push(row.get_result_row()?);
+                }
 
-            Ok(result)
-        })
+                Ok(result)
+            },
+        )
         .await
     }
 
     async fn query_raw_typed(&self, sql: &str, params: &[Value<'_>]) -> crate::Result<ResultSet> {
         self.check_bind_variables_len(params)?;
 
-        metrics::query("postgres.query_raw", sql, params, move || async move {
-            let stmt = self.fetch_cached(sql, params).await?;
-
-            if stmt.params().len() != params.len() {
-                let kind = ErrorKind::IncorrectNumberOfParameters {
-                    expected: stmt.params().len(),
-                    actual: params.len(),
-                };
-
-                return Err(Error::builder(kind).build());
-            }
+        metrics::query(
+            "postgres.query_raw",
+            self.db_system_name,
+            sql,
+            params,
+            move || async move {
+                let stmt = self.fetch_cached(sql, params).await?;
+
+                if stmt.params().len() != params.len() {
+                    let kind = ErrorKind::IncorrectNumberOfParameters {
+                        expected: stmt.params().len(),
+                        actual: params.len(),
+                    };
+
+                    return Err(Error::builder(kind).build());
+                }
 
-            let col_types = stmt
-                .columns()
-                .iter()
-                .map(|c| PGColumnType::from_pg_type(c.type_()))
-                .map(ColumnType::from)
-                .collect::<Vec<_>>();
-            let rows = self
-                .perform_io(self.client.0.query(&stmt, conversion::conv_params(params).as_slice()))
-                .await?;
+                let col_types = stmt
+                    .columns()
+                    .iter()
+                    .map(|c| PGColumnType::from_pg_type(c.type_()))
+                    .map(ColumnType::from)
+                    .collect::<Vec<_>>();
+                let rows = self
+                    .perform_io(self.client.0.query(&stmt, conversion::conv_params(params).as_slice()))
+                    .await?;
 
-            let mut result = ResultSet::new(stmt.to_column_names(), col_types, Vec::new());
+                let mut result = ResultSet::new(stmt.to_column_names(), col_types, Vec::new());
 
-            for row in rows {
-                result.rows.push(row.get_result_row()?);
-            }
+                for row in rows {
+                    result.rows.push(row.get_result_row()?);
+                }
 
-            Ok(result)
-        })
+                Ok(result)
+            },
+        )
         .await
     }
 
@@ -692,53 +716,65 @@ impl Queryable for PostgreSql {
     async fn execute_raw(&self, sql: &str, params: &[Value<'_>]) -> crate::Result<u64> {
         self.check_bind_variables_len(params)?;
 
-        metrics::query("postgres.execute_raw", sql, params, move || async move {
-            let stmt = self.fetch_cached(sql, &[]).await?;
-
-            if stmt.params().len() != params.len() {
-                let kind = ErrorKind::IncorrectNumberOfParameters {
-                    expected: stmt.params().len(),
-                    actual: params.len(),
-                };
-
-                return Err(Error::builder(kind).build());
-            }
+        metrics::query(
+            "postgres.execute_raw",
+            self.db_system_name,
+            sql,
+            params,
+            move || async move {
+                let stmt = self.fetch_cached(sql, &[]).await?;
+
+                if stmt.params().len() != params.len() {
+                    let kind = ErrorKind::IncorrectNumberOfParameters {
+                        expected: stmt.params().len(),
+                        actual: params.len(),
+                    };
+
+                    return Err(Error::builder(kind).build());
+                }
 
-            let changes = self
-                .perform_io(self.client.0.execute(&stmt, conversion::conv_params(params).as_slice()))
-                .await?;
+                let changes = self
+                    .perform_io(self.client.0.execute(&stmt, conversion::conv_params(params).as_slice()))
+                    .await?;
 
-            Ok(changes)
-        })
+                Ok(changes)
+            },
+        )
         .await
     }
 
     async fn execute_raw_typed(&self, sql: &str, params: &[Value<'_>]) -> crate::Result<u64> {
         self.check_bind_variables_len(params)?;
 
-        metrics::query("postgres.execute_raw", sql, params, move || async move {
-            let stmt = self.fetch_cached(sql, params).await?;
-
-            if stmt.params().len() != params.len() {
-                let kind = ErrorKind::IncorrectNumberOfParameters {
-                    expected: stmt.params().len(),
-                    actual: params.len(),
-                };
-
-                return Err(Error::builder(kind).build());
-            }
+        metrics::query(
+            "postgres.execute_raw",
+            self.db_system_name,
+            sql,
+            params,
+            move || async move {
+                let stmt = self.fetch_cached(sql, params).await?;
+
+                if stmt.params().len() != params.len() {
+                    let kind = ErrorKind::IncorrectNumberOfParameters {
+                        expected: stmt.params().len(),
+                        actual: params.len(),
+                    };
+
+                    return Err(Error::builder(kind).build());
+                }
 
-            let changes = self
-                .perform_io(self.client.0.execute(&stmt, conversion::conv_params(params).as_slice()))
-                .await?;
+                let changes = self
+                    .perform_io(self.client.0.execute(&stmt, conversion::conv_params(params).as_slice()))
+                    .await?;
 
-            Ok(changes)
-        })
+                Ok(changes)
+            },
+        )
         .await
     }
 
     async fn raw_cmd(&self, cmd: &str) -> crate::Result<()> {
-        metrics::query("postgres.raw_cmd", cmd, &[], move || async move {
+        metrics::query("postgres.raw_cmd", self.db_system_name, cmd, &[], move || async move {
             self.perform_io(self.client.0.simple_query(cmd)).await?;
             Ok(())
         })
diff --git a/quaint/src/connector/sqlite/native/mod.rs b/quaint/src/connector/sqlite/native/mod.rs
index abcec7410a67..2d738a7f087f 100644
--- a/quaint/src/connector/sqlite/native/mod.rs
+++ b/quaint/src/connector/sqlite/native/mod.rs
@@ -29,6 +29,8 @@ pub struct Sqlite {
     pub(crate) client: Mutex<rusqlite::Connection>,
 }
 
+const DB_SYSTEM_NAME: &str = "sqlite";
+
 impl TryFrom<&str> for Sqlite {
     type Error = Error;
 
@@ -100,7 +102,7 @@ impl Queryable for Sqlite {
     }
 
     async fn query_raw(&self, sql: &str, params: &[Value<'_>]) -> crate::Result<ResultSet> {
-        metrics::query("sqlite.query_raw", sql, params, move || async move {
+        metrics::query("sqlite.query_raw", DB_SYSTEM_NAME, sql, params, move || async move {
             let client = self.client.lock().await;
 
             let mut stmt = client.prepare_cached(sql)?;
@@ -134,7 +136,7 @@ impl Queryable for Sqlite {
     }
 
     async fn execute_raw(&self, sql: &str, params: &[Value<'_>]) -> crate::Result<u64> {
-        metrics::query("sqlite.query_raw", sql, params, move || async move {
+        metrics::query("sqlite.query_raw", DB_SYSTEM_NAME, sql, params, move || async move {
             let client = self.client.lock().await;
             let mut stmt = client.prepare_cached(sql)?;
             let res = u64::try_from(stmt.execute(params_from_iter(params.iter()))?)?;
@@ -149,7 +151,7 @@ impl Queryable for Sqlite {
     }
 
     async fn raw_cmd(&self, cmd: &str) -> crate::Result<()> {
-        metrics::query("sqlite.raw_cmd", cmd, &[], move || async move {
+        metrics::query("sqlite.raw_cmd", DB_SYSTEM_NAME, cmd, &[], move || async move {
             let client = self.client.lock().await;
             client.execute_batch(cmd)?;
             Ok(())
diff --git a/query-engine/connectors/mongodb-query-connector/src/root_queries/mod.rs b/query-engine/connectors/mongodb-query-connector/src/root_queries/mod.rs
index 9ee217d62a81..6f534a95fc98 100644
--- a/query-engine/connectors/mongodb-query-connector/src/root_queries/mod.rs
+++ b/query-engine/connectors/mongodb-query-connector/src/root_queries/mod.rs
@@ -23,6 +23,8 @@ use std::time::Instant;
 use tracing::{debug, info_span};
 use tracing_futures::Instrument;
 
+const DB_SYSTEM_NAME: &str = "mongodb";
+
 /// Transforms a document to a `Record`, fields ordered as defined in `fields`.
 fn document_to_record(mut doc: Document, fields: &[String], meta_mapping: &OutputMetaMapping) -> crate::Result<Record> {
     let mut values: Vec<PrismaValue> = Vec::with_capacity(fields.len());
@@ -69,9 +71,16 @@ where
     let span = info_span!(
         "prisma:engine:db_query",
         user_facing = true,
-        "db.statement" = %Arc::clone(&query_string)
+        "db.system" = DB_SYSTEM_NAME,
+        "db.statement" = %Arc::clone(&query_string),
+        "db.operation.name" = builder.query_type(),
+        "otel.kind" = "client"
     );
 
+    if let Some(coll) = builder.collection() {
+        span.record("db.collection.name", coll);
+    }
+
     let start = Instant::now();
     let res = f().instrument(span).await;
     let elapsed = start.elapsed().as_millis() as f64;
diff --git a/query-engine/connectors/query-connector/src/interface.rs b/query-engine/connectors/query-connector/src/interface.rs
index cbdafcaeeee3..90e05b99a567 100644
--- a/query-engine/connectors/query-connector/src/interface.rs
+++ b/query-engine/connectors/query-connector/src/interface.rs
@@ -9,7 +9,10 @@ pub trait Connector {
     /// Returns a connection to a data source.
     async fn get_connection(&self) -> crate::Result<Box<dyn Connection + Send + Sync>>;
 
-    /// Returns the name of the connector.
+    /// Returns the database system name, as per the OTEL spec.
+    /// Reference:
+    /// - https://opentelemetry.io/docs/specs/semconv/database/sql/
+    /// - https://opentelemetry.io/docs/specs/semconv/database/mongodb/
     fn name(&self) -> &'static str;
 
     /// Returns whether a connector should retry an entire transaction when that transaction failed during its execution
diff --git a/query-engine/connectors/sql-query-connector/src/database/js.rs b/query-engine/connectors/sql-query-connector/src/database/js.rs
index d771eb51e406..40ca0caa0025 100644
--- a/query-engine/connectors/sql-query-connector/src/database/js.rs
+++ b/query-engine/connectors/sql-query-connector/src/database/js.rs
@@ -48,7 +48,16 @@ impl Connector for Js {
     }
 
     fn name(&self) -> &'static str {
-        "js"
+        match self.connection_info.sql_family() {
+            #[cfg(feature = "postgresql")]
+            SqlFamily::Postgres => "postgresql",
+            #[cfg(feature = "mysql")]
+            SqlFamily::Mysql => "mysql",
+            #[cfg(feature = "sqlite")]
+            SqlFamily::Sqlite => "sqlite",
+            #[cfg(feature = "mssql")]
+            SqlFamily::Mssql => "mssql",
+        }
     }
 
     fn should_retry_on_transient_error(&self) -> bool {
diff --git a/query-engine/connectors/sql-query-connector/src/database/native/postgresql.rs b/query-engine/connectors/sql-query-connector/src/database/native/postgresql.rs
index 701fa9a1a0c5..9e59e4f232c7 100644
--- a/query-engine/connectors/sql-query-connector/src/database/native/postgresql.rs
+++ b/query-engine/connectors/sql-query-connector/src/database/native/postgresql.rs
@@ -13,6 +13,7 @@ pub struct PostgreSql {
     pool: Quaint,
     connection_info: ConnectionInfo,
     features: psl::PreviewFeatures,
+    flavour: PostgresFlavour,
 }
 
 impl PostgreSql {
@@ -60,6 +61,7 @@ impl FromSource for PostgreSql {
             pool,
             connection_info,
             features,
+            flavour,
         })
     }
 }
@@ -76,7 +78,10 @@ impl Connector for PostgreSql {
     }
 
     fn name(&self) -> &'static str {
-        "postgres"
+        match self.flavour {
+            PostgresFlavour::Postgres | PostgresFlavour::Unknown => "postgresql",
+            PostgresFlavour::Cockroach => "cockroachdb",
+        }
     }
 
     fn should_retry_on_transient_error(&self) -> bool {
diff --git a/query-engine/core/src/executor/execute_operation.rs b/query-engine/core/src/executor/execute_operation.rs
index 6ef445d8364e..6abb48cdb80b 100644
--- a/query-engine/core/src/executor/execute_operation.rs
+++ b/query-engine/core/src/executor/execute_operation.rs
@@ -87,7 +87,7 @@ pub async fn execute_single_self_contained<C: Connector + Send + Sync>(
     let conn_span = info_span!(
         "prisma:engine:connection",
         user_facing = true,
-        "db.type" = connector.name()
+        "db.system" = connector.name(),
     );
     let conn = connector.get_connection().instrument(conn_span).await?;
 
@@ -120,7 +120,7 @@ pub async fn execute_many_self_contained<C: Connector + Send + Sync>(
         let conn_span = info_span!(
             "prisma:engine:connection",
             user_facing = true,
-            "db.type" = connector.name(),
+            "db.system" = connector.name(),
         );
         let conn = connector.get_connection().instrument(conn_span).await?;
 
diff --git a/query-engine/core/src/executor/interpreting_executor.rs b/query-engine/core/src/executor/interpreting_executor.rs
index 0408361b766d..119eddf65b8b 100644
--- a/query-engine/core/src/executor/interpreting_executor.rs
+++ b/query-engine/core/src/executor/interpreting_executor.rs
@@ -102,7 +102,7 @@ where
             let conn_span = info_span!(
                 "prisma:engine:connection",
                 user_facing = true,
-                "db.type" = self.connector.name(),
+                "db.system" = self.connector.name(),
             );
             let mut conn = self.connector.get_connection().instrument(conn_span).await?;
             let mut tx = conn.start_transaction(transaction.isolation_level()).await?;
@@ -162,7 +162,7 @@ where
             let conn_span = info_span!(
                 "prisma:engine:connection",
                 user_facing = true,
-                "db.type" = self.connector.name()
+                "db.system" = self.connector.name()
             );
             let conn = crosstarget_utils::time::timeout(
                 Duration::from_millis(tx_opts.max_acquisition_millis),
diff --git a/query-engine/core/src/telemetry/models.rs b/query-engine/core/src/telemetry/models.rs
index c1e9ff0158b9..275ec5e56930 100644
--- a/query-engine/core/src/telemetry/models.rs
+++ b/query-engine/core/src/telemetry/models.rs
@@ -7,7 +7,21 @@ use std::{
     time::{Duration, SystemTime},
 };
 
-const ACCEPT_ATTRIBUTES: &[&str] = &["db.statement", "itx_id", "db.type"];
+const ACCEPT_ATTRIBUTES: &[&str] = &[
+    "db.system",
+    "db.statement",
+    "db.collection.name",
+    "db.operation.name",
+    "itx_id",
+];
+
+#[derive(Serialize, Debug, Clone, PartialEq, Eq)]
+pub enum SpanKind {
+    #[serde(rename = "client")]
+    Client,
+    #[serde(rename = "internal")]
+    Internal,
+}
 
 #[derive(Serialize, Debug, Clone, PartialEq, Eq)]
 pub struct TraceSpan {
@@ -23,6 +37,7 @@ pub struct TraceSpan {
     pub(super) events: Vec<Event>,
     #[serde(skip_serializing_if = "Vec::is_empty")]
     pub(super) links: Vec<Link>,
+    pub(super) kind: SpanKind,
 }
 
 #[derive(Serialize, Debug, Clone, PartialEq, Eq)]
@@ -39,6 +54,11 @@ impl TraceSpan {
 
 impl From<SpanData> for TraceSpan {
     fn from(span: SpanData) -> Self {
+        let kind = match span.span_kind {
+            opentelemetry::trace::SpanKind::Client => SpanKind::Client,
+            _ => SpanKind::Internal,
+        };
+
         let attributes: HashMap<String, serde_json::Value> =
             span.attributes
                 .iter()
@@ -105,6 +125,7 @@ impl From<SpanData> for TraceSpan {
             attributes,
             links,
             events,
+            kind,
         }
     }
 }
diff --git a/query-engine/driver-adapters/src/queryable.rs b/query-engine/driver-adapters/src/queryable.rs
index dde42c5fb420..8aa7579762f6 100644
--- a/query-engine/driver-adapters/src/queryable.rs
+++ b/query-engine/driver-adapters/src/queryable.rs
@@ -30,12 +30,18 @@ use tracing::{info_span, Instrument};
 pub(crate) struct JsBaseQueryable {
     pub(crate) proxy: CommonProxy,
     pub provider: AdapterFlavour,
+    pub(crate) db_system_name: &'static str,
 }
 
 impl JsBaseQueryable {
     pub(crate) fn new(proxy: CommonProxy) -> Self {
         let provider: AdapterFlavour = proxy.provider.parse().unwrap();
-        Self { proxy, provider }
+        let db_system_name = provider.db_system_name();
+        Self {
+            proxy,
+            provider,
+            db_system_name,
+        }
     }
 
     /// visit a quaint query AST according to the provider of the JS connector
@@ -84,7 +90,7 @@ impl QuaintQueryable for JsBaseQueryable {
     }
 
     async fn query_raw(&self, sql: &str, params: &[quaint::Value<'_>]) -> quaint::Result<ResultSet> {
-        metrics::query("js.query_raw", sql, params, move || async move {
+        metrics::query("js.query_raw", self.db_system_name, sql, params, move || async move {
             self.do_query_raw(sql, params).await
         })
         .await
@@ -104,7 +110,7 @@ impl QuaintQueryable for JsBaseQueryable {
     }
 
     async fn execute_raw(&self, sql: &str, params: &[quaint::Value<'_>]) -> quaint::Result<u64> {
-        metrics::query("js.execute_raw", sql, params, move || async move {
+        metrics::query("js.execute_raw", self.db_system_name, sql, params, move || async move {
             self.do_execute_raw(sql, params).await
         })
         .await
@@ -116,7 +122,7 @@ impl QuaintQueryable for JsBaseQueryable {
 
     async fn raw_cmd(&self, cmd: &str) -> quaint::Result<()> {
         let params = &[];
-        metrics::query("js.raw_cmd", cmd, params, move || async move {
+        metrics::query("js.raw_cmd", self.db_system_name, cmd, params, move || async move {
             self.do_execute_raw(cmd, params).await?;
             Ok(())
         })
@@ -174,7 +180,7 @@ impl JsBaseQueryable {
         let serialization_span = info_span!("js:query:args", user_facing = true, "length" = %len);
         let query = self.build_query(sql, params).instrument(serialization_span).await?;
 
-        let sql_span = info_span!("js:query:sql", user_facing = true, "db.statement" = %sql);
+        let sql_span = info_span!("js:query:sql", user_facing = true, "db.system" = %self.db_system_name, "db.statement" = %sql, "otel.kind" = "client");
         let result_set = self.proxy.query_raw(query).instrument(sql_span).await?;
 
         let len = result_set.len();
@@ -196,7 +202,7 @@ impl JsBaseQueryable {
         let serialization_span = info_span!("js:query:args", user_facing = true, "length" = %len);
         let query = self.build_query(sql, params).instrument(serialization_span).await?;
 
-        let sql_span = info_span!("js:query:sql", user_facing = true, "db.statement" = %sql);
+        let sql_span = info_span!("js:query:sql", user_facing = true, "db.system" = %self.db_system_name, "db.statement" = %sql, "otel.kind" = "client");
         let affected_rows = self.proxy.execute_raw(query).instrument(sql_span).await?;
 
         Ok(affected_rows as u64)
diff --git a/query-engine/driver-adapters/src/transaction.rs b/query-engine/driver-adapters/src/transaction.rs
index 8d124bd4da0a..4c39f791e57c 100644
--- a/query-engine/driver-adapters/src/transaction.rs
+++ b/query-engine/driver-adapters/src/transaction.rs
@@ -99,7 +99,14 @@ impl JsTransaction {
 
     pub async fn raw_phantom_cmd(&self, cmd: &str) -> quaint::Result<()> {
         let params = &[];
-        quaint::connector::metrics::query("js.raw_phantom_cmd", cmd, params, move || async move { Ok(()) }).await
+        quaint::connector::metrics::query(
+            "js.raw_phantom_cmd",
+            self.inner.db_system_name,
+            cmd,
+            params,
+            move || async move { Ok(()) },
+        )
+        .await
     }
 }
 
diff --git a/query-engine/driver-adapters/src/types.rs b/query-engine/driver-adapters/src/types.rs
index 9e5f1eae149d..03f9c5d6325a 100644
--- a/query-engine/driver-adapters/src/types.rs
+++ b/query-engine/driver-adapters/src/types.rs
@@ -25,6 +25,19 @@ pub enum AdapterFlavour {
     Sqlite,
 }
 
+impl AdapterFlavour {
+    pub fn db_system_name(&self) -> &'static str {
+        match self {
+            #[cfg(feature = "mysql")]
+            Self::Mysql => "mysql",
+            #[cfg(feature = "postgresql")]
+            Self::Postgres => "postgresql",
+            #[cfg(feature = "sqlite")]
+            Self::Sqlite => "sqlite",
+        }
+    }
+}
+
 impl FromStr for AdapterFlavour {
     type Err = String;
 
diff --git a/query-engine/query-engine-c-abi/src/engine.rs b/query-engine/query-engine-c-abi/src/engine.rs
index 4d3d81636755..2301545901bf 100644
--- a/query-engine/query-engine-c-abi/src/engine.rs
+++ b/query-engine/query-engine-c-abi/src/engine.rs
@@ -238,7 +238,7 @@ impl QueryEngine {
                 let conn_span = tracing::info_span!(
                     "prisma:engine:connection",
                     user_facing = true,
-                    "db.type" = connector.name(),
+                    "db.system" = connector.name(),
                 );
 
                 connector.get_connection().instrument(conn_span).await?;
diff --git a/query-engine/query-engine-node-api/src/engine.rs b/query-engine/query-engine-node-api/src/engine.rs
index 598aa9650617..d03e78f6c298 100644
--- a/query-engine/query-engine-node-api/src/engine.rs
+++ b/query-engine/query-engine-node-api/src/engine.rs
@@ -224,7 +224,7 @@ impl QueryEngine {
                     let conn_span = tracing::info_span!(
                         "prisma:engine:connection",
                         user_facing = true,
-                        "db.type" = connector.name(),
+                        "db.system" = connector.name(),
                     );
 
                     let conn = connector.get_connection().instrument(conn_span).await?;
diff --git a/query-engine/query-engine-wasm/src/wasm/engine.rs b/query-engine/query-engine-wasm/src/wasm/engine.rs
index ae6fe40f8728..faf77746d518 100644
--- a/query-engine/query-engine-wasm/src/wasm/engine.rs
+++ b/query-engine/query-engine-wasm/src/wasm/engine.rs
@@ -111,7 +111,7 @@ impl QueryEngine {
                 let conn_span = tracing::info_span!(
                     "prisma:engine:connection",
                     user_facing = true,
-                    "db.type" = connector.name(),
+                    "db.system" = connector.name(),
                 );
 
                 let conn = connector.get_connection().instrument(conn_span).await?;