Support including Module and Action in each JDBC session with Oracle JDBC

data-connection-hibernate/src/main/java/io/micronaut/data/hibernate/connection/HibernateConnectionOperations.java

@@ -22,12 +22,16 @@
 import io.micronaut.data.connection.ConnectionDefinition;
 import io.micronaut.data.connection.ConnectionStatus;
 import io.micronaut.data.connection.support.AbstractConnectionOperations;
+import io.micronaut.data.connection.support.ConnectionListener;
+import io.micronaut.data.connection.support.DefaultConnectionStatus;
 import io.micronaut.data.hibernate.conf.RequiresSyncHibernate;
 import org.hibernate.Interceptor;
 import org.hibernate.Session;
 import org.hibernate.SessionBuilder;
 import org.hibernate.SessionFactory;
 
+import java.util.List;
+
 /**
  * The Hibernate connection operations.
  *
@@ -45,26 +49,28 @@ public final class HibernateConnectionOperations extends AbstractConnectionOpera
     private final Interceptor entityInterceptor;
 
     public HibernateConnectionOperations(SessionFactory sessionFactory,
-                                         @Nullable Interceptor entityInterceptor) {
+                                         @Nullable Interceptor entityInterceptor,
+                                         List<ConnectionListener<Session>> connectionListeners) {
+        super(connectionListeners);
         this.sessionFactory = sessionFactory;
         this.entityInterceptor = entityInterceptor;
     }
 
     @Override
-    protected Session openConnection(ConnectionDefinition definition) {
+    protected ConnectionStatus<Session> doOpenConnection(ConnectionDefinition definition) {
         SessionBuilder sessionBuilder = sessionFactory.withOptions();
         if (entityInterceptor != null) {
             sessionBuilder = sessionBuilder.interceptor(entityInterceptor);
         }
-        return sessionBuilder.openSession();
+        return new DefaultConnectionStatus<>(sessionBuilder.openSession(), definition, true);
     }
 
     @Override
     protected void setupConnection(ConnectionStatus<Session> connectionStatus) {
     }
 
     @Override
-    protected void closeConnection(ConnectionStatus<Session> connectionStatus) {
+    protected void doCloseConnection(ConnectionStatus<Session> connectionStatus) {
         connectionStatus.getConnection().close();
     }
 

data-connection-jdbc/src/main/java/io/micronaut/data/connection/jdbc/operations/DefaultDataSourceConnectionOperations.java

@@ -24,6 +24,8 @@
 import io.micronaut.data.connection.ConnectionStatus;
 import io.micronaut.data.connection.ConnectionSynchronization;
 import io.micronaut.data.connection.support.AbstractConnectionOperations;
+import io.micronaut.data.connection.support.ConnectionListener;
+import io.micronaut.data.connection.support.DefaultConnectionStatus;
 import io.micronaut.data.connection.support.JdbcConnectionUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -47,22 +49,28 @@ public final class DefaultDataSourceConnectionOperations extends AbstractConnect
     private static final Logger LOG = LoggerFactory.getLogger(DefaultDataSourceConnectionOperations.class);
     private final DataSource dataSource;
 
-    DefaultDataSourceConnectionOperations(DataSource dataSource) {
+    DefaultDataSourceConnectionOperations(DataSource dataSource,
+                                          List<ConnectionListener<Connection>> connectionListeners) {
+        super(connectionListeners);
         this.dataSource = DelegatingDataSource.unwrapDataSource(dataSource);
     }
 
     @Override
-    protected Connection openConnection(ConnectionDefinition definition) {
+    protected ConnectionStatus<Connection> doOpenConnection(ConnectionDefinition definition) {
+        Connection connection;
         try {
-            return dataSource.getConnection();
+            connection = dataSource.getConnection();
         } catch (SQLException e) {
             throw new CannotGetJdbcConnectionException("Failed to obtain JDBC Connection", e);
         }
+
+        return new DefaultConnectionStatus<>(connection, definition, true);
     }
 
     @Override
     protected void setupConnection(ConnectionStatus<Connection> connectionStatus) {
-        connectionStatus.getDefinition().isReadOnly().ifPresent(readOnly -> {
+        ConnectionDefinition connectionDefinition = connectionStatus.getDefinition();
+        connectionDefinition.isReadOnly().ifPresent(readOnly -> {
             List<Runnable> onCompleteCallbacks = new ArrayList<>(1);
             JdbcConnectionUtils.applyReadOnly(LOG, connectionStatus.getConnection(), readOnly, onCompleteCallbacks);
             if (!onCompleteCallbacks.isEmpty()) {
@@ -79,12 +87,12 @@ public void executionComplete() {
     }
 
     @Override
-    protected void closeConnection(ConnectionStatus<Connection> connectionStatus) {
+    protected void doCloseConnection(ConnectionStatus<Connection> connectionStatus) {
+        Connection connection = connectionStatus.getConnection();
         try {
-            connectionStatus.getConnection().close();
+            connection.close();
         } catch (SQLException e) {
             throw new ConnectionException("Failed to close the connection: " + e.getMessage(), e);
         }
     }
-
 }

data-connection-jdbc/src/main/java/io/micronaut/data/connection/jdbc/oracle/OracleClientInfoCustomizerCondition.java

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2017-2024 original authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.micronaut.data.connection.jdbc.oracle;
+
+import io.micronaut.context.BeanResolutionContext;
+import io.micronaut.context.Qualifier;
+import io.micronaut.context.condition.Condition;
+import io.micronaut.context.condition.ConditionContext;
+import io.micronaut.core.annotation.Internal;
+import io.micronaut.core.naming.Named;
+import io.micronaut.inject.BeanDefinition;
+
+/**
+ * A condition that determines whether to customize Oracle client information based on configuration properties.
+ *
+ * This condition checks if the data source dialect is set to Oracle and if the 'customize-oracle-client-info' property is enabled.
+ *
+ * @author radovanradic
+ * @since 4.10
+ */
+@Internal
+final class OracleClientInfoCustomizerCondition implements Condition {
+
+    static final String DATASOURCES = "datasources";
+    private static final Character DOT = '.';
+    private static final String DIALECT = "dialect";
+    private static final String ORACLE_CLIENT_INFO_ENABLED = "customize-oracle-client-info";
+    private static final String ORACLE_DIALECT = "ORACLE";
+
+    @Override
+    public boolean matches(ConditionContext context) {
+        BeanResolutionContext beanResolutionContext = context.getBeanResolutionContext();
+        String dataSourceName;
+        if (beanResolutionContext == null) {
+            return true;
+        } else {
+            Qualifier<?> currentQualifier = beanResolutionContext.getCurrentQualifier();
+            if (currentQualifier == null && context.getComponent() instanceof BeanDefinition<?> definition) {
+                currentQualifier = definition.getDeclaredQualifier();
+            }
+            if (currentQualifier instanceof Named named) {
+                dataSourceName = named.getName();
+            } else {
+                dataSourceName = "default";
+            }
+        }
+
+        String dialectProperty = DATASOURCES + DOT + dataSourceName + DOT + DIALECT;
+        String dialect = context.getProperty(dialectProperty, String.class).orElse(null);
+        if (!ORACLE_DIALECT.equalsIgnoreCase(dialect)) {
+            return false;
+        }
+
+        String property = DATASOURCES + DOT + dataSourceName + DOT + ORACLE_CLIENT_INFO_ENABLED;
+        return context.getProperty(property, Boolean.class, false);
+    }
+}

data-connection-jdbc/src/main/java/io/micronaut/data/connection/jdbc/oracle/OracleClientInfoCustomizerConnectionListener.java

@@ -0,0 +1,151 @@
+/*
+ * Copyright 2017-2024 original authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.micronaut.data.connection.jdbc.oracle;
+
+import io.micronaut.context.annotation.EachBean;
+import io.micronaut.context.annotation.Requires;
+import io.micronaut.core.annotation.Internal;
+import io.micronaut.core.annotation.NonNull;
+import io.micronaut.core.util.StringUtils;
+import io.micronaut.data.connection.ConnectionDefinition;
+import io.micronaut.data.connection.ConnectionStatus;
+import io.micronaut.data.connection.support.ConnectionClientInfoDetails;
+import io.micronaut.data.connection.support.ConnectionListener;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.sql.DataSource;
+import java.sql.Connection;
+import java.sql.SQLClientInfoException;
+import java.sql.SQLException;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * A customizer for Oracle database connections that sets client information after opening and clears before closing.
+ *
+ * This customizer checks if the connection is an Oracle database connection and then sets the client information
+ * (client ID, module, and action) after opening the connection. It also clears these properties before closing the connection.
+ *
+ * @author radovanradic
+ * @since 4.10
+ */
+@EachBean(DataSource.class)
+@Requires(condition = OracleClientInfoCustomizerCondition.class)
+@Internal
+final class OracleClientInfoCustomizerConnectionListener implements ConnectionListener<Connection> {
+
+    /**
+     * Constant for the Oracle connection client info client ID property name.
+     */
+    private static final String ORACLE_CLIENT_ID = "OCSID.CLIENTID";
+    /**
+     * Constant for the Oracle connection client info module property name.
+     */
+    private static final String ORACLE_MODULE = "OCSID.MODULE";
+    /**
+     * Constant for the Oracle connection client info action property name.
+     */
+    private static final String ORACLE_ACTION = "OCSID.ACTION";
+    /**
+     * Constant for the Oracle connection database product name.
+     */
+    private static final String ORACLE_CONNECTION_DATABASE_PRODUCT_NAME = "Oracle";
+    private static final List<String> RESERVED_CLIENT_INFO_NAMES = List.of(ORACLE_CLIENT_ID, ORACLE_MODULE, ORACLE_ACTION);
+
+    private static final Logger LOG = LoggerFactory.getLogger(OracleClientInfoCustomizerConnectionListener.class);
+
+    private final Map<Connection, Boolean> connectionSupportedMap = new ConcurrentHashMap<>(20);
+
+    @Override
+    public boolean supportsConnection(@NonNull ConnectionStatus<Connection> connectionStatus) {
+        return connectionSupportedMap.computeIfAbsent(connectionStatus.getConnection(), this::isOracleConnection);
+    }
+
+    @Override
+    public void afterOpen(@NonNull ConnectionStatus<Connection> connectionStatus) {
+        ConnectionDefinition connectionDefinition = connectionStatus.getDefinition();
+        // Set client info for connection if Oracle connection after connection is opened
+        ConnectionClientInfoDetails connectionClientInfo = connectionDefinition.connectionClientInfo();
+        if (connectionClientInfo != null) {
+            Connection connection = connectionStatus.getConnection();
+            LOG.trace("Setting connection tracing info to the Oracle connection");
+            try {
+                if (connectionClientInfo.appName() != null) {
+                    connection.setClientInfo(ORACLE_CLIENT_ID, connectionClientInfo.appName());
+                }
+                connection.setClientInfo(ORACLE_MODULE, connectionClientInfo.module());
+                connection.setClientInfo(ORACLE_ACTION, connectionClientInfo.action());
+                for (Map.Entry<String, String> additionalInfo : connectionClientInfo.connectionClientInfoAttributes().entrySet()) {
+                    String name = additionalInfo.getKey();
+                    if (RESERVED_CLIENT_INFO_NAMES.contains(name)) {
+                        LOG.debug("Connection client info attribute {} already set. Skip setting value from the arbitrary attributes.", name);
+                    } else {
+                        String value = additionalInfo.getValue();
+                        connection.setClientInfo(name, value);
+                    }
+                }
+            } catch (SQLClientInfoException e) {
+                LOG.debug("Failed to set connection tracing info", e);
+            }
+        }
+    }
+
+    @Override
+    public void beforeClose(@NonNull ConnectionStatus<Connection> connectionStatus) {
+        // Clear client info for connection if it was Oracle connection and client info was set previously
+        ConnectionDefinition connectionDefinition = connectionStatus.getDefinition();
+        ConnectionClientInfoDetails connectionClientInfo = connectionDefinition.connectionClientInfo();
+        if (connectionClientInfo != null) {
+            try {
+                Connection connection = connectionStatus.getConnection();
+                connection.setClientInfo(ORACLE_CLIENT_ID, null);
+                connection.setClientInfo(ORACLE_MODULE, null);
+                connection.setClientInfo(ORACLE_ACTION, null);
+                for (Map.Entry<String, String> additionalInfo : connectionClientInfo.connectionClientInfoAttributes().entrySet()) {
+                    String name = additionalInfo.getKey();
+                    if (!RESERVED_CLIENT_INFO_NAMES.contains(name)) {
+                        connection.setClientInfo(name, null);
+                    }
+                }
+            } catch (SQLClientInfoException e) {
+                LOG.debug("Failed to clear connection tracing info", e);
+            }
+        }
+    }
+
+    @Override
+    public String getName() {
+        return "Oracle Connection Client Info Customizer";
+    }
+
+    /**
+     * Checks whether current connection is Oracle database connection.
+     *
+     * @param connection The connection
+     * @return true if current connection is Oracle database connection
+     */
+    private boolean isOracleConnection(Connection connection) {
+        try {
+            String databaseProductName = connection.getMetaData().getDatabaseProductName();
+            return StringUtils.isNotEmpty(databaseProductName) && databaseProductName.equalsIgnoreCase(ORACLE_CONNECTION_DATABASE_PRODUCT_NAME);
+        } catch (SQLException e) {
+            LOG.debug("Failed to get database product name from the connection", e);
+            return false;
+        }
+    }
+}

data-connection/src/main/java/io/micronaut/data/connection/ConnectionDefinition.java

@@ -18,6 +18,7 @@
 
 import io.micronaut.core.annotation.NonNull;
 import io.micronaut.core.annotation.Nullable;
+import io.micronaut.data.connection.support.ConnectionClientInfoDetails;
 
 import java.time.Duration;
 import java.util.Optional;
@@ -101,6 +102,15 @@ enum Propagation {
     @Nullable
     String getName();
 
+    /**
+     * Returns the connection client information associated with this connection definition.
+     * If no connection client information has been set, this method will return null.
+     *
+     * @return An instance of {@link ConnectionClientInfoDetails} representing the connection client information, or null if not set.
+     * @since 4.10
+     */
+    @Nullable ConnectionClientInfoDetails connectionClientInfo();
+
     /**
      * Connection definition with specific propagation.
      * @param propagation The new propagation