diff --git a/pom.xml b/pom.xml
index dc8eafd64..07cc7283f 100644
--- a/pom.xml
+++ b/pom.xml
@@ -14,7 +14,7 @@
     <groupId>org.mule.connectors</groupId>
     <artifactId>mule-db-connector</artifactId>
     <packaging>mule-extension</packaging>
-    <version>2.0.0-SNAPSHOT</version>
+    <version>2.0.3-SNAPSHOT</version>
 
     <name>Database Connector</name>
     <description>A Mule extension that provides functionality for connecting to Databases through the JDBC standard</description>
@@ -62,6 +62,8 @@
         <spring-context-version>5.3.2</spring-context-version>
         <spring-core-version>5.3.2</spring-core-version>
         <mule-spring-module-version>1.3.7</mule-spring-module-version>
+        <muleSdkCompatibilityApiVersion>1.0.0-SNAPSHOT</muleSdkCompatibilityApiVersion>
+        <muleSdkApiVersion>1.0.0-SNAPSHOT</muleSdkApiVersion>
     </properties>
 
     <dependencies>
@@ -174,6 +176,16 @@
             <version>${xmlunit.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.mule.sdk</groupId>
+            <artifactId>mule-sdk-compatibility-api</artifactId>
+            <version>${muleSdkCompatibilityApiVersion}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.mule.sdk</groupId>
+            <artifactId>mule-sdk-api</artifactId>
+            <version>${muleSdkApiVersion}</version>
+        </dependency>
 
         <!-- DB Drivers -->
         <dependency>
diff --git a/src/main/java/org/mule/extension/db/internal/domain/connection/datasource/DbDataSourceReferenceConnectionProvider.java b/src/main/java/org/mule/extension/db/internal/domain/connection/datasource/DbDataSourceReferenceConnectionProvider.java
index e0c66e3f6..6c24ac0e2 100644
--- a/src/main/java/org/mule/extension/db/internal/domain/connection/datasource/DbDataSourceReferenceConnectionProvider.java
+++ b/src/main/java/org/mule/extension/db/internal/domain/connection/datasource/DbDataSourceReferenceConnectionProvider.java
@@ -12,6 +12,7 @@
 
 import javax.sql.DataSource;
 
+import org.mule.db.commons.internal.domain.connection.DataSourceConfigDbConnectionTracingMetadata;
 import org.mule.db.commons.internal.domain.connection.DbConnection;
 import org.mule.db.commons.internal.domain.connection.datasource.DataSourceReferenceConnectionProvider;
 import org.mule.db.commons.internal.domain.type.ResolvedDbType;
@@ -43,7 +44,8 @@ public class DbDataSourceReferenceConnectionProvider extends DataSourceReference
   protected DbConnection createDbConnection(Connection connection) throws Exception {
     if (isOracle(connection)) {
       return new OracleDbConnection(connection, super.resolveCustomTypes(), resolvedDbTypesCache,
-                                    super.getCacheQueryTemplateSize());
+                                    super.getCacheQueryTemplateSize(),
+                                    new DataSourceConfigDbConnectionTracingMetadata(getDataSourceConfig().get()));
     } else {
       return super.createDbConnection(connection);
     }
diff --git a/src/main/java/org/mule/extension/db/internal/domain/connection/derby/DerbyConnection.java b/src/main/java/org/mule/extension/db/internal/domain/connection/derby/DerbyConnection.java
index 0ff903e62..e67ff51f4 100644
--- a/src/main/java/org/mule/extension/db/internal/domain/connection/derby/DerbyConnection.java
+++ b/src/main/java/org/mule/extension/db/internal/domain/connection/derby/DerbyConnection.java
@@ -8,6 +8,7 @@
 
 import org.mule.db.commons.internal.domain.connection.DefaultDbConnection;
 import org.mule.db.commons.internal.domain.type.DbType;
+import org.mule.db.commons.internal.domain.connection.DbConnectionTracingMetadata;
 
 import java.sql.Connection;
 import java.util.List;
@@ -19,8 +20,9 @@
  */
 public class DerbyConnection extends DefaultDbConnection {
 
-  DerbyConnection(Connection connection, List<DbType> dbTypes, long cacheQueryTemplateSize) {
-    super(connection, dbTypes, cacheQueryTemplateSize);
+  DerbyConnection(Connection connection, List<DbType> dbTypes, long cacheQueryTemplateSize,
+                  DbConnectionTracingMetadata dbConnectionTracingMetadata) {
+    super(connection, dbTypes, cacheQueryTemplateSize, dbConnectionTracingMetadata);
   }
 
   // We are disabling content streaming for Derby because of a incompatibility between the connector logic and the
diff --git a/src/main/java/org/mule/extension/db/internal/domain/connection/derby/DerbyConnectionProvider.java b/src/main/java/org/mule/extension/db/internal/domain/connection/derby/DerbyConnectionProvider.java
index 6b0373094..b44b63e7f 100644
--- a/src/main/java/org/mule/extension/db/internal/domain/connection/derby/DerbyConnectionProvider.java
+++ b/src/main/java/org/mule/extension/db/internal/domain/connection/derby/DerbyConnectionProvider.java
@@ -25,6 +25,7 @@
 
 import org.mule.db.commons.api.exception.connection.DbError;
 import org.mule.db.commons.internal.domain.connection.DataSourceConfig;
+import org.mule.db.commons.internal.domain.connection.DataSourceConfigDbConnectionTracingMetadata;
 import org.mule.db.commons.internal.domain.connection.DbConnection;
 import org.mule.db.commons.internal.domain.connection.DbConnectionProvider;
 import org.mule.runtime.extension.api.annotation.Alias;
@@ -64,7 +65,8 @@ public java.util.Optional<DataSourceConfig> getDataSourceConfig() {
 
   @Override
   protected DbConnection createDbConnection(Connection connection) throws Exception {
-    return new DerbyConnection(connection, resolveCustomTypes(), super.getCacheQueryTemplateSize());
+    return new DerbyConnection(connection, resolveCustomTypes(), super.getCacheQueryTemplateSize(),
+                               new DataSourceConfigDbConnectionTracingMetadata(getDataSourceConfig().get()));
   }
 
   @Override
diff --git a/src/main/java/org/mule/extension/db/internal/domain/connection/generic/DbGenericConnectionProvider.java b/src/main/java/org/mule/extension/db/internal/domain/connection/generic/DbGenericConnectionProvider.java
index 306215754..1cfc4dfa8 100644
--- a/src/main/java/org/mule/extension/db/internal/domain/connection/generic/DbGenericConnectionProvider.java
+++ b/src/main/java/org/mule/extension/db/internal/domain/connection/generic/DbGenericConnectionProvider.java
@@ -10,6 +10,7 @@
 import static org.mule.runtime.api.meta.ExternalLibraryType.JAR;
 import static org.mule.db.commons.internal.domain.connection.DbConnectionProvider.DRIVER_FILE_NAME_PATTERN;
 
+import org.mule.db.commons.internal.domain.connection.DataSourceConfigDbConnectionTracingMetadata;
 import org.mule.db.commons.internal.domain.connection.DbConnection;
 import org.mule.db.commons.internal.domain.connection.generic.GenericConnectionProvider;
 import org.mule.db.commons.internal.domain.type.ResolvedDbType;
@@ -39,7 +40,8 @@ public class DbGenericConnectionProvider extends GenericConnectionProvider {
   @Override
   protected DbConnection createDbConnection(Connection connection) throws Exception {
     if (isOracle(connection)) {
-      return new OracleDbConnection(connection, resolveCustomTypes(), resolvedDbTypesCache, super.getCacheQueryTemplateSize());
+      return new OracleDbConnection(connection, resolveCustomTypes(), resolvedDbTypesCache, super.getCacheQueryTemplateSize(),
+                                    new DataSourceConfigDbConnectionTracingMetadata(getDataSourceConfig().get()));
     } else {
       return super.createDbConnection(connection);
     }
diff --git a/src/main/java/org/mule/extension/db/internal/domain/connection/mysql/MySqlConnectionProvider.java b/src/main/java/org/mule/extension/db/internal/domain/connection/mysql/MySqlConnectionProvider.java
index 319feaabc..0b70ddd48 100644
--- a/src/main/java/org/mule/extension/db/internal/domain/connection/mysql/MySqlConnectionProvider.java
+++ b/src/main/java/org/mule/extension/db/internal/domain/connection/mysql/MySqlConnectionProvider.java
@@ -23,6 +23,7 @@
 import org.mule.db.commons.api.exception.connection.DbError;
 import org.mule.db.commons.internal.domain.connection.DataSourceConfig;
 import org.mule.db.commons.internal.domain.connection.DbConnectionProvider;
+import org.mule.db.commons.internal.domain.connection.DbConnectionTracingMetadata;
 import org.mule.runtime.extension.api.annotation.Alias;
 import org.mule.runtime.extension.api.annotation.ExternalLib;
 import org.mule.runtime.extension.api.annotation.param.ParameterGroup;
@@ -72,4 +73,8 @@ public java.util.Optional<DbError> getDbVendorErrorType(SQLException e) {
     return empty();
   }
 
+  @Override
+  protected DbConnectionTracingMetadata getDbConnectionTracingMetadataFrom() {
+    return new MySqlConnectionTracingMetadata(mySqlParameters);
+  }
 }
diff --git a/src/main/java/org/mule/extension/db/internal/domain/connection/mysql/MySqlConnectionTracingMetadata.java b/src/main/java/org/mule/extension/db/internal/domain/connection/mysql/MySqlConnectionTracingMetadata.java
new file mode 100644
index 000000000..53f86f705
--- /dev/null
+++ b/src/main/java/org/mule/extension/db/internal/domain/connection/mysql/MySqlConnectionTracingMetadata.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
+ * The software in this package is published under the terms of the CPAL v1.0
+ * license, a copy of which has been included with this distribution in the
+ * LICENSE.txt file.
+ */
+package org.mule.extension.db.internal.domain.connection.mysql;
+
+import org.mule.db.commons.internal.domain.connection.DbConnectionTracingMetadata;
+
+import static org.mule.db.commons.internal.domain.connection.ConnectionTracingMetadataUtils.getPeerNameFrom;
+import static org.mule.db.commons.internal.domain.connection.ConnectionTracingMetadataUtils.getPeerTransportFrom;
+
+import static java.util.Optional.ofNullable;
+
+import java.util.Optional;
+
+public class MySqlConnectionTracingMetadata implements DbConnectionTracingMetadata {
+
+  public static final String MYSQL = "mysql";
+  private final MySqlConnectionParameters mySqlParameter;
+
+  public MySqlConnectionTracingMetadata(MySqlConnectionParameters mySqlParameters) {
+    this.mySqlParameter = mySqlParameters;
+  }
+
+  @Override
+  public String getDbSystem() {
+    return MYSQL;
+  }
+
+  @Override
+  public String getConnectionString() {
+    return mySqlParameter.getUrl();
+  }
+
+  @Override
+  public String getUser() {
+    return mySqlParameter.getUser();
+  }
+
+  @Override
+  public Optional<String> getPeerName() {
+    return ofNullable(getPeerNameFrom(mySqlParameter.getUrl()));
+  }
+
+  @Override
+  public Optional<String> getPeerTransport() {
+    return ofNullable(getPeerTransportFrom(mySqlParameter.getUrl()));
+  }
+}
diff --git a/src/main/java/org/mule/extension/db/internal/domain/connection/oracle/OracleDbConnection.java b/src/main/java/org/mule/extension/db/internal/domain/connection/oracle/OracleDbConnection.java
index a7ba6e61f..fea38ecce 100644
--- a/src/main/java/org/mule/extension/db/internal/domain/connection/oracle/OracleDbConnection.java
+++ b/src/main/java/org/mule/extension/db/internal/domain/connection/oracle/OracleDbConnection.java
@@ -26,6 +26,7 @@
 import org.mule.extension.db.internal.domain.connection.oracle.types.OracleSQLXMLType;
 import org.mule.extension.db.internal.domain.connection.oracle.types.OracleSYSXMLType;
 import org.mule.extension.db.internal.domain.connection.oracle.types.OracleXMLType;
+import org.mule.db.commons.internal.domain.connection.DbConnectionTracingMetadata;
 
 import java.sql.Array;
 import java.sql.Connection;
@@ -79,8 +80,9 @@ public class OracleDbConnection extends DefaultDbConnection {
 
 
   public OracleDbConnection(Connection jdbcConnection, List<DbType> customDataTypes,
-                            Map<String, Map<Integer, ResolvedDbType>> resolvedDbTypesCache, long cacheQueryTemplateSize) {
-    super(jdbcConnection, customDataTypes, cacheQueryTemplateSize);
+                            Map<String, Map<Integer, ResolvedDbType>> resolvedDbTypesCache, long cacheQueryTemplateSize,
+                            DbConnectionTracingMetadata dbConnectionTracingMetadata) {
+    super(jdbcConnection, customDataTypes, cacheQueryTemplateSize, dbConnectionTracingMetadata);
     this.resolvedDbTypesCache = resolvedDbTypesCache;
   }
 
diff --git a/src/main/java/org/mule/extension/db/internal/domain/connection/oracle/OracleDbConnectionProvider.java b/src/main/java/org/mule/extension/db/internal/domain/connection/oracle/OracleDbConnectionProvider.java
index 09ea28576..baa1dc6ad 100644
--- a/src/main/java/org/mule/extension/db/internal/domain/connection/oracle/OracleDbConnectionProvider.java
+++ b/src/main/java/org/mule/extension/db/internal/domain/connection/oracle/OracleDbConnectionProvider.java
@@ -7,10 +7,6 @@
 
 package org.mule.extension.db.internal.domain.connection.oracle;
 
-import static java.util.Optional.empty;
-import static java.util.Optional.of;
-import static java.util.Optional.ofNullable;
-
 import static org.mule.db.commons.api.exception.connection.DbError.CANNOT_REACH;
 import static org.mule.db.commons.api.exception.connection.DbError.INVALID_CREDENTIALS;
 import static org.mule.db.commons.api.exception.connection.DbError.INVALID_DATABASE;
@@ -21,6 +17,10 @@
 import static org.mule.runtime.extension.api.annotation.param.ParameterGroup.CONNECTION;
 import static org.mule.extension.db.internal.util.MigrationUtils.mapDataSourceConfig;
 
+import static java.util.Optional.empty;
+import static java.util.Optional.of;
+import static java.util.Optional.ofNullable;
+
 import javax.sql.DataSource;
 import java.sql.Connection;
 import java.sql.SQLException;
@@ -30,6 +30,7 @@
 
 import org.mule.db.commons.api.exception.connection.DbError;
 import org.mule.db.commons.internal.domain.connection.DataSourceConfig;
+import org.mule.db.commons.internal.domain.connection.DataSourceConfigDbConnectionTracingMetadata;
 import org.mule.db.commons.internal.domain.connection.DbConnection;
 import org.mule.db.commons.internal.domain.connection.DbConnectionProvider;
 import org.mule.db.commons.internal.domain.type.ResolvedDbType;
@@ -79,7 +80,8 @@ public java.util.Optional<DataSourceConfig> getDataSourceConfig() {
   @Override
   protected DbConnection createDbConnection(Connection connection) throws Exception {
     return new OracleDbConnection(connection, super.resolveCustomTypes(), resolvedDbTypesCache,
-                                  super.getCacheQueryTemplateSize());
+                                  super.getCacheQueryTemplateSize(),
+                                  new DataSourceConfigDbConnectionTracingMetadata(getDataSourceConfig().get()));
   }
 
   @Override
diff --git a/src/main/java/org/mule/extension/db/internal/domain/connection/sqlserver/SqlServerConnection.java b/src/main/java/org/mule/extension/db/internal/domain/connection/sqlserver/SqlServerConnection.java
index bb501c0d0..c43f59d9b 100644
--- a/src/main/java/org/mule/extension/db/internal/domain/connection/sqlserver/SqlServerConnection.java
+++ b/src/main/java/org/mule/extension/db/internal/domain/connection/sqlserver/SqlServerConnection.java
@@ -11,6 +11,7 @@
 import org.mule.extension.db.internal.domain.connection.sqlserver.types.SqlServerBinaryDbType;
 import org.mule.extension.db.internal.domain.connection.sqlserver.types.SqlServerVarBinaryDbType;
 import org.mule.db.commons.internal.domain.type.DbType;
+import org.mule.db.commons.internal.domain.connection.DbConnectionTracingMetadata;
 
 import java.sql.Connection;
 import java.util.ArrayList;
@@ -23,8 +24,9 @@
  */
 public class SqlServerConnection extends DefaultDbConnection {
 
-  SqlServerConnection(Connection jdbcConnection, List<DbType> customDataTypes, long cacheQueryTemplateSize) {
-    super(jdbcConnection, customDataTypes, cacheQueryTemplateSize);
+  SqlServerConnection(Connection jdbcConnection, List<DbType> customDataTypes, long cacheQueryTemplateSize,
+                      DbConnectionTracingMetadata dbConnectionTracingMetadata) {
+    super(jdbcConnection, customDataTypes, cacheQueryTemplateSize, dbConnectionTracingMetadata);
   }
 
   /**
diff --git a/src/main/java/org/mule/extension/db/internal/domain/connection/sqlserver/SqlServerConnectionProvider.java b/src/main/java/org/mule/extension/db/internal/domain/connection/sqlserver/SqlServerConnectionProvider.java
index a3b384554..522be45f7 100644
--- a/src/main/java/org/mule/extension/db/internal/domain/connection/sqlserver/SqlServerConnectionProvider.java
+++ b/src/main/java/org/mule/extension/db/internal/domain/connection/sqlserver/SqlServerConnectionProvider.java
@@ -23,8 +23,10 @@
 import javax.sql.DataSource;
 import java.sql.Connection;
 import java.sql.SQLException;
+
 import org.mule.db.commons.api.exception.connection.DbError;
 import org.mule.db.commons.internal.domain.connection.DataSourceConfig;
+import org.mule.db.commons.internal.domain.connection.DataSourceConfigDbConnectionTracingMetadata;
 import org.mule.db.commons.internal.domain.connection.DbConnection;
 import org.mule.db.commons.internal.domain.connection.DbConnectionProvider;
 import org.mule.runtime.extension.api.annotation.Alias;
@@ -56,7 +58,8 @@ public class SqlServerConnectionProvider extends DbConnectionProvider {
 
   @Override
   protected DbConnection createDbConnection(Connection connection) throws Exception {
-    return new SqlServerConnection(connection, super.resolveCustomTypes(), super.getCacheQueryTemplateSize());
+    return new SqlServerConnection(connection, super.resolveCustomTypes(), super.getCacheQueryTemplateSize(),
+                                   new DataSourceConfigDbConnectionTracingMetadata(getDataSourceConfig().get()));
   }
 
   @Override
diff --git a/src/main/java/org/mule/extension/db/internal/operation/DbBulkOperations.java b/src/main/java/org/mule/extension/db/internal/operation/DbBulkOperations.java
index 4a0c36c0a..a7296cc13 100644
--- a/src/main/java/org/mule/extension/db/internal/operation/DbBulkOperations.java
+++ b/src/main/java/org/mule/extension/db/internal/operation/DbBulkOperations.java
@@ -8,6 +8,7 @@
 
 import org.mule.db.commons.AbstractDbConnector;
 import org.mule.db.commons.internal.domain.connection.DbConnection;
+import org.mule.db.commons.internal.domain.connection.DbConnectionTracingMetadata;
 import org.mule.db.commons.internal.domain.metadata.DbInputMetadataResolver;
 import org.mule.db.commons.internal.operation.BulkOperations;
 import org.mule.db.commons.internal.operation.OperationErrorTypeProvider;
@@ -25,13 +26,20 @@
 import org.mule.extension.db.api.param.BulkQueryDefinition;
 import org.mule.extension.db.api.param.BulkScript;
 import org.mule.extension.db.api.param.QuerySettings;
+import org.mule.sdk.api.runtime.parameter.CorrelationInfo;
+import org.mule.sdk.compatibility.api.utils.ForwardCompatibilityHelper;
 
+import javax.inject.Inject;
 import java.sql.SQLException;
 import java.util.List;
 import java.util.Map;
 
+import static org.mule.db.commons.internal.domain.query.QueryType.DELETE;
+import static org.mule.db.commons.internal.domain.query.QueryType.INSERT;
+import static org.mule.db.commons.internal.domain.query.QueryType.UPDATE;
 import static org.mule.db.commons.internal.operation.BaseDbOperations.QUERY_GROUP;
 import static org.mule.db.commons.internal.operation.BaseDbOperations.QUERY_SETTINGS;
+import static org.mule.extension.db.internal.operation.tracing.TracingUtils.setAttributesForDbClientOperation;
 import static org.mule.extension.db.internal.util.MigrationUtils.mapBulkQueryDefinition;
 import static org.mule.extension.db.internal.util.MigrationUtils.mapBulkScript;
 import static org.mule.extension.db.internal.util.MigrationUtils.mapQuerySettings;
@@ -47,6 +55,9 @@ public class DbBulkOperations implements Initialisable {
 
   private BulkOperations bulkOperations;
 
+  @Inject
+  private java.util.Optional<ForwardCompatibilityHelper> forwardCompatibilityHelper;
+
   @Override
   public void initialise() throws InitialisationException {
     this.bulkOperations = new BulkOperations.Builder().build();
@@ -70,8 +81,16 @@ public int[] bulkInsert(@DisplayName("Input Parameters") @Content @Placement(
                           @ParameterGroup(name = QUERY_GROUP) BulkQueryDefinition query,
                           @Config AbstractDbConnector connector,
                           @Connection DbConnection connection,
+                          CorrelationInfo correlationInfo,
                           StreamingHelper streamingHelper)
       throws SQLException {
+    forwardCompatibilityHelper.ifPresent(fwh -> {
+      DbConnectionTracingMetadata dbConnectionTracingMetadata = connection.getDbConnectionTracingMetadata();
+      setAttributesForDbClientOperation(dbConnectionTracingMetadata,
+                                        dbConnectionTracingMetadata.getDbSystem(),
+                                        fwh.getDistributedTraceContextManager(correlationInfo),
+                                        query.getSql());
+    });
     return bulkOperations.bulkInsert(bulkInputParameters, mapBulkQueryDefinition(query), connector, connection, streamingHelper);
   }
 
@@ -94,8 +113,16 @@ public int[] bulkUpdate(@DisplayName("Input Parameters") @Content @Placement(
                           @ParameterGroup(name = QUERY_GROUP) BulkQueryDefinition query,
                           @Config AbstractDbConnector connector,
                           @Connection DbConnection connection,
+                          CorrelationInfo correlationInfo,
                           StreamingHelper streamingHelper)
       throws SQLException {
+    forwardCompatibilityHelper.ifPresent(fwh -> {
+      DbConnectionTracingMetadata dbConnectionTracingMetadata = connection.getDbConnectionTracingMetadata();
+      setAttributesForDbClientOperation(dbConnectionTracingMetadata,
+                                        UPDATE.name() + " " + dbConnectionTracingMetadata.getDbSystem(),
+                                        fwh.getDistributedTraceContextManager(correlationInfo),
+                                        query.getSql());
+    });
     return bulkOperations.bulkUpdate(bulkInputParameters, mapBulkQueryDefinition(query), connector, connection, streamingHelper);
   }
 
@@ -117,8 +144,16 @@ public int[] bulkDelete(@DisplayName("Input Parameters") @Content @Placement(
                           @ParameterGroup(name = QUERY_GROUP) BulkQueryDefinition query,
                           @Config AbstractDbConnector connector,
                           @Connection DbConnection connection,
+                          CorrelationInfo correlationInfo,
                           StreamingHelper streamingHelper)
       throws SQLException {
+    forwardCompatibilityHelper.ifPresent(fwh -> {
+      DbConnectionTracingMetadata dbConnectionTracingMetadata = connection.getDbConnectionTracingMetadata();
+      setAttributesForDbClientOperation(dbConnectionTracingMetadata,
+                                        DELETE.name() + " " + dbConnectionTracingMetadata.getDbSystem(),
+                                        fwh.getDistributedTraceContextManager(correlationInfo),
+                                        query.getSql());
+    });
     return bulkOperations.bulkDelete(bulkInputParameters, mapBulkQueryDefinition(query), connector, connection, streamingHelper);
   }
 
@@ -135,8 +170,16 @@ public int[] bulkDelete(@DisplayName("Input Parameters") @Content @Placement(
    */
   public int[] executeScript(@ParameterGroup(name = QUERY_GROUP) BulkScript script,
                              @ParameterGroup(name = QUERY_SETTINGS) QuerySettings settings,
-                             @Connection DbConnection connection)
+                             @Connection DbConnection connection,
+                             CorrelationInfo correlationInfo)
       throws SQLException {
+    forwardCompatibilityHelper.ifPresent(fwh -> {
+      DbConnectionTracingMetadata dbConnectionTracingMetadata = connection.getDbConnectionTracingMetadata();
+      setAttributesForDbClientOperation(dbConnectionTracingMetadata,
+                                        dbConnectionTracingMetadata.getDbSystem(),
+                                        fwh.getDistributedTraceContextManager(correlationInfo),
+                                        "<script>");
+    });
     return bulkOperations.executeScript(mapBulkScript(script), mapQuerySettings(settings), connection);
   }
 
diff --git a/src/main/java/org/mule/extension/db/internal/operation/DbDmlOperations.java b/src/main/java/org/mule/extension/db/internal/operation/DbDmlOperations.java
index 33b75318c..b15694bc0 100644
--- a/src/main/java/org/mule/extension/db/internal/operation/DbDmlOperations.java
+++ b/src/main/java/org/mule/extension/db/internal/operation/DbDmlOperations.java
@@ -9,6 +9,7 @@
 import org.mule.db.commons.AbstractDbConnector;
 
 import org.mule.db.commons.internal.domain.connection.DbConnection;
+import org.mule.db.commons.internal.domain.connection.DbConnectionTracingMetadata;
 import org.mule.db.commons.internal.domain.metadata.QuerySingleMetadataResolver;
 import org.mule.db.commons.internal.domain.metadata.SelectMetadataResolver;
 import org.mule.db.commons.internal.domain.metadata.StoredProcedureMetadataResolver;
@@ -30,17 +31,25 @@
 import org.mule.runtime.extension.api.runtime.operation.FlowListener;
 import org.mule.runtime.extension.api.runtime.streaming.PagingProvider;
 import org.mule.runtime.extension.api.runtime.streaming.StreamingHelper;
+import org.mule.sdk.api.runtime.parameter.CorrelationInfo;
+import org.mule.sdk.api.runtime.source.DistributedTraceContextManager;
+import org.mule.sdk.compatibility.api.utils.ForwardCompatibilityHelper;
 
+import javax.inject.Inject;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 
-import static org.mule.extension.db.internal.util.MigrationUtils.mapQueryDefinition;
-import static org.mule.extension.db.internal.util.MigrationUtils.mapStoredProcedureCall;
 import static org.mule.db.commons.internal.domain.autogeneratedkey.AutoGenerateKeysAttributes.AUTO_GENERATE_KEYS;
+import static org.mule.db.commons.internal.domain.query.QueryType.DELETE;
+import static org.mule.db.commons.internal.domain.query.QueryType.INSERT;
+import static org.mule.db.commons.internal.domain.query.QueryType.UPDATE;
 import static org.mule.db.commons.internal.operation.BaseDbOperations.QUERY_GROUP;
+import static org.mule.extension.db.internal.operation.tracing.TracingUtils.setAttributesForDbClientOperation;
+import static org.mule.extension.db.internal.util.MigrationUtils.mapQueryDefinition;
+import static org.mule.extension.db.internal.util.MigrationUtils.mapStoredProcedureCall;
 import static org.mule.runtime.extension.api.annotation.param.display.Placement.ADVANCED_TAB;
 
 /**
@@ -58,6 +67,9 @@ public void initialise() throws InitialisationException {
     dmlOperations = new DmlOperations.Builder().build();
   }
 
+  @Inject
+  private java.util.Optional<ForwardCompatibilityHelper> forwardCompatibilityHelper;
+
   /**
    * Selects data from a database.
    *
@@ -75,6 +87,7 @@ public PagingProvider<DbConnection, Map<String, Object>> select(
                                                                       tab = ADVANCED_TAB) QueryDefinition query,
                                                                   @Config AbstractDbConnector connector,
                                                                   StreamingHelper streamingHelper,
+                                                                  CorrelationInfo correlationInfo,
                                                                   FlowListener flowListener)
       throws SQLException {
     return dmlOperations.select(mapQueryDefinition(query), connector, streamingHelper, flowListener);
@@ -96,8 +109,22 @@ public PagingProvider<DbConnection, Map<String, Object>> select(
   @OutputResolver(output = QuerySingleMetadataResolver.class)
   public Map<String, Object> querySingle(@ParameterGroup(name = QUERY_GROUP) @Placement(
       tab = ADVANCED_TAB) QueryDefinition query, @Config AbstractDbConnector connector, @Connection DbConnection connection,
+                                         CorrelationInfo correlationInfo,
                                          StreamingHelper streamingHelper)
       throws SQLException {
+
+    forwardCompatibilityHelper.ifPresent(fwh -> {
+      DbConnectionTracingMetadata dbConnectionTracingMetadata = connection.getDbConnectionTracingMetadata();
+      // We set the name because it is the most generic operation.
+      // We follow the semantic conventions in this part:
+      // "It is not recommended to attempt any client-side parsing of db.statement just to get these properties,
+      // they should only be used if the library being instrumented already provides them. When it?s otherwise
+      // impossible to get any meaningful span name, db.name or the tech-specific database name MAY be used."
+      setAttributesForDbClientOperation(dbConnectionTracingMetadata,
+                                        dbConnectionTracingMetadata.getDbSystem(),
+                                        fwh.getDistributedTraceContextManager(correlationInfo),
+                                        query.getSql());
+    });
     return dmlOperations.querySingle(mapQueryDefinition(query), connector, connection, streamingHelper);
   }
 
@@ -116,8 +143,16 @@ public StatementResult insert(@ParameterGroup(name = QUERY_GROUP) @Placement(tab
                                     name = AUTO_GENERATE_KEYS) DbAutoGenerateKeysAttributes autoGenerateKeysAttributes,
                                 @Config AbstractDbConnector connector,
                                 @Connection DbConnection connection,
+                                CorrelationInfo correlationInfo,
                                 StreamingHelper streamingHelper)
       throws SQLException {
+    forwardCompatibilityHelper.ifPresent(fwh -> {
+      DbConnectionTracingMetadata dbConnectionTracingMetadata = connection.getDbConnectionTracingMetadata();
+      setAttributesForDbClientOperation(dbConnectionTracingMetadata,
+                                        INSERT.name() + " " + dbConnectionTracingMetadata.getDbSystem(),
+                                        fwh.getDistributedTraceContextManager(correlationInfo),
+                                        query.getSql());
+    });
     return new StatementResult(dmlOperations.insert(mapQueryDefinition(query), autoGenerateKeysAttributes, connector, connection,
                                                     streamingHelper));
   }
@@ -137,8 +172,16 @@ public StatementResult update(@ParameterGroup(name = QUERY_GROUP) QueryDefinitio
                                     name = AUTO_GENERATE_KEYS) DbAutoGenerateKeysAttributes autoGenerateKeysAttributes,
                                 @Config AbstractDbConnector connector,
                                 @Connection DbConnection connection,
+                                CorrelationInfo correlationInfo,
                                 StreamingHelper streamingHelper)
       throws SQLException {
+    forwardCompatibilityHelper.ifPresent(fwh -> {
+      DbConnectionTracingMetadata dbConnectionTracingMetadata = connection.getDbConnectionTracingMetadata();
+      setAttributesForDbClientOperation(dbConnectionTracingMetadata,
+                                        UPDATE.name() + " " + dbConnectionTracingMetadata.getDbSystem(),
+                                        fwh.getDistributedTraceContextManager(correlationInfo),
+                                        query.getSql());
+    });
     return new StatementResult(dmlOperations.update(mapQueryDefinition(query), autoGenerateKeysAttributes, connector, connection,
                                                     streamingHelper));
 
@@ -156,8 +199,16 @@ public StatementResult update(@ParameterGroup(name = QUERY_GROUP) QueryDefinitio
   public int delete(@ParameterGroup(name = QUERY_GROUP) QueryDefinition query,
                     @Config AbstractDbConnector connector,
                     @Connection DbConnection connection,
+                    CorrelationInfo correlationInfo,
                     StreamingHelper streamingHelper)
       throws SQLException {
+    forwardCompatibilityHelper.ifPresent(fwh -> {
+      DbConnectionTracingMetadata dbConnectionTracingMetadata = connection.getDbConnectionTracingMetadata();
+      setAttributesForDbClientOperation(dbConnectionTracingMetadata,
+                                        DELETE.name() + " " + dbConnectionTracingMetadata.getDbSystem(),
+                                        fwh.getDistributedTraceContextManager(correlationInfo),
+                                        query.getSql());
+    });
     return dmlOperations.delete(mapQueryDefinition(query), connector, connection, streamingHelper);
   }
 
@@ -183,8 +234,16 @@ public Map<String, Object> storedProcedure(@ParameterGroup(name = QUERY_GROUP) S
                                              @Config AbstractDbConnector connector,
                                              @Connection DbConnection connection,
                                              StreamingHelper streamingHelper,
+                                             CorrelationInfo correlationInfo,
                                              FlowListener flowListener)
       throws SQLException {
+    forwardCompatibilityHelper.ifPresent(fwh -> {
+      DbConnectionTracingMetadata dbConnectionTracingMetadata = connection.getDbConnectionTracingMetadata();
+      setAttributesForDbClientOperation(dbConnectionTracingMetadata,
+                                        dbConnectionTracingMetadata.getDbSystem(),
+                                        fwh.getDistributedTraceContextManager(correlationInfo),
+                                        call.getSql());
+    });
     return dmlOperations.storedProcedure(mapStoredProcedureCall(call), autoGenerateKeysAttributes, connector, connection,
                                          streamingHelper, flowListener);
   }
diff --git a/src/main/java/org/mule/extension/db/internal/operation/tracing/TracingUtils.java b/src/main/java/org/mule/extension/db/internal/operation/tracing/TracingUtils.java
new file mode 100644
index 000000000..6986f9df4
--- /dev/null
+++ b/src/main/java/org/mule/extension/db/internal/operation/tracing/TracingUtils.java
@@ -0,0 +1,184 @@
+/*
+ * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
+ * The software in this package is published under the terms of the CPAL v1.0
+ * license, a copy of which has been included with this distribution in the
+ * LICENSE.txt file.
+ */
+package org.mule.extension.db.internal.operation.tracing;
+
+import org.mule.db.commons.internal.domain.connection.DbConnectionTracingMetadata;
+import org.mule.sdk.api.runtime.source.DistributedTraceContextManager;
+import org.slf4j.Logger;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+import static org.slf4j.LoggerFactory.getLogger;
+
+/**
+ * Utils for runtime tracing.
+ */
+public class TracingUtils {
+
+  public static final String SPAN_KIND_CLIENT_NAME = "CLIENT";
+
+  private static final Logger LOGGER = getLogger(TracingUtils.class);
+  static final String SPAN_KIND = "span.kind.override";
+  static final String DB_CONNECTION_STRING_KEY = "db.connection_string";
+  static final String DB_SYSTEM_KEY = "db.system";
+  static final String DB_USER_KEY = "db.user";
+  static final String NET_PEER_NAME_KEY = "net.peer.name";
+  static final String DB_STATEMENT = "db.statement";
+
+  /**
+   * It sets the attributes for the db client operation corresponding
+   * to the semantic conventions for Optel.
+   *
+   * @link <a href="https://opentelemetry.io/docs/reference/specification/trace/semantic_conventions/database/">Semantic conventions for database client calls</a>
+   *
+   * @param dbConnectionTracingMetadata dbConnectionTracingMetadata the metadata from the tracing connection to get information for the span.
+   * @param spanName the updated name of the current span
+   * @param distributedTraceContextManager the {@link DistributedTraceContextManager} to communicate with the runtime.
+   * @param query the query string for the operation.
+   */
+  public static void setAttributesForDbClientOperation(DbConnectionTracingMetadata dbConnectionTracingMetadata,
+                                                       String spanName,
+                                                       DistributedTraceContextManager distributedTraceContextManager,
+                                                       String query) {
+    try {
+      // We set the name because it is the most generic operation.
+      // We follow the semantic conventions in this part:
+      // "It is not recommended to attempt any client-side parsing of db.statement just to get these properties,
+      // they should only be used if the library being instrumented already provides them. When it?s otherwise
+      // impossible to get any meaningful span name, db.name or the tech-specific database name MAY be used."
+      traceDbClientOperation(spanName,
+                             distributedTraceContextManager,
+                             dbConnectionTracingMetadata,
+                             query);
+    } catch (Throwable e) {
+      LOGGER.warn("Exception on adding span attributes", e);
+    }
+  }
+
+  private static void traceDbClientOperation(String spanName, DistributedTraceContextManager distributedTraceContextManager,
+                                             DbConnectionTracingMetadata dbConnectionTracingMetadata, String sqlQuery) {
+    distributedTraceContextManager.setCurrentSpanName(spanName);
+    distributedTraceContextManager.addCurrentSpanAttributes(new LazySpanAttributesMap(sqlQuery, dbConnectionTracingMetadata));
+  }
+
+  /**
+   * A lazy span attributes map to not affect the performance of the operations.
+   */
+
+  private final static class LazySpanAttributesMap implements Map<String, String> {
+
+    private final DbConnectionTracingMetadata dbConnectionTracingMetadata;
+
+    private final String sqlQuery;
+
+    private Map<String, String> delegate;
+
+    public LazySpanAttributesMap(String sqlQuery, DbConnectionTracingMetadata dbConnectionTracingMetadata) {
+      this.sqlQuery = sqlQuery;
+      this.dbConnectionTracingMetadata = dbConnectionTracingMetadata;
+    }
+
+    @Override
+    public int size() {
+      if (delegate == null) {
+        delegate = createDelegateMap();
+      }
+      return delegate.size();
+    }
+
+    private Map<String, String> createDelegateMap() {
+      Map<String, String> delegate = new HashMap<>();
+      delegate.put(DB_STATEMENT, sqlQuery);
+      delegate.put(DB_CONNECTION_STRING_KEY, dbConnectionTracingMetadata.getConnectionString());
+      delegate.put(DB_SYSTEM_KEY, dbConnectionTracingMetadata.getDbSystem());
+      delegate.put(DB_USER_KEY, dbConnectionTracingMetadata.getUser());
+      dbConnectionTracingMetadata.getPeerName()
+          .ifPresent(peerName -> delegate.put(NET_PEER_NAME_KEY, peerName));
+      delegate.put(SPAN_KIND, SPAN_KIND_CLIENT_NAME);
+      return delegate;
+    }
+
+    @Override
+    public boolean isEmpty() {
+      if (delegate == null) {
+        delegate = createDelegateMap();
+      }
+      return delegate.isEmpty();
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+      if (delegate == null) {
+        delegate = createDelegateMap();
+      }
+      return delegate.containsKey(key);
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+      if (delegate == null) {
+        delegate = createDelegateMap();
+      }
+      return delegate.containsValue(value);
+    }
+
+    @Override
+    public String get(Object key) {
+      if (delegate == null) {
+        delegate = createDelegateMap();
+      }
+      return delegate.get(key);
+    }
+
+    @Override
+    public String put(String key, String value) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public String remove(Object key) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void putAll(Map<? extends String, ? extends String> m) {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void clear() {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public Set<String> keySet() {
+      if (delegate == null) {
+        delegate = createDelegateMap();
+      }
+      return delegate.keySet();
+    }
+
+    @Override
+    public Collection<String> values() {
+      if (delegate == null) {
+        delegate = createDelegateMap();
+      }
+      return delegate.values();
+    }
+
+    @Override
+    public Set<Entry<String, String>> entrySet() {
+      if (delegate == null) {
+        delegate = createDelegateMap();
+      }
+      return delegate.entrySet();
+    }
+  }
+}
diff --git a/src/test/java/org/mule/extension/db/internal/AbstractDbFunctionTestCase.java b/src/test/java/org/mule/extension/db/internal/AbstractDbFunctionTestCase.java
index 705309f99..92818792b 100644
--- a/src/test/java/org/mule/extension/db/internal/AbstractDbFunctionTestCase.java
+++ b/src/test/java/org/mule/extension/db/internal/AbstractDbFunctionTestCase.java
@@ -49,7 +49,7 @@ DefaultDbConnection mockDefaultDbConnectionMetadata(Connection delegate, int dat
     when(resultSet.getString(ATTR_TYPE_NAME_INDEX)).thenReturn(dataTypeName);
     when(metadata.getAttributes("catalog", null, TYPE_NAME, null)).thenReturn(resultSet);
 
-    return new DefaultDbConnection(delegate, new ArrayList<>(), 1000);
+    return new DefaultDbConnection(delegate, new ArrayList<>(), 1000, null);
   }
 
 }
diff --git a/src/test/java/org/mule/extension/db/internal/OracleCreateArrayTestCase.java b/src/test/java/org/mule/extension/db/internal/OracleCreateArrayTestCase.java
index 1a5da42ac..9988897d2 100644
--- a/src/test/java/org/mule/extension/db/internal/OracleCreateArrayTestCase.java
+++ b/src/test/java/org/mule/extension/db/internal/OracleCreateArrayTestCase.java
@@ -126,7 +126,8 @@ private void testThroughOracleQuery(Connection delegate, Object[] values, String
     when(resultSet.getInt(ATTR_NO_PARAM)).thenReturn(1);
     when(resultSet.getString(ATTR_TYPE_NAME_PARAM)).thenReturn(dataTypeName);
 
-    OracleDbConnection oracleConnection = new OracleDbConnection(delegate, new ArrayList<>(), new ConcurrentHashMap<>(), 100);
+    OracleDbConnection oracleConnection =
+        new OracleDbConnection(delegate, new ArrayList<>(), new ConcurrentHashMap<>(), 100, null);
 
     oracleConnection.createArray(udtName, values);
 
diff --git a/src/test/java/org/mule/extension/db/internal/OracleCreateStructTestCase.java b/src/test/java/org/mule/extension/db/internal/OracleCreateStructTestCase.java
index 42ae8b912..770e82c24 100644
--- a/src/test/java/org/mule/extension/db/internal/OracleCreateStructTestCase.java
+++ b/src/test/java/org/mule/extension/db/internal/OracleCreateStructTestCase.java
@@ -90,7 +90,8 @@ private void testThroughOracleQuery(Connection delegate, Object[] structValues,
     when(resultSet.getInt(ATTR_NO_PARAM)).thenReturn(1);
     when(resultSet.getString(ATTR_TYPE_NAME_PARAM)).thenReturn(dataTypeName);
 
-    OracleDbConnection oracleConnection = new OracleDbConnection(delegate, new ArrayList<>(), new ConcurrentHashMap<>(), 100);
+    OracleDbConnection oracleConnection =
+        new OracleDbConnection(delegate, new ArrayList<>(), new ConcurrentHashMap<>(), 100, null);
 
     oracleConnection.createStruct(udtName, structValues);
 
diff --git a/src/test/java/org/mule/extension/db/internal/domain/connection/OracleDbConnectionTestCase.java b/src/test/java/org/mule/extension/db/internal/domain/connection/OracleDbConnectionTestCase.java
index 46f28a790..5f761da5e 100644
--- a/src/test/java/org/mule/extension/db/internal/domain/connection/OracleDbConnectionTestCase.java
+++ b/src/test/java/org/mule/extension/db/internal/domain/connection/OracleDbConnectionTestCase.java
@@ -80,7 +80,7 @@ public void lobResolutionPerformance() throws Exception {
     when(resultSet.next()).thenReturn(true).thenReturn(false).thenReturn(true).thenReturn(false);
     when(resultSet.getString(ATTR_TYPE_NAME_PARAM)).thenReturn(USER_TYPE_DBNAME);
 
-    OracleDbConnection cnx = new OracleDbConnection(delegate, Collections.emptyList(), dbTypeCache, 1000);
+    OracleDbConnection cnx = new OracleDbConnection(delegate, Collections.emptyList(), dbTypeCache, 1000, null);
     cnx.createArray(USER_TYPE_NAME, params);
     assertThat(dbTypeCache.containsKey(USER_TYPE_NAME), is(true));
     assertThat(dbTypeCache.get(USER_TYPE_NAME).get(0).getName(), is(USER_TYPE_DBNAME));
@@ -98,7 +98,7 @@ public void lobResolutionPerformance() throws Exception {
     when(resultSet.next()).thenReturn(true).thenReturn(false).thenReturn(true).thenReturn(false);
     when(resultSet.getString(ATTR_TYPE_NAME_PARAM)).thenReturn(USER_TYPE_DBNAME);
 
-    cnx = new OracleDbConnection(delegate, Collections.emptyList(), dbTypeCache, 100);
+    cnx = new OracleDbConnection(delegate, Collections.emptyList(), dbTypeCache, 100, null);
     cnx.createArray(USER_TYPE_NAME, params);
 
     assertThat(dbTypeCache.containsKey(USER_TYPE_NAME), is(true));
@@ -119,7 +119,7 @@ public void lobResolutionPerformance() throws Exception {
     when(resultSet.next()).thenReturn(true).thenReturn(false).thenReturn(true).thenReturn(false);
     when(resultSet.getString(ATTR_TYPE_NAME_PARAM)).thenReturn(USER_TYPE_DBNAME_B);
 
-    cnx = new OracleDbConnection(delegate, Collections.emptyList(), dbTypeCache, 100);
+    cnx = new OracleDbConnection(delegate, Collections.emptyList(), dbTypeCache, 100, null);
     cnx.createArray(USER_TYPE_NAME_B, params);
 
     assertThat(dbTypeCache.containsKey(USER_TYPE_NAME_B), is(true));
@@ -140,7 +140,7 @@ public void getTablesClosesTheStatement() throws SQLException {
     when(resultSet.next()).thenReturn(false);
 
     Map<String, Map<Integer, ResolvedDbType>> dbTypeCache = new ConcurrentHashMap<>();
-    OracleDbConnection cnx = new OracleDbConnection(delegate, Collections.emptyList(), dbTypeCache, 1000);
+    OracleDbConnection cnx = new OracleDbConnection(delegate, Collections.emptyList(), dbTypeCache, 1000, null);
 
     cnx.getTables();
 
diff --git a/src/test/java/org/mule/extension/db/internal/operation/tracing/TracingUtilsTestCase.java b/src/test/java/org/mule/extension/db/internal/operation/tracing/TracingUtilsTestCase.java
new file mode 100644
index 000000000..dac296540
--- /dev/null
+++ b/src/test/java/org/mule/extension/db/internal/operation/tracing/TracingUtilsTestCase.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) MuleSoft, Inc.  All rights reserved.  http://www.mulesoft.com
+ * The software in this package is published under the terms of the CPAL v1.0
+ * license, a copy of which has been included with this distribution in the
+ * LICENSE.txt file.
+ */
+package org.mule.extension.db.internal.operation.tracing;
+
+import static org.mule.extension.db.internal.operation.tracing.TracingUtils.DB_CONNECTION_STRING_KEY;
+import static org.mule.extension.db.internal.operation.tracing.TracingUtils.DB_STATEMENT;
+import static org.mule.extension.db.internal.operation.tracing.TracingUtils.DB_SYSTEM_KEY;
+import static org.mule.extension.db.internal.operation.tracing.TracingUtils.DB_USER_KEY;
+import static org.mule.extension.db.internal.operation.tracing.TracingUtils.NET_PEER_NAME_KEY;
+import static org.mule.extension.db.internal.operation.tracing.TracingUtils.SPAN_KIND;
+import static org.mule.extension.db.internal.operation.tracing.TracingUtils.SPAN_KIND_CLIENT_NAME;
+import static org.mule.extension.db.internal.operation.tracing.TracingUtils.setAttributesForDbClientOperation;
+
+import static java.util.Optional.of;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.aMapWithSize;
+import static org.hamcrest.Matchers.hasEntry;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import static org.mockito.Mockito.verify;
+
+import org.mule.db.commons.internal.domain.connection.DbConnectionTracingMetadata;
+import org.mule.sdk.api.runtime.source.DistributedTraceContextManager;
+
+import java.util.Map;
+
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+
+public class TracingUtilsTestCase {
+
+  public static final String TEST_SPAN_NAME = "test_span_name";
+  public static final String TEST_QUERY = "test_query";
+  public static final String TEST_CONNECTION_STRING = "connection_string";
+  public static final String TEST_DB_SYSTEM = "db_system";
+  public static final String TEST_PEER_NAME = "peer_name";
+  public static final String TEST_USER = "user";
+
+  @Test
+  public void tracingSemanticConventionAttributes() {
+    DbConnectionTracingMetadata dbConnectionTracingMetadata = mock(DbConnectionTracingMetadata.class);
+    DistributedTraceContextManager distributedTraceContext = mock(DistributedTraceContextManager.class);
+    when(dbConnectionTracingMetadata.getConnectionString()).thenReturn(TEST_CONNECTION_STRING);
+    when(dbConnectionTracingMetadata.getDbSystem()).thenReturn(TEST_DB_SYSTEM);
+    when(dbConnectionTracingMetadata.getPeerName()).thenReturn(of(TEST_PEER_NAME));
+    when(dbConnectionTracingMetadata.getUser()).thenReturn(TEST_USER);
+    setAttributesForDbClientOperation(dbConnectionTracingMetadata, TEST_SPAN_NAME, distributedTraceContext, TEST_QUERY);
+    verify(distributedTraceContext).setCurrentSpanName(any());
+    ArgumentCaptor<Map<String, String>> argumentCaptor = ArgumentCaptor.forClass(Map.class);
+    verify(distributedTraceContext).addCurrentSpanAttributes(argumentCaptor.capture());
+    Map<String, String> attributes = argumentCaptor.getValue();
+    assertThat(attributes, aMapWithSize(6));
+    assertThat(attributes, hasEntry(DB_CONNECTION_STRING_KEY, TEST_CONNECTION_STRING));
+    assertThat(attributes, hasEntry(SPAN_KIND, SPAN_KIND_CLIENT_NAME));
+    assertThat(attributes, hasEntry(DB_SYSTEM_KEY, TEST_DB_SYSTEM));
+    assertThat(attributes, hasEntry(DB_USER_KEY, TEST_USER));
+    assertThat(attributes, hasEntry(NET_PEER_NAME_KEY, TEST_PEER_NAME));
+    assertThat(attributes, hasEntry(DB_STATEMENT, TEST_QUERY));
+  }
+
+  @Test
+  public void failsafeAttributesPropagation() {
+    DbConnectionTracingMetadata dbConnectionTracingMetadata = mock(DbConnectionTracingMetadata.class);
+    DistributedTraceContextManager distributedTraceContext = mock(DistributedTraceContextManager.class);
+    setAttributesForDbClientOperation(dbConnectionTracingMetadata, TEST_SPAN_NAME, distributedTraceContext, TEST_QUERY);
+
+  }
+}