#956

Committed 14 Jul 2026 02:08PM UTC coverage: 90.721% (-0.04%) from 90.759%

Build # #956

Build Type

Committed by

Commit Message

Guard resultCount computation with !isSuppressLogging() && isDebugEnabled()

Pull Request Pull Request #380: DebugEventSubscriber: output resultCount instead of result.toString() in beforeEndTransaction

Coverage Stats

15 of 20 new or added lines in 1 file covered. (75.0%)

9230 of 10174 relevant lines covered (90.72%)

0.91 hits per line

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

69.57

/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.lang.reflect.Array;
import java.sql.SQLException;
import java.util.Collection;

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 {
                        if (!isSuppressLogging() && EVENT_LOG.isDebugEnabled()) {
                                var result = evt.getResult();
                                int resultCount;
                                if (result == null) {
                                        resultCount = 0;
                                } else if (result.getClass().isArray()) {
                                        resultCount = Array.getLength(result);
                                } else if (result instanceof Collection) {
                                        resultCount = ((Collection<?>) result).size();
                                } else {
                                        resultCount = 1;
                                }
                                debugWith(EVENT_LOG)
                                                .setMessage(
                                                                "End Transaction - connection:{}, requiredNew:{}, transactionLevel:{}, resultCount:{}, occurredOn:{}")
                                                .addArgument(evt.getTransactionContext().getConnection())
                                                .addArgument(evt.isRequiredNew())
                                                .addArgument(evt.getTransactionLevel())
                                                .addArgument(resultCount)
                                                .addArgument(evt.occurredOn())
                                                .log();
                        }
                        traceWith(EVENT_LOG)
                                        .setMessage("End Transaction result:{}")
                                        .addArgument(evt::getResult)
                                        .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.lang.reflect.Array;
10	import java.sql.SQLException;
11	import java.util.Collection;
12
13	import org.slf4j.Logger;
14
15	import jp.co.future.uroborosql.event.AfterBeginTransactionEvent;
16	import jp.co.future.uroborosql.event.AfterGetOutParameterEvent;
17	import jp.co.future.uroborosql.event.AfterSqlBatchEvent;
18	import jp.co.future.uroborosql.event.AfterSqlQueryEvent;
19	import jp.co.future.uroborosql.event.AfterSqlUpdateEvent;
20	import jp.co.future.uroborosql.event.BeforeEndTransactionEvent;
21	import jp.co.future.uroborosql.event.BeforeSetParameterEvent;
22	import jp.co.future.uroborosql.log.support.EventLoggingSupport;
23
24	/**
25	* デバッグログを出力するEventSubscriber
26	*
27	* @author H.Sugimoto
28	* @since v1.0.0
29	*/
30	public class DebugEventSubscriber extends EventSubscriber implements EventLoggingSupport {	1✔
31	/** ロガー */
32	private static final Logger EVENT_LOG = EventLoggingSupport.getEventLogger("debug");	1✔
33
34	@Override
35	public void initialize() {
36	afterBeginTransactionListener(this::afterBeginTransaction);	1✔
37	beforeEndTransactionListener(this::beforeEndTransaction);	1✔
38	beforeSetParameterListener(this::beforeSetParameter);	1✔
39	afterGetOutParameterListener(this::afterGetOutParameter);	1✔
40	afterSqlQueryListener(this::afterSqlQuery);	1✔
41	afterSqlUpdateListener(this::afterSqlUpdate);	1✔
42	afterSqlBatchListener(this::afterSqlBatch);	1✔
43	}	1✔
44
45	void afterBeginTransaction(final AfterBeginTransactionEvent evt) {
46	try {
47	debugWith(EVENT_LOG)	1✔
48	.setMessage("Begin Transaction - connection:{}, requiredNew:{}, transactionLevel:{}, occurredOn:{}")	1✔
49	.addArgument(evt.getTransactionContext().getConnection())	1✔
50	.addArgument(evt.isRequiredNew())	1✔
51	.addArgument(evt.getTransactionLevel())	1✔
52	.addArgument(evt.occurredOn())	1✔
53	.log();	1✔
54	} catch (SQLException ex) {	×
55	errorWith(EVENT_LOG)	×
56	.setMessage(ex.getMessage())	×
57	.setCause(ex)	×
58	.log();	×
59	}	1✔
60	}	1✔
61
62	void beforeEndTransaction(final BeforeEndTransactionEvent evt) {
63	try {
64	if (!isSuppressLogging() && EVENT_LOG.isDebugEnabled()) {	1✔
65	var result = evt.getResult();	1✔
66	int resultCount;
67	if (result == null) {	1✔
68	resultCount = 0;	1✔
NEW 69	} else if (result.getClass().isArray()) {	×
NEW 70	resultCount = Array.getLength(result);	×
NEW 71	} else if (result instanceof Collection) {	×
NEW 72	resultCount = ((Collection<?>) result).size();	×
73	} else {
NEW 74	resultCount = 1;	×
75	}
76	debugWith(EVENT_LOG)	1✔
77	.setMessage(	1✔
78	"End Transaction - connection:{}, requiredNew:{}, transactionLevel:{}, resultCount:{}, occurredOn:{}")
79	.addArgument(evt.getTransactionContext().getConnection())	1✔
80	.addArgument(evt.isRequiredNew())	1✔
81	.addArgument(evt.getTransactionLevel())	1✔
82	.addArgument(resultCount)	1✔
83	.addArgument(evt.occurredOn())	1✔
84	.log();	1✔
85	}
86	traceWith(EVENT_LOG)	1✔
87	.setMessage("End Transaction result:{}")	1✔
88	.addArgument(evt::getResult)	1✔
89	.log();	1✔
90	} catch (SQLException ex) {	×
91	errorWith(EVENT_LOG)	×
92	.setMessage(ex.getMessage())	×
93	.setCause(ex)	×
94	.log();	×
95	}	1✔
96	}	1✔
97
98	void beforeSetParameter(final BeforeSetParameterEvent evt) {
99	debugWith(EVENT_LOG)	1✔
100	.setMessage("Before Set Parameter - Parameter:{}")	1✔
101	.addArgument(evt.getParameter())	1✔
102	.log();	1✔
103	}	1✔
104
105	void afterGetOutParameter(final AfterGetOutParameterEvent evt) {
106	debugWith(EVENT_LOG)	×
107	.setMessage("After Get OutParameter - key:{}, value:{}. parameterIndex:{}")	×
108	.addArgument(evt.getKey())	×
109	.addArgument(evt.getValue())	×
110	.addArgument(evt.getParameterIndex())	×
111	.log();	×
112	}	×
113
114	void afterSqlQuery(final AfterSqlQueryEvent evt) {
115	debugWith(EVENT_LOG)	1✔
116	.setMessage("Execute Query - sqlName:{} executed.")	1✔
117	.addArgument(evt.getExecutionContext().getSqlName())	1✔
118	.log();	1✔
119	traceWith(EVENT_LOG)	1✔
120	.setMessage("Execute Query sql:{}")	1✔
121	.addArgument(evt.getPreparedStatement())	1✔
122	.log();	1✔
123	}	1✔
124
125	void afterSqlUpdate(final AfterSqlUpdateEvent evt) {
126	debugWith(EVENT_LOG)	1✔
127	.setMessage("Execute Update - sqlName:{} executed. Count:{} items.")	1✔
128	.addArgument(evt.getExecutionContext().getSqlName())	1✔
129	.addArgument(evt.getCount())	1✔
130	.log();	1✔
131	}	1✔
132
133	void afterSqlBatch(final AfterSqlBatchEvent evt) {
134	debugWith(EVENT_LOG)	1✔
135	.setMessage("Execute Update - sqlName:{} executed. Results:{}")	1✔
136	.addArgument(evt.getExecutionContext().getSqlName())	1✔
137	.addArgument(() -> {	1✔
138	try {
139	return new int[] { evt.getPreparedStatement().getUpdateCount() };	1✔
140	} catch (SQLException ex) {	×
141	errorWith(EVENT_LOG)	×
142	.setMessage(ex.getMessage())	×
143	.setCause(ex)	×
144	.log();	×
145	return evt.getCounts();	×
146	}
147	})
148	.log();	1✔
149	}	1✔
150	}

future-architect / uroborosql / #956

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