#770

Committed 12 Sep 2024 03:28PM UTC coverage: 90.35% (-0.9%) from 91.21%

Build # #770

Build Type

push

Committed by

Commit Message

 Enable per-SQL-ID log suppression (#322) (#332)

* 各Logger用のインタフェースを作成し必要なクラスがimplementsするように修正。そのうえでSLF4J 2.xのAPIを利用するように変更（性能改善）

* Changed to use slf4j v2.0 API
Also added suppressLogging API

* Refactoring log-related class and method names.

Run Details

384 of 587 new or added lines in 32 files covered. (65.42%)

9 existing lines in 7 files now uncovered.

8885 of 9834 relevant lines covered (90.35%)

0.9 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

70.89

/src/main/java/jp/co/future/uroborosql/event/subscriber/DebugEventSubscriber.java

/**
 * Copyright (c) 2017-present, Future Corporation
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */
package jp.co.future.uroborosql.event.subscriber;

import java.sql.SQLException;

import org.slf4j.Logger;

import jp.co.future.uroborosql.event.AfterBeginTransactionEvent;
import jp.co.future.uroborosql.event.AfterGetOutParameterEvent;
import jp.co.future.uroborosql.event.AfterSqlBatchEvent;
import jp.co.future.uroborosql.event.AfterSqlQueryEvent;
import jp.co.future.uroborosql.event.AfterSqlUpdateEvent;
import jp.co.future.uroborosql.event.BeforeEndTransactionEvent;
import jp.co.future.uroborosql.event.BeforeSetParameterEvent;
import jp.co.future.uroborosql.log.support.EventLoggingSupport;

/**
 * デバッグログを出力するEventSubscriber
 *
 * @author H.Sugimoto
 * @since v1.0.0
 */
public class DebugEventSubscriber extends EventSubscriber implements EventLoggingSupport {
        /** ロガー */
        private static final Logger EVENT_LOG = EventLoggingSupport.getEventLogger("debug");

        @Override
        public void initialize() {
                afterBeginTransactionListener(this::afterBeginTransaction);
                beforeEndTransactionListener(this::beforeEndTransaction);
                beforeSetParameterListener(this::beforeSetParameter);
                afterGetOutParameterListener(this::afterGetOutParameter);
                afterSqlQueryListener(this::afterSqlQuery);
                afterSqlUpdateListener(this::afterSqlUpdate);
                afterSqlBatchListener(this::afterSqlBatch);
        }

        void afterBeginTransaction(final AfterBeginTransactionEvent evt) {
                try {
                        debugWith(EVENT_LOG)
                                        .setMessage("Begin Transaction - connection:{}, requiredNew:{}, transactionLevel:{}, occurredOn:{}")
                                        .addArgument(evt.getTransactionContext().getConnection())
                                        .addArgument(evt.isRequiredNew())
                                        .addArgument(evt.getTransactionLevel())
                                        .addArgument(evt.occurredOn())
                                        .log();
                } catch (SQLException ex) {
                        errorWith(EVENT_LOG)
                                        .setMessage(ex.getMessage())
                                        .setCause(ex)
                                        .log();
                }
        }

        void beforeEndTransaction(final BeforeEndTransactionEvent evt) {
                try {
                        debugWith(EVENT_LOG)
                                        .setMessage(
                                                        "End Transaction - connection:{}, requiredNew:{}, transactionLevel:{}, result:{}, occurredOn:{}")
                                        .addArgument(evt.getTransactionContext().getConnection())
                                        .addArgument(evt.isRequiredNew())
                                        .addArgument(evt.getTransactionLevel())
                                        .addArgument(evt.getResult())
                                        .addArgument(evt.occurredOn())
                                        .log();
                } catch (SQLException ex) {
                        errorWith(EVENT_LOG)
                                        .setMessage(ex.getMessage())
                                        .setCause(ex)
                                        .log();
                }
        }

        void beforeSetParameter(final BeforeSetParameterEvent evt) {
                debugWith(EVENT_LOG)
                                .setMessage("Before Set Parameter - Parameter:{}")
                                .addArgument(evt.getParameter())
                                .log();
        }

        void afterGetOutParameter(final AfterGetOutParameterEvent evt) {
                debugWith(EVENT_LOG)
                                .setMessage("After Get OutParameter - key:{}, value:{}. parameterIndex:{}")
                                .addArgument(evt.getKey())
                                .addArgument(evt.getValue())
                                .addArgument(evt.getParameterIndex())
                                .log();
        }

        void afterSqlQuery(final AfterSqlQueryEvent evt) {
                debugWith(EVENT_LOG)
                                .setMessage("Execute Query - sqlName:{} executed.")
                                .addArgument(evt.getExecutionContext().getSqlName())
                                .log();
                traceWith(EVENT_LOG)
                                .setMessage("Execute Query sql:{}")
                                .addArgument(evt.getPreparedStatement())
                                .log();
        }

        void afterSqlUpdate(final AfterSqlUpdateEvent evt) {
                debugWith(EVENT_LOG)
                                .setMessage("Execute Update - sqlName:{} executed. Count:{} items.")
                                .addArgument(evt.getExecutionContext().getSqlName())
                                .addArgument(evt.getCount())
                                .log();
        }

        void afterSqlBatch(final AfterSqlBatchEvent evt) {
                debugWith(EVENT_LOG)
                                .setMessage("Execute Update - sqlName:{} executed. Results:{}")
                                .addArgument(evt.getExecutionContext().getSqlName())
                                .addArgument(() -> {
                                        try {
                                                return new int[] { evt.getPreparedStatement().getUpdateCount() };
                                        } catch (SQLException ex) {
                                                errorWith(EVENT_LOG)
                                                                .setMessage(ex.getMessage())
                                                                .setCause(ex)
                                                                .log();
                                                return evt.getCounts();
                                        }
                                })
                                .log();
        }
}

1	/**
2	* Copyright (c) 2017-present, Future Corporation
3	*
4	* This source code is licensed under the MIT license found in the
5	* LICENSE file in the root directory of this source tree.
6	*/
7	package jp.co.future.uroborosql.event.subscriber;
8
9	import java.sql.SQLException;
10
11	import org.slf4j.Logger;
12
13	import jp.co.future.uroborosql.event.AfterBeginTransactionEvent;
14	import jp.co.future.uroborosql.event.AfterGetOutParameterEvent;
15	import jp.co.future.uroborosql.event.AfterSqlBatchEvent;
16	import jp.co.future.uroborosql.event.AfterSqlQueryEvent;
17	import jp.co.future.uroborosql.event.AfterSqlUpdateEvent;
18	import jp.co.future.uroborosql.event.BeforeEndTransactionEvent;
19	import jp.co.future.uroborosql.event.BeforeSetParameterEvent;
20	import jp.co.future.uroborosql.log.support.EventLoggingSupport;
21
22	/**
23	* デバッグログを出力するEventSubscriber
24	*
25	* @author H.Sugimoto
26	* @since v1.0.0
27	*/
28	public class DebugEventSubscriber extends EventSubscriber implements EventLoggingSupport {	1✔
29	/** ロガー */
30	private static final Logger EVENT_LOG = EventLoggingSupport.getEventLogger("debug");	1✔
31
32	@Override
33	public void initialize() {
34	afterBeginTransactionListener(this::afterBeginTransaction);	1✔
35	beforeEndTransactionListener(this::beforeEndTransaction);	1✔
36	beforeSetParameterListener(this::beforeSetParameter);	1✔
37	afterGetOutParameterListener(this::afterGetOutParameter);	1✔
38	afterSqlQueryListener(this::afterSqlQuery);	1✔
39	afterSqlUpdateListener(this::afterSqlUpdate);	1✔
40	afterSqlBatchListener(this::afterSqlBatch);	1✔
41	}	1✔
42
43	void afterBeginTransaction(final AfterBeginTransactionEvent evt) {
44	try {
45	debugWith(EVENT_LOG)	1✔
46	.setMessage("Begin Transaction - connection:{}, requiredNew:{}, transactionLevel:{}, occurredOn:{}")	1✔
47	.addArgument(evt.getTransactionContext().getConnection())	1✔
48	.addArgument(evt.isRequiredNew())	1✔
49	.addArgument(evt.getTransactionLevel())	1✔
50	.addArgument(evt.occurredOn())	1✔
51	.log();	1✔
NEW 52	} catch (SQLException ex) {	×
NEW 53	errorWith(EVENT_LOG)	×
NEW 54	.setMessage(ex.getMessage())	×
NEW 55	.setCause(ex)	×
NEW 56	.log();	×
57	}	1✔
58	}	1✔
59
60	void beforeEndTransaction(final BeforeEndTransactionEvent evt) {
61	try {
62	debugWith(EVENT_LOG)	1✔
63	.setMessage(	1✔
64	"End Transaction - connection:{}, requiredNew:{}, transactionLevel:{}, result:{}, occurredOn:{}")
65	.addArgument(evt.getTransactionContext().getConnection())	1✔
66	.addArgument(evt.isRequiredNew())	1✔
67	.addArgument(evt.getTransactionLevel())	1✔
68	.addArgument(evt.getResult())	1✔
69	.addArgument(evt.occurredOn())	1✔
70	.log();	1✔
NEW 71	} catch (SQLException ex) {	×
NEW 72	errorWith(EVENT_LOG)	×
NEW 73	.setMessage(ex.getMessage())	×
NEW 74	.setCause(ex)	×
NEW 75	.log();	×
76	}	1✔
77	}	1✔
78
79	void beforeSetParameter(final BeforeSetParameterEvent evt) {
80	debugWith(EVENT_LOG)	1✔
81	.setMessage("Before Set Parameter - Parameter:{}")	1✔
82	.addArgument(evt.getParameter())	1✔
83	.log();	1✔
84	}	1✔
85
86	void afterGetOutParameter(final AfterGetOutParameterEvent evt) {
NEW 87	debugWith(EVENT_LOG)	×
NEW 88	.setMessage("After Get OutParameter - key:{}, value:{}. parameterIndex:{}")	×
NEW 89	.addArgument(evt.getKey())	×
NEW 90	.addArgument(evt.getValue())	×
NEW 91	.addArgument(evt.getParameterIndex())	×
NEW 92	.log();	×
UNCOV 93	}	×
94
95	void afterSqlQuery(final AfterSqlQueryEvent evt) {
96	debugWith(EVENT_LOG)	1✔
97	.setMessage("Execute Query - sqlName:{} executed.")	1✔
98	.addArgument(evt.getExecutionContext().getSqlName())	1✔
99	.log();	1✔
100	traceWith(EVENT_LOG)	1✔
101	.setMessage("Execute Query sql:{}")	1✔
102	.addArgument(evt.getPreparedStatement())	1✔
103	.log();	1✔
104	}	1✔
105
106	void afterSqlUpdate(final AfterSqlUpdateEvent evt) {
107	debugWith(EVENT_LOG)	1✔
108	.setMessage("Execute Update - sqlName:{} executed. Count:{} items.")	1✔
109	.addArgument(evt.getExecutionContext().getSqlName())	1✔
110	.addArgument(evt.getCount())	1✔
111	.log();	1✔
112	}	1✔
113
114	void afterSqlBatch(final AfterSqlBatchEvent evt) {
115	debugWith(EVENT_LOG)	1✔
116	.setMessage("Execute Update - sqlName:{} executed. Results:{}")	1✔
117	.addArgument(evt.getExecutionContext().getSqlName())	1✔
118	.addArgument(() -> {	1✔
119	try {
120	return new int[] { evt.getPreparedStatement().getUpdateCount() };	1✔
NEW 121	} catch (SQLException ex) {	×
NEW 122	errorWith(EVENT_LOG)	×
NEW 123	.setMessage(ex.getMessage())	×
NEW 124	.setCause(ex)	×
NEW 125	.log();	×
NEW 126	return evt.getCounts();	×
127	}
128	})
129	.log();	1✔
130	}	1✔
131	}

future-architect / uroborosql / #770

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous