address review comment

Author: laurit

instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/db/internal/SqlCommenter.java

@@ -36,13 +36,24 @@ public static SqlCommenter noop() {
     return builder().build();
   }
 
-  public String processQuery(Object connection, String sql, boolean safe) {
+  /**
+   * Augments the given SQL query with comment containing tracing context.
+   *
+   * @param connection connection object, e.g. JDBC connection or R2DBC connection, that is used to
+   *     execute the query
+   * @param sql original query
+   * @param executed whether the query is immediately executed after being processed, e.g. {@link
+   *     java.sql.Statement#execute(String)}, or may be executed later, e.g. {@link
+   *     java.sql.Connection#prepareStatement(String)}
+   * @return modified query
+   */
+  public String processQuery(Object connection, String sql, boolean executed) {
     if (!enabled) {
       return sql;
     }
 
     return SqlCommenterUtil.processQuery(
-        sql, propagator.apply(connection, safe), prepend.test(connection));
+        sql, propagator.apply(connection, executed), prepend.test(connection));
   }
 
   public boolean isEnabled() {

instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/db/internal/SqlCommenterBuilder.java

@@ -70,11 +70,11 @@ public SqlCommenterBuilder setPropagator(TextMapPropagator propagator) {
    * Context propagator.
    *
    * @param propagator a function that receives the database connection and whether the query is
-   *     executed only once or could be reused. Connection may be a jdbc Connection, R2DBC
-   *     Connection, or any other connection type used by the data access framework performing the
+   *     executed only once or could be reused. Connection may be a JDBC connection, R2DBC
+   *     connection, or any other connection type used by the data access framework performing the
    *     operation. If the second argument to the function is true, the query is executed only once
-   *     (e.g. JDBC {@link Statement#execute(String)}). If false, the query could be reused (e.g.
-   *     JDBC {@link Connection#prepareStatement(String)}).
+   *     (e.g. JDBC {@link Statement#execute(String)}) immediately after processing. If false, the
+   *     query could be reused (e.g. JDBC {@link Connection#prepareStatement(String)}).
    */
   @CanIgnoreReturnValue
   public SqlCommenterBuilder setPropagator(

instrumentation-api-incubator/src/main/java/io/opentelemetry/instrumentation/api/incubator/semconv/db/internal/SqlCommenterUtil.java

@@ -17,7 +17,7 @@
 final class SqlCommenterUtil {
 
   /**
-   * Append comment containing tracing information at the end of the query. See <a
+   * Append comment containing tracing information to the query. See <a
    * href="https://google.github.io/sqlcommenter/spec/">sqlcommenter</a> for the description of the
    * algorithm.
    */

instrumentation/jdbc/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jdbc/ConnectionInstrumentation.java

@@ -104,7 +104,7 @@ public static Object[] processSql(
       Context context = Java8BytecodeBridge.currentContext();
       if (PrepareContext.get(context) == null) {
         // process sql only in the outermost prepare call and save the original sql in context
-        String processSql = JdbcSingletons.processSql(connection, sql, true);
+        String processSql = JdbcSingletons.processSql(connection, sql, false);
         Scope scope = PrepareContext.init(context, sql).makeCurrent();
         return new Object[] {processSql, scope};
       } else {

instrumentation/jdbc/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jdbc/JdbcSingletons.java

@@ -114,19 +114,19 @@ private static SqlCommenter configureSqlCommenter() {
     return builder.build();
   }
 
-  public static String processSql(Statement statement, String sql, boolean safe) {
+  public static String processSql(Statement statement, String sql, boolean executed) {
     Connection connection;
     try {
       connection = statement.getConnection();
     } catch (SQLException exception) {
       // connection was already closed
       return sql;
     }
-    return processSql(connection, sql, safe);
+    return processSql(connection, sql, executed);
   }
 
-  public static String processSql(Connection connection, String sql, boolean safe) {
-    return SQL_COMMENTER.processQuery(connection, sql, safe);
+  public static String processSql(Connection connection, String sql, boolean executed) {
+    return SQL_COMMENTER.processQuery(connection, sql, executed);
   }
 
   private JdbcSingletons() {}

instrumentation/jdbc/javaagent/src/main/java/io/opentelemetry/javaagent/instrumentation/jdbc/StatementInstrumentation.java

@@ -69,7 +69,7 @@ public static Object[] onEnter(
         return new Object[] {null, sql};
       }
 
-      String processedSql = JdbcSingletons.processSql(statement, sql, false);
+      String processedSql = JdbcSingletons.processSql(statement, sql, true);
       return new Object[] {
         JdbcAdviceScope.startStatement(CallDepth.forClass(Statement.class), sql, statement),
         processedSql
@@ -101,7 +101,7 @@ public static String addBatch(
       }
 
       JdbcData.addStatementBatch(statement, sql);
-      return JdbcSingletons.processSql(statement, sql, false);
+      return JdbcSingletons.processSql(statement, sql, true);
     }
   }
 

instrumentation/jdbc/library/src/main/java/io/opentelemetry/instrumentation/jdbc/internal/OpenTelemetryStatement.java

@@ -71,7 +71,7 @@ class OpenTelemetryStatement<S extends Statement> implements Statement {
   }
 
   private String processQuery(String sql) {
-    return sqlCommenter.processQuery(connection.delegate, sql, false);
+    return sqlCommenter.processQuery(connection.delegate, sql, true);
   }
 
   @Override

instrumentation/r2dbc-1.0/library/src/main/java/io/opentelemetry/instrumentation/r2dbc/v1_0/internal/R2dbcSqlCommenterUtil.java

@@ -30,7 +30,7 @@ public static void configure(ProxyConfig proxyConfig, SqlCommenter sqlCommenter)
           public String onCreateStatement(String query, StatementInfo info) {
             Connection connection =
                 unwapConnection(info.getConnectionInfo().getOriginalConnection());
-            String modifiedQuery = sqlCommenter.processQuery(connection, query, true);
+            String modifiedQuery = sqlCommenter.processQuery(connection, query, false);
             if (!modifiedQuery.equals(query)) {
               // We store mapping from the modified query to original query on the connection
               // the assumption here is that since the connection is not thread safe it won't be