001    /*
002     * Licensed to the Apache Software Foundation (ASF) under one or more
003     * contributor license agreements. See the NOTICE file distributed with
004     * this work for additional information regarding copyright ownership.
005     * The ASF licenses this file to You under the Apache license, Version 2.0
006     * (the "License"); you may not use this file except in compliance with
007     * the License. You may obtain a copy of the License at
008     *
009     *      http://www.apache.org/licenses/LICENSE-2.0
010     *
011     * Unless required by applicable law or agreed to in writing, software
012     * distributed under the License is distributed on an "AS IS" BASIS,
013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014     * See the license for the specific language governing permissions and
015     * limitations under the license.
016     */
017    package org.apache.logging.log4j.core.appender.db.jdbc;
018    
019    import java.io.StringReader;
020    import java.sql.Connection;
021    import java.sql.DatabaseMetaData;
022    import java.sql.PreparedStatement;
023    import java.sql.SQLException;
024    import java.sql.Timestamp;
025    import java.util.ArrayList;
026    import java.util.List;
027    
028    import org.apache.logging.log4j.core.LogEvent;
029    import org.apache.logging.log4j.core.appender.AppenderLoggingException;
030    import org.apache.logging.log4j.core.appender.ManagerFactory;
031    import org.apache.logging.log4j.core.appender.db.AbstractDatabaseManager;
032    import org.apache.logging.log4j.core.layout.PatternLayout;
033    import org.apache.logging.log4j.core.util.Closer;
034    
035    /**
036     * An {@link AbstractDatabaseManager} implementation for relational databases accessed via JDBC.
037     */
038    public final class JdbcDatabaseManager extends AbstractDatabaseManager {
039    
040        private static final JdbcDatabaseManagerFactory INSTANCE = new JdbcDatabaseManagerFactory();
041    
042        private final List<Column> columns;
043        private final ConnectionSource connectionSource;
044        private final String sqlStatement;
045    
046        private Connection connection;
047        private PreparedStatement statement;
048        private boolean isBatchSupported;
049    
050        private JdbcDatabaseManager(final String name, final int bufferSize, final ConnectionSource connectionSource,
051                                    final String sqlStatement, final List<Column> columns) {
052            super(name, bufferSize);
053            this.connectionSource = connectionSource;
054            this.sqlStatement = sqlStatement;
055            this.columns = columns;
056        }
057    
058        @Override
059        protected void startupInternal() throws Exception {
060            this.connection = this.connectionSource.getConnection();
061            final DatabaseMetaData metaData = this.connection.getMetaData();
062            this.isBatchSupported = metaData.supportsBatchUpdates();
063            Closer.closeSilently(this.connection);
064        }
065    
066        @Override
067        protected void shutdownInternal() {
068            if (this.connection != null || this.statement != null) {
069                this.commitAndClose();
070            }
071        }
072    
073        @Override
074        protected void connectAndStart() {
075            try {
076                this.connection = this.connectionSource.getConnection();
077                this.connection.setAutoCommit(false);
078                this.statement = this.connection.prepareStatement(this.sqlStatement);
079            } catch (final SQLException e) {
080                throw new AppenderLoggingException(
081                        "Cannot write logging event or flush buffer; JDBC manager cannot connect to the database.", e
082                );
083            }
084        }
085    
086        @Override
087        protected void writeInternal(final LogEvent event) {
088            StringReader reader = null;
089            try {
090                if (!this.isRunning() || this.connection == null || this.connection.isClosed() || this.statement == null
091                        || this.statement.isClosed()) {
092                    throw new AppenderLoggingException(
093                            "Cannot write logging event; JDBC manager not connected to the database.");
094                }
095    
096                int i = 1;
097                for (final Column column : this.columns) {
098                    if (column.isEventTimestamp) {
099                        this.statement.setTimestamp(i++, new Timestamp(event.getTimeMillis()));
100                    } else {
101                        if (column.isClob) {
102                            reader = new StringReader(column.layout.toSerializable(event));
103                            if (column.isUnicode) {
104                                this.statement.setNClob(i++, reader);
105                            } else {
106                                this.statement.setClob(i++, reader);
107                            }
108                        } else {
109                            if (column.isUnicode) {
110                                this.statement.setNString(i++, column.layout.toSerializable(event));
111                            } else {
112                                this.statement.setString(i++, column.layout.toSerializable(event));
113                            }
114                        }
115                    }
116                }
117    
118                if (this.isBatchSupported) {
119                    this.statement.addBatch();
120                } else if (this.statement.executeUpdate() == 0) {
121                    throw new AppenderLoggingException(
122                            "No records inserted in database table for log event in JDBC manager.");
123                }
124            } catch (final SQLException e) {
125                throw new AppenderLoggingException("Failed to insert record for log event in JDBC manager: " +
126                        e.getMessage(), e);
127            } finally {
128                Closer.closeSilently(reader);
129            }
130        }
131    
132        @Override
133        protected void commitAndClose() {
134            try {
135                if (this.connection != null && !this.connection.isClosed()) {
136                    if (this.isBatchSupported) {
137                        this.statement.executeBatch();
138                    }
139                    this.connection.commit();
140                }
141            } catch (final SQLException e) {
142                throw new AppenderLoggingException("Failed to commit transaction logging event or flushing buffer.", e);
143            } finally {
144                try {
145                    Closer.close(this.statement);
146                } catch (final Exception e) {
147                    LOGGER.warn("Failed to close SQL statement logging event or flushing buffer.", e);
148                } finally {
149                    this.statement = null;
150                }
151    
152                try {
153                    Closer.close(this.connection);
154                } catch (final Exception e) {
155                    LOGGER.warn("Failed to close database connection logging event or flushing buffer.", e);
156                } finally {
157                    this.connection = null;
158                }
159            }
160        }
161    
162        /**
163         * Creates a JDBC manager for use within the {@link JdbcAppender}, or returns a suitable one if it already exists.
164         *
165         * @param name The name of the manager, which should include connection details and hashed passwords where possible.
166         * @param bufferSize The size of the log event buffer.
167         * @param connectionSource The source for connections to the database.
168         * @param tableName The name of the database table to insert log events into.
169         * @param columnConfigs Configuration information about the log table columns.
170         * @return a new or existing JDBC manager as applicable.
171         */
172        public static JdbcDatabaseManager getJDBCDatabaseManager(final String name, final int bufferSize,
173                                                                 final ConnectionSource connectionSource,
174                                                                 final String tableName,
175                                                                 final ColumnConfig[] columnConfigs) {
176    
177            return AbstractDatabaseManager.getManager(
178                    name, new FactoryData(bufferSize, connectionSource, tableName, columnConfigs), getFactory()
179            );
180        }
181    
182        private static JdbcDatabaseManagerFactory getFactory() {
183            return INSTANCE;
184        }
185    
186        /**
187         * Encapsulates data that {@link JdbcDatabaseManagerFactory} uses to create managers.
188         */
189        private static final class FactoryData extends AbstractDatabaseManager.AbstractFactoryData {
190            private final ColumnConfig[] columnConfigs;
191            private final ConnectionSource connectionSource;
192            private final String tableName;
193    
194            protected FactoryData(final int bufferSize, final ConnectionSource connectionSource, final String tableName,
195                                  final ColumnConfig[] columnConfigs) {
196                super(bufferSize);
197                this.connectionSource = connectionSource;
198                this.tableName = tableName;
199                this.columnConfigs = columnConfigs;
200            }
201        }
202    
203        /**
204         * Creates managers.
205         */
206        private static final class JdbcDatabaseManagerFactory implements ManagerFactory<JdbcDatabaseManager, FactoryData> {
207            @Override
208            public JdbcDatabaseManager createManager(final String name, final FactoryData data) {
209                final StringBuilder columnPart = new StringBuilder();
210                final StringBuilder valuePart = new StringBuilder();
211                final List<Column> columns = new ArrayList<Column>();
212                int i = 0;
213                for (final ColumnConfig config : data.columnConfigs) {
214                    if (i++ > 0) {
215                        columnPart.append(',');
216                        valuePart.append(',');
217                    }
218    
219                    columnPart.append(config.getColumnName());
220    
221                    if (config.getLiteralValue() != null) {
222                        valuePart.append(config.getLiteralValue());
223                    } else {
224                        columns.add(new Column(
225                                config.getLayout(), config.isEventTimestamp(), config.isUnicode(), config.isClob()
226                        ));
227                        valuePart.append('?');
228                    }
229                }
230    
231                final String sqlStatement = "INSERT INTO " + data.tableName + " (" + columnPart + ") VALUES (" +
232                        valuePart + ')';
233    
234                return new JdbcDatabaseManager(name, data.getBufferSize(), data.connectionSource, sqlStatement, columns);
235            }
236        }
237    
238        /**
239         * Encapsulates information about a database column and how to persist data to it.
240         */
241        private static final class Column {
242            private final PatternLayout layout;
243            private final boolean isEventTimestamp;
244            private final boolean isUnicode;
245            private final boolean isClob;
246    
247            private Column(final PatternLayout layout, final boolean isEventDate, final boolean isUnicode,
248                           final boolean isClob) {
249                this.layout = layout;
250                this.isEventTimestamp = isEventDate;
251                this.isUnicode = isUnicode;
252                this.isClob = isClob;
253            }
254        }
255    }