since: 6.0.15 -

 public JDBCAccessLogValve() 
{
        super();
        driverName = null;
        connectionURL = null;
        tableName = "access";
        remoteHostField = "remoteHost";
        userField = "userName";
        timestampField = "timestamp";
        virtualHostField = "virtualHost";
        methodField = "method";
        queryField = "query";
        statusField = "status";
        bytesField = "bytes";
        refererField = "referer";
        userAgentField = "userAgent";
        pattern = "common";
        resolveHosts = false;
        conn = null;
        ps = null;
        currentTimeMillis = new java.util.Date().getTime();
}

Class constructor. Initializes the fields with the default values. The defaults are:

driverName = null;
connectionURL = null;
tableName = "access";
remoteHostField = "remoteHost";
userField = "userName";
timestampField = "timestamp";
virtualHostField = "virtualHost";
methodField = "method";
queryField = "query";
statusField = "status";
bytesField = "bytes";
refererField = "referer";
userAgentField = "userAgent";
pattern = "common";
resolveHosts = false;

 public  void addLifecycleListener(LifecycleListener listener) 
{
        lifecycle.addLifecycleListener(listener);
}

Adds a Lifecycle listener.

 protected  void close() 
{
        // Do nothing if the database connection is already closed
        if (conn == null)
            return;
        // Close our prepared statements (if any)
        try {
            ps.close();
        } catch (Throwable f) {
            ;
        }
        this.ps = null;
        // Close this database connection, and log any errors
        try {
            conn.close();
        } catch (SQLException e) {
            container.getLogger().error(sm.getString("jdbcAccessLogValeve.close"), e); // Just log it here            
        } finally {
           this.conn = null;
        }
}

Close the specified database connection.

 public LifecycleListener[] findLifecycleListeners() 
{
        return lifecycle.findLifecycleListeners();
}

Get the lifecycle listeners associated with this lifecycle. If this Lifecycle has no listeners registered, a zero-length array is returned.

 public String getConnectionName() 
{
    // ------------------------------------------------------------- Properties
        return connectionName;
}

Return the username to use to connect to the database.

 public String getConnectionPassword() 
{
        return connectionPassword;
}

Return the password to use to connect to the database.

 public long getCurrentTimeMillis() 
{
        long systime  =  System.currentTimeMillis();
        if ((systime - currentTimeMillis)  > 1000) {
            currentTimeMillis  =  new java.util.Date(systime).getTime();
        }
        return currentTimeMillis;
}

 public boolean getUseLongContentLength() 
{
        return this.useLongContentLength ;
}

get useLongContentLength

 public  void invoke(Request request,
    Response response) throws IOException, ServletException 
{
        final String EMPTY = "" ;
        getNext().invoke(request, response);
        String remoteHost = EMPTY;
        if(resolveHosts)
            remoteHost = request.getRemoteHost();
        else
            remoteHost = request.getRemoteAddr();
        String user = EMPTY;
        if(request != null)
            user = request.getRemoteUser();
        String query="";
        if(request != null)
            query = request.getRequestURI();
        long bytes = response.getContentCountLong() ;
        if(bytes <  0)
            bytes = 0;
        int status = response.getStatus();
        String virtualHost = EMPTY;
        String method = EMPTY;
        String referer = EMPTY;
        String userAgent = EMPTY;
        if (pattern.equals("combined") && request != null) {
            virtualHost = request.getServerName();
            method = request.getMethod();
            referer = request.getHeader("referer");
            userAgent = request.getHeader("user-agent");
        }
        synchronized (this) {
          int numberOfTries = 2;
          while (numberOfTries >0) {
            try {
                open();
                ps.setString(1, remoteHost);
                ps.setString(2, user);
                ps.setTimestamp(3, new Timestamp(getCurrentTimeMillis()));
                ps.setString(4, query);
                ps.setInt(5, status);
                if(useLongContentLength) {
                    ps.setLong(6, bytes);                
                } else {
                    if (bytes  > Integer.MAX_VALUE)
                        bytes = -1 ;
                    ps.setInt(6, (int) bytes);
                }               
                if (pattern.equals("combined")) {
                      ps.setString(7, virtualHost);
                      ps.setString(8, method);
                      ps.setString(9, referer);
                      ps.setString(10, userAgent);
                }
                ps.executeUpdate();
                return;
              } catch (SQLException e) {
                // Log the problem for posterity
                  container.getLogger().error(sm.getString("jdbcAccessLogValve.exception"), e);
                // Close the connection so that it gets reopened next time
                if (conn != null)
                    close();
              }
              numberOfTries--;
           }
        }
}

This method is invoked by Tomcat on each query.

 protected  void open() throws SQLException 
{
        // Do nothing if there is a database connection already open
        if (conn != null)
            return ;
        // Instantiate our database driver if necessary
        if (driver == null) {
            try {
                Class clazz = Class.forName(driverName);
                driver = (Driver) clazz.newInstance();
            } catch (Throwable e) {
                throw new SQLException(e.getMessage());
            }
        }
        // Open a new connection
        Properties props = new Properties();
        props.put("autoReconnect", "true");
        if (connectionName != null)
            props.put("user", connectionName);
        if (connectionPassword != null)
            props.put("password", connectionPassword);
        conn = driver.connect(connectionURL, props);
        conn.setAutoCommit(true);
        if (pattern.equals("common")) {
                ps = conn.prepareStatement
                    ("INSERT INTO " + tableName + " (" 
                     + remoteHostField + ", " + userField + ", "
                     + timestampField +", " + queryField + ", "
                     + statusField + ", " + bytesField 
                     + ") VALUES(?, ?, ?, ?, ?, ?)");
        } else if (pattern.equals("combined")) {
                ps = conn.prepareStatement
                    ("INSERT INTO " + tableName + " (" 
                     + remoteHostField + ", " + userField + ", "
                     + timestampField + ", " + queryField + ", " 
                     + statusField + ", " + bytesField + ", " 
                     + virtualHostField + ", " + methodField + ", "
                     + refererField + ", " + userAgentField
                     + ") VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
        }
}

Open (if necessary) and return a database connection for use by this AccessLogValve.

 public  void removeLifecycleListener(LifecycleListener listener) 
{
        lifecycle.removeLifecycleListener(listener);
}

Removes a Lifecycle listener.

 public  void setBytesField(String bytesField) 
{
        this.bytesField = bytesField;
}

Sets the name of the field containing the number of bytes returned.

 public  void setConnectionName(String connectionName) 
{
        this.connectionName = connectionName;
}

Set the username to use to connect to the database.

 public  void setConnectionPassword(String connectionPassword) 
{
        this.connectionPassword = connectionPassword;
}

Set the password to use to connect to the database.

 public  void setConnectionURL(String connectionURL) 
{
        this.connectionURL = connectionURL;
}

Sets the JDBC URL for the database where the log is stored.

 public  void setDriverName(String driverName) 
{
        this.driverName = driverName;
}

Sets the database driver name.

 public  void setMethodField(String methodField) 
{
        this.methodField = methodField;
}

Sets the name of the field containing the HTTP request method.

 public  void setPattern(String pattern) 
{
        this.pattern = pattern;
}

Sets the logging pattern. The patterns supported correspond to the file-based "common" and "combined". These are translated into the use of tables containing either set of fields.

TO DO: more flexible field choices.

 public  void setQueryField(String queryField) 
{
        this.queryField = queryField;
}

Sets the name of the field containing the URL part of the HTTP query.

 public  void setRefererField(String refererField) 
{
        this.refererField = refererField;
}

Sets the name of the field containing the referer.

 public  void setRemoteHostField(String remoteHostField) 
{
        this.remoteHostField = remoteHostField;
}

Sets the name of the field containing the remote host.

 public  void setResolveHosts(String resolveHosts) 
{
        this.resolveHosts = new Boolean(resolveHosts).booleanValue();
}

Determines whether IP host name resolution is done.

 public  void setStatusField(String statusField) 
{
        this.statusField = statusField;
}

Sets the name of the field containing the HTTP response status code.

 public  void setTableName(String tableName) 
{
        this.tableName = tableName;
}

Sets the name of the table where the logs are stored.

 public  void setTimestampField(String timestampField) 
{
        this.timestampField = timestampField;
}

Sets the name of the field containing the server-determined timestamp.

 public  void setUseLongContentLength(boolean useLongContentLength) 
{
        this.useLongContentLength = useLongContentLength;
}

 public  void setUserAgentField(String userAgentField) 
{
        this.userAgentField = userAgentField;
}

Sets the name of the field containing the user agent.

 public  void setUserField(String userField) 
{
        this.userField = userField;
}

Sets the name of the field containing the remote user name.

 public  void setVirtualHostField(String virtualHostField) 
{
        this.virtualHostField = virtualHostField;
}

Sets the name of the field containing the virtual host information (this is in fact the server name).

 public  void start() throws LifecycleException 
{
        if (started)
            throw new LifecycleException
                (sm.getString("accessLogValve.alreadyStarted"));
        lifecycle.fireLifecycleEvent(START_EVENT, null);
        started = true;
        try {
            open() ;        
        } catch (SQLException e) {
            throw new LifecycleException(e);
        }
}

Invoked by Tomcat on startup. The database connection is set here.

 public  void stop() throws LifecycleException 
{
        if (!started)
            throw new LifecycleException
                (sm.getString("accessLogValve.notStarted"));
        lifecycle.fireLifecycleEvent(STOP_EVENT, null);
        started = false;
        close() ;
}

Invoked by tomcat on shutdown. The database connection is closed here.