This is an automated email from the ASF dual-hosted git repository.
albumenj pushed a commit to branch 3.3
in repository https://gitbox.apache.org/repos/asf/dubbo.git
The following commit(s) were added to refs/heads/3.3 by this push:
new 737ff1dcda Add fluent logger to simplify logging (#14484)
737ff1dcda is described below
commit 737ff1dcdaf5f4a64151985954fce4ad2ec60581
Author: Sean Yang <[email protected]>
AuthorDate: Tue Aug 20 18:02:33 2024 +0800
Add fluent logger to simplify logging (#14484)
---
.../apache/dubbo/common/logger/FluentLogger.java | 134 +++++
.../dubbo/common/logger/FluentLoggerImpl.java | 667 +++++++++++++++++++++
.../tri/h12/AbstractServerTransportListener.java | 59 +-
.../tri/rest/filter/DefaultFilterChain.java | 18 +-
.../mapping/DefaultRequestMappingRegistry.java | 13 +-
5 files changed, 822 insertions(+), 69 deletions(-)
diff --git
a/dubbo-common/src/main/java/org/apache/dubbo/common/logger/FluentLogger.java
b/dubbo-common/src/main/java/org/apache/dubbo/common/logger/FluentLogger.java
new file mode 100644
index 0000000000..f68739fe49
--- /dev/null
+++
b/dubbo-common/src/main/java/org/apache/dubbo/common/logger/FluentLogger.java
@@ -0,0 +1,134 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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
+ *
+ * http://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 org.apache.dubbo.common.logger;
+
+import java.util.function.Supplier;
+
+public interface FluentLogger {
+
+ FluentLogger cause(String cause);
+
+ FluentLogger more(String extendedInformation);
+
+ FluentLogger msg(String msg);
+
+ FluentLogger msg(String msg, Object... args);
+
+ FluentLogger msg(Supplier<String> supplier);
+
+ void trace();
+
+ void trace(Throwable t);
+
+ void trace(String msg);
+
+ void trace(String msg, Object... args);
+
+ void trace(String msg, Throwable t);
+
+ void debug();
+
+ void debug(Throwable t);
+
+ void debug(String msg);
+
+ void debug(String msg, Object... args);
+
+ void debug(String msg, Throwable t);
+
+ void info();
+
+ void info(Throwable t);
+
+ void info(String msg, Object... args);
+
+ void info(String msg);
+
+ void info(String msg, Throwable t);
+
+ void internalWarn();
+
+ void internalWarn(Throwable t);
+
+ void internalWarn(String msg);
+
+ void internalWarn(String msg, Object... args);
+
+ void internalWarn(String msg, Throwable t);
+
+ void warn(String code);
+
+ void warn(String code, Throwable t);
+
+ void warn(String code, String msg, Object... args);
+
+ void warn(String code, String msg, Throwable t);
+
+ void internalError();
+
+ void internalError(Throwable t);
+
+ void internalError(String msg);
+
+ void internalError(String msg, Object... args);
+
+ void internalError(String msg, Throwable t);
+
+ void error(String code);
+
+ void error(String code, Throwable t);
+
+ void error(String code, String msg, Object... args);
+
+ void error(String code, String msg, Throwable t);
+
+ void log(Level level);
+
+ void log(Level level, Throwable t);
+
+ void log(Level level, String msg);
+
+ void log(Level level, String msg, Object... args);
+
+ void log(Level level, String msg, Throwable t);
+
+ void log(String code, Level level);
+
+ void log(String code, Level level, String msg, Object... args);
+
+ void log(String code, Level level, String msg, Throwable t);
+
+ boolean isTraceEnabled();
+
+ boolean isDebugEnabled();
+
+ boolean isInfoEnabled();
+
+ boolean isWarnEnabled();
+
+ boolean isErrorEnabled();
+
+ static FluentLogger of(Class<?> key) {
+ return new FluentLoggerImpl(key);
+ }
+
+ static FluentLogger of(String key) {
+ return new FluentLoggerImpl(key);
+ }
+
+ interface S extends Supplier<String> {}
+}
diff --git
a/dubbo-common/src/main/java/org/apache/dubbo/common/logger/FluentLoggerImpl.java
b/dubbo-common/src/main/java/org/apache/dubbo/common/logger/FluentLoggerImpl.java
new file mode 100644
index 0000000000..3184493b8b
--- /dev/null
+++
b/dubbo-common/src/main/java/org/apache/dubbo/common/logger/FluentLoggerImpl.java
@@ -0,0 +1,667 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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
+ *
+ * http://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 org.apache.dubbo.common.logger;
+
+import org.apache.dubbo.common.logger.helpers.FormattingTuple;
+import org.apache.dubbo.common.logger.helpers.MessageFormatter;
+import org.apache.dubbo.common.utils.StringUtils;
+
+import java.util.function.Supplier;
+
+import static
org.apache.dubbo.common.constants.LoggerCodeConstants.INTERNAL_ERROR;
+
+final class FluentLoggerImpl implements FluentLogger {
+
+ private final ErrorTypeAwareLogger delegate;
+ private final FluentLoggerImpl root;
+
+ private String cause = StringUtils.EMPTY_STRING;
+ private String extendedInformation = StringUtils.EMPTY_STRING;
+ private Supplier<String> messageSupplier;
+ private String message;
+ private Object[] args;
+
+ FluentLoggerImpl(Class<?> key) {
+ delegate = LoggerFactory.getErrorTypeAwareLogger(key);
+ root = this;
+ }
+
+ FluentLoggerImpl(String key) {
+ delegate = LoggerFactory.getErrorTypeAwareLogger(key);
+ root = this;
+ }
+
+ private FluentLoggerImpl(FluentLoggerImpl logger) {
+ delegate = logger.delegate;
+ root = logger;
+ }
+
+ @Override
+ public FluentLogger cause(String cause) {
+ if (cause == null) {
+ return this;
+ }
+ FluentLoggerImpl logger = getLogger();
+ logger.cause = cause;
+ return logger;
+ }
+
+ @Override
+ public FluentLogger more(String extendedInformation) {
+ if (extendedInformation == null) {
+ return this;
+ }
+ FluentLoggerImpl logger = getLogger();
+ logger.extendedInformation = extendedInformation;
+ return logger;
+ }
+
+ @Override
+ public FluentLogger msg(String message) {
+ FluentLoggerImpl logger = getLogger();
+ logger.message = message;
+ return logger;
+ }
+
+ @Override
+ public FluentLogger msg(String message, Object... args) {
+ FluentLoggerImpl logger = getLogger();
+ logger.message = message;
+ logger.args = args;
+ return logger;
+ }
+
+ @Override
+ public FluentLogger msg(Supplier<String> supplier) {
+ FluentLoggerImpl logger = getLogger();
+ logger.messageSupplier = supplier;
+ return logger;
+ }
+
+ @Override
+ public void trace() {
+ if (message != null) {
+ if (args != null && args.length > 0) {
+ if (delegate.isTraceEnabled()) {
+ delegate.trace(message, formatArgs(args));
+ }
+ } else {
+ delegate.trace(message);
+ }
+ } else if (messageSupplier != null) {
+ if (delegate.isTraceEnabled()) {
+ delegate.trace(messageSupplier.get());
+ }
+ } else {
+ warnMessageMissing();
+ }
+ }
+
+ @Override
+ public void trace(Throwable t) {
+ if (message != null) {
+ int len = args == null ? 0 : args.length;
+ if (len > 0) {
+ if (delegate.isTraceEnabled()) {
+ Object[] arr = new Object[len + 1];
+ System.arraycopy(args, 0, arr, 0, len);
+ arr[len] = t;
+ delegate.trace(message, formatArgs(arr));
+ }
+ } else {
+ delegate.trace(message, t);
+ }
+ } else if (messageSupplier != null) {
+ if (delegate.isTraceEnabled()) {
+ delegate.trace(messageSupplier.get(), t);
+ }
+ } else {
+ warnMessageMissing();
+ }
+ }
+
+ @Override
+ public void trace(String message) {
+ delegate.trace(message);
+ }
+
+ @Override
+ public void trace(String message, Object... args) {
+ if (args == null || args.length == 0) {
+ delegate.trace(message);
+ } else if (delegate.isTraceEnabled()) {
+ delegate.trace(message, formatArgs(args));
+ }
+ }
+
+ @Override
+ public void trace(String message, Throwable t) {
+ delegate.trace(message, t);
+ }
+
+ @Override
+ public void debug() {
+ if (message != null) {
+ if (args != null && args.length > 0) {
+ if (delegate.isDebugEnabled()) {
+ delegate.debug(message, formatArgs(args));
+ }
+ } else {
+ delegate.debug(message);
+ }
+ } else if (messageSupplier != null) {
+ if (delegate.isDebugEnabled()) {
+ delegate.debug(messageSupplier.get());
+ }
+ } else {
+ warnMessageMissing();
+ }
+ }
+
+ @Override
+ public void debug(Throwable t) {
+ if (message != null) {
+ int len = args == null ? 0 : args.length;
+ if (len > 0) {
+ if (delegate.isDebugEnabled()) {
+ Object[] arr = new Object[len + 1];
+ System.arraycopy(args, 0, arr, 0, len);
+ arr[len] = t;
+ delegate.debug(message, formatArgs(arr));
+ }
+ } else {
+ delegate.debug(message, t);
+ }
+ } else if (messageSupplier != null) {
+ if (delegate.isDebugEnabled()) {
+ delegate.debug(messageSupplier.get(), t);
+ }
+ } else {
+ warnMessageMissing();
+ }
+ }
+
+ @Override
+ public void debug(String message) {
+ delegate.debug(message);
+ }
+
+ @Override
+ public void debug(String message, Object... args) {
+ if (args == null || args.length == 0) {
+ delegate.debug(message);
+ } else if (delegate.isDebugEnabled()) {
+ delegate.debug(message, formatArgs(args));
+ }
+ }
+
+ @Override
+ public void debug(String message, Throwable t) {
+ delegate.debug(message, t);
+ }
+
+ @Override
+ public void info() {
+ if (message != null) {
+ if (args != null && args.length > 0) {
+ if (delegate.isInfoEnabled()) {
+ delegate.info(message, formatArgs(args));
+ }
+ } else {
+ delegate.info(message);
+ }
+ } else if (messageSupplier != null) {
+ if (delegate.isInfoEnabled()) {
+ delegate.info(messageSupplier.get());
+ }
+ } else {
+ warnMessageMissing();
+ }
+ }
+
+ @Override
+ public void info(Throwable t) {
+ if (message != null) {
+ int len = args == null ? 0 : args.length;
+ if (len > 0) {
+ if (delegate.isInfoEnabled()) {
+ Object[] arr = new Object[len + 1];
+ System.arraycopy(args, 0, arr, 0, len);
+ arr[len] = t;
+ delegate.info(message, formatArgs(arr));
+ }
+ } else {
+ delegate.info(message, t);
+ }
+ } else if (messageSupplier != null) {
+ if (delegate.isInfoEnabled()) {
+ delegate.info(messageSupplier.get(), t);
+ }
+ } else {
+ warnMessageMissing();
+ }
+ }
+
+ @Override
+ public void info(String message, Object... args) {
+ if (args == null || args.length == 0) {
+ delegate.info(message);
+ } else if (delegate.isInfoEnabled()) {
+ delegate.info(message, formatArgs(args));
+ }
+ }
+
+ @Override
+ public void info(String message) {
+ delegate.info(message);
+ }
+
+ @Override
+ public void info(String message, Throwable t) {
+ delegate.info(message, t);
+ }
+
+ @Override
+ public void internalWarn() {
+ warn(INTERNAL_ERROR);
+ }
+
+ @Override
+ public void internalWarn(Throwable t) {
+ warn(INTERNAL_ERROR, t);
+ }
+
+ @Override
+ public void internalWarn(String message) {
+ warn(INTERNAL_ERROR, message);
+ }
+
+ @Override
+ public void internalWarn(String message, Object... args) {
+ warn(INTERNAL_ERROR, message, args);
+ }
+
+ @Override
+ public void internalWarn(String message, Throwable t) {
+ warn(INTERNAL_ERROR, message, t);
+ }
+
+ @Override
+ public void warn(String code) {
+ if (message != null) {
+ if (args != null && args.length > 0) {
+ formatAndWarn(code, message, args);
+ } else {
+ delegate.warn(code, cause, extendedInformation, message);
+ }
+ } else if (messageSupplier != null) {
+ if (delegate.isWarnEnabled()) {
+ delegate.warn(code, cause, extendedInformation,
messageSupplier.get());
+ }
+ } else {
+ warnMessageMissing();
+ }
+ }
+
+ @Override
+ public void warn(String code, Throwable t) {
+ if (message != null) {
+ if (args != null && args.length > 0) {
+ if (delegate.isWarnEnabled()) {
+ FormattingTuple tuple =
MessageFormatter.arrayFormat(message, formatArgs(args));
+ delegate.warn(code, cause, extendedInformation,
tuple.getMessage(), t);
+ }
+ } else {
+ delegate.warn(code, cause, extendedInformation, message, t);
+ }
+ } else if (messageSupplier != null && delegate.isWarnEnabled()) {
+ delegate.warn(code, cause, extendedInformation,
messageSupplier.get(), t);
+ }
+ }
+
+ @Override
+ public void warn(String code, String message, Object... args) {
+ if (args == null || args.length == 0) {
+ delegate.warn(code, cause, extendedInformation, message);
+ return;
+ }
+ formatAndWarn(code, message, args);
+ }
+
+ private void formatAndWarn(String code, String message, Object... args) {
+ if (!delegate.isWarnEnabled()) {
+ return;
+ }
+ FormattingTuple tuple = MessageFormatter.arrayFormat(message,
formatArgs(args));
+ if (tuple.getThrowable() == null) {
+ delegate.warn(code, cause, extendedInformation,
tuple.getMessage());
+ } else {
+ delegate.warn(code, cause, extendedInformation,
tuple.getMessage(), tuple.getThrowable());
+ }
+ }
+
+ @Override
+ public void warn(String code, String message, Throwable t) {
+ delegate.warn(code, cause, extendedInformation, message, t);
+ }
+
+ @Override
+ public void internalError() {
+ error(INTERNAL_ERROR);
+ }
+
+ @Override
+ public void internalError(Throwable t) {
+ error(INTERNAL_ERROR, t);
+ }
+
+ @Override
+ public void internalError(String message) {
+ error(INTERNAL_ERROR, message);
+ }
+
+ @Override
+ public void internalError(String message, Object... args) {
+ error(INTERNAL_ERROR, message, args);
+ }
+
+ @Override
+ public void internalError(String message, Throwable t) {
+ error(INTERNAL_ERROR, message, t);
+ }
+
+ @Override
+ public void error(String code) {
+ if (message != null) {
+ if (args != null && args.length > 0) {
+ formatAndError(code, message, args);
+ } else {
+ delegate.error(code, cause, extendedInformation, message);
+ }
+ } else if (messageSupplier != null) {
+ if (delegate.isErrorEnabled()) {
+ delegate.error(code, cause, extendedInformation,
messageSupplier.get());
+ }
+ } else {
+ warnMessageMissing();
+ }
+ }
+
+ @Override
+ public void error(String code, Throwable t) {
+ if (message != null) {
+ if (args != null && args.length > 0) {
+ if (delegate.isErrorEnabled()) {
+ FormattingTuple tuple =
MessageFormatter.arrayFormat(message, formatArgs(args));
+ delegate.error(code, cause, extendedInformation,
tuple.getMessage(), t);
+ }
+ } else {
+ delegate.error(code, cause, extendedInformation, message, t);
+ }
+ } else if (messageSupplier != null) {
+ if (delegate.isErrorEnabled()) {
+ delegate.error(code, cause, extendedInformation,
messageSupplier.get(), t);
+ }
+ } else {
+ warnMessageMissing();
+ }
+ }
+
+ @Override
+ public void error(String code, String message, Object... args) {
+ if (args == null || args.length == 0) {
+ delegate.error(code, cause, extendedInformation, message);
+ return;
+ }
+ formatAndError(code, message, args);
+ }
+
+ private void formatAndError(String code, String message, Object... args) {
+ if (!delegate.isErrorEnabled()) {
+ return;
+ }
+ FormattingTuple tuple = MessageFormatter.arrayFormat(message,
formatArgs(args));
+ if (tuple.getThrowable() == null) {
+ delegate.error(code, cause, extendedInformation,
tuple.getMessage());
+ } else {
+ delegate.error(code, cause, extendedInformation,
tuple.getMessage(), tuple.getThrowable());
+ }
+ }
+
+ @Override
+ public void error(String code, String message, Throwable t) {
+ delegate.error(code, cause, extendedInformation, message, t);
+ }
+
+ @Override
+ public void log(Level level) {
+ switch (level) {
+ case TRACE:
+ trace();
+ break;
+ case DEBUG:
+ debug();
+ break;
+ case INFO:
+ info();
+ break;
+ case WARN:
+ internalWarn();
+ break;
+ case ERROR:
+ internalError();
+ break;
+ default:
+ }
+ }
+
+ @Override
+ public void log(Level level, Throwable t) {
+ switch (level) {
+ case TRACE:
+ trace(t);
+ break;
+ case DEBUG:
+ debug(t);
+ break;
+ case INFO:
+ info(t);
+ break;
+ case WARN:
+ internalWarn(t);
+ break;
+ case ERROR:
+ internalError(t);
+ break;
+ default:
+ }
+ }
+
+ @Override
+ public void log(Level level, String msg) {
+ switch (level) {
+ case TRACE:
+ trace(msg);
+ break;
+ case DEBUG:
+ debug(msg);
+ break;
+ case INFO:
+ info(msg);
+ break;
+ case WARN:
+ internalWarn(msg);
+ break;
+ case ERROR:
+ internalError(msg);
+ break;
+ default:
+ }
+ }
+
+ @Override
+ public void log(Level level, String msg, Object... args) {
+ switch (level) {
+ case TRACE:
+ trace(msg, args);
+ break;
+ case DEBUG:
+ debug(msg, args);
+ break;
+ case INFO:
+ info(msg, args);
+ break;
+ case WARN:
+ internalWarn(msg, args);
+ break;
+ case ERROR:
+ internalError(msg, args);
+ break;
+ default:
+ }
+ }
+
+ @Override
+ public void log(Level level, String msg, Throwable t) {
+ switch (level) {
+ case TRACE:
+ trace(msg, t);
+ break;
+ case DEBUG:
+ debug(msg, t);
+ break;
+ case INFO:
+ info(msg, t);
+ break;
+ case WARN:
+ internalWarn(msg, t);
+ break;
+ case ERROR:
+ internalError(msg, t);
+ break;
+ default:
+ }
+ }
+
+ @Override
+ public void log(String code, Level level) {
+ switch (level) {
+ case TRACE:
+ trace();
+ break;
+ case DEBUG:
+ debug();
+ break;
+ case INFO:
+ info();
+ break;
+ case WARN:
+ warn(code);
+ break;
+ case ERROR:
+ error(code);
+ break;
+ default:
+ }
+ }
+
+ @Override
+ public void log(String code, Level level, String msg, Object... args) {
+ switch (level) {
+ case TRACE:
+ trace(msg, args);
+ break;
+ case DEBUG:
+ debug(msg, args);
+ break;
+ case INFO:
+ info(msg, args);
+ break;
+ case WARN:
+ warn(code, msg, args);
+ break;
+ case ERROR:
+ error(code, msg, args);
+ break;
+ default:
+ }
+ }
+
+ @Override
+ public void log(String code, Level level, String msg, Throwable t) {
+ switch (level) {
+ case TRACE:
+ trace(msg, t);
+ break;
+ case DEBUG:
+ debug(msg, t);
+ break;
+ case INFO:
+ info(msg, t);
+ break;
+ case WARN:
+ warn(code, msg, t);
+ break;
+ case ERROR:
+ error(code, msg, t);
+ break;
+ default:
+ }
+ }
+
+ @Override
+ public boolean isTraceEnabled() {
+ return delegate.isTraceEnabled();
+ }
+
+ @Override
+ public boolean isDebugEnabled() {
+ return delegate.isDebugEnabled();
+ }
+
+ @Override
+ public boolean isInfoEnabled() {
+ return delegate.isInfoEnabled();
+ }
+
+ @Override
+ public boolean isWarnEnabled() {
+ return delegate.isWarnEnabled();
+ }
+
+ @Override
+ public boolean isErrorEnabled() {
+ return delegate.isErrorEnabled();
+ }
+
+ private FluentLoggerImpl getLogger() {
+ return this == root ? new FluentLoggerImpl(this) : this;
+ }
+
+ private void warnMessageMissing() {
+ delegate.warn(INTERNAL_ERROR, cause, extendedInformation, "Message
must not be empty");
+ }
+
+ private static Object[] formatArgs(Object[] args) {
+ for (int i = 0; i < args.length; i++) {
+ if (args[i] instanceof Supplier) {
+ args[i] = ((Supplier<?>) args[i]).get();
+ }
+ }
+ return args;
+ }
+}
diff --git
a/dubbo-rpc/dubbo-rpc-triple/src/main/java/org/apache/dubbo/rpc/protocol/tri/h12/AbstractServerTransportListener.java
b/dubbo-rpc/dubbo-rpc-triple/src/main/java/org/apache/dubbo/rpc/protocol/tri/h12/AbstractServerTransportListener.java
index ac4f59e61a..16e52d990f 100644
---
a/dubbo-rpc/dubbo-rpc-triple/src/main/java/org/apache/dubbo/rpc/protocol/tri/h12/AbstractServerTransportListener.java
+++
b/dubbo-rpc/dubbo-rpc-triple/src/main/java/org/apache/dubbo/rpc/protocol/tri/h12/AbstractServerTransportListener.java
@@ -18,8 +18,8 @@ package org.apache.dubbo.rpc.protocol.tri.h12;
import org.apache.dubbo.common.URL;
import org.apache.dubbo.common.constants.CommonConstants;
-import org.apache.dubbo.common.logger.ErrorTypeAwareLogger;
-import org.apache.dubbo.common.logger.LoggerFactory;
+import org.apache.dubbo.common.constants.LoggerCodeConstants;
+import org.apache.dubbo.common.logger.FluentLogger;
import org.apache.dubbo.common.utils.MethodUtils;
import org.apache.dubbo.remoting.http12.ExceptionHandler;
import org.apache.dubbo.remoting.http12.HttpChannel;
@@ -37,6 +37,7 @@ import org.apache.dubbo.rpc.model.MethodDescriptor;
import org.apache.dubbo.rpc.protocol.tri.DescriptorUtils;
import org.apache.dubbo.rpc.protocol.tri.ExceptionUtils;
import org.apache.dubbo.rpc.protocol.tri.RpcInvocationBuildContext;
+import org.apache.dubbo.rpc.protocol.tri.TripleConstant;
import org.apache.dubbo.rpc.protocol.tri.TripleHeaderEnum;
import org.apache.dubbo.rpc.protocol.tri.TripleProtocol;
import org.apache.dubbo.rpc.protocol.tri.h12.http2.CompositeExceptionHandler;
@@ -49,16 +50,10 @@ import java.util.List;
import java.util.concurrent.Executor;
import java.util.function.Supplier;
-import static
org.apache.dubbo.common.constants.LoggerCodeConstants.COMMON_ERROR_USE_THREAD_POOL;
-import static
org.apache.dubbo.common.constants.LoggerCodeConstants.INTERNAL_ERROR;
-import static
org.apache.dubbo.common.constants.LoggerCodeConstants.PROTOCOL_FAILED_PARSE;
-import static
org.apache.dubbo.rpc.protocol.tri.TripleConstant.REMOTE_ADDRESS_KEY;
-
public abstract class AbstractServerTransportListener<HEADER extends
RequestMetadata, MESSAGE extends HttpInputMessage>
implements HttpTransportListener<HEADER, MESSAGE> {
- private static final ErrorTypeAwareLogger LOGGER =
-
LoggerFactory.getErrorTypeAwareLogger(AbstractServerTransportListener.class);
+ private static final FluentLogger LOGGER =
FluentLogger.of(AbstractServerTransportListener.class);
private final FrameworkModel frameworkModel;
private final URL url;
@@ -88,12 +83,12 @@ public abstract class
AbstractServerTransportListener<HEADER extends RequestMeta
try {
executor = initializeExecutor(metadata);
} catch (Throwable throwable) {
- LOGGER.error(COMMON_ERROR_USE_THREAD_POOL, "", "", "initialize
executor fail.", throwable);
+ LOGGER.error(LoggerCodeConstants.COMMON_ERROR_USE_THREAD_POOL,
"Initialize executor fail.", throwable);
onError(throwable);
return;
}
if (executor == null) {
- LOGGER.error(INTERNAL_ERROR, "", "", "executor must be not null.");
+ LOGGER.error(LoggerCodeConstants.INTERNAL_ERROR, "Executor must be
not null.");
onError(new NullPointerException("initializeExecutor return
null"));
return;
}
@@ -198,34 +193,7 @@ public abstract class
AbstractServerTransportListener<HEADER extends RequestMeta
}
return sb.toString();
};
- switch (exceptionHandler.resolveLogLevel(t)) {
- case TRACE:
- if (LOGGER.isTraceEnabled()) {
- LOGGER.trace(msg.get(), t);
- }
- return;
- case DEBUG:
- if (LOGGER.isDebugEnabled()) {
- LOGGER.debug(msg.get(), t);
- }
- return;
- case INFO:
- if (LOGGER.isInfoEnabled()) {
- LOGGER.info(msg.get(), t);
- }
- return;
- case WARN:
- if (LOGGER.isWarnEnabled()) {
- LOGGER.warn(INTERNAL_ERROR, "", "", msg.get(), t);
- }
- return;
- case ERROR:
- if (LOGGER.isErrorEnabled()) {
- LOGGER.error(INTERNAL_ERROR, "", "", msg.get(), t);
- }
- return;
- default:
- }
+ LOGGER.msg(msg).log(exceptionHandler.resolveLogLevel(t), t);
}
protected void onError(Throwable throwable) {
@@ -282,7 +250,7 @@ public abstract class
AbstractServerTransportListener<HEADER extends RequestMeta
inv.setTargetServiceUniqueName(url.getServiceKey());
inv.setReturnTypes(methodDescriptor.getReturnTypes());
inv.setObjectAttachments(StreamUtils.toAttachments(httpMetadata.headers()));
- inv.put(REMOTE_ADDRESS_KEY, httpChannel.remoteAddress());
+ inv.put(TripleConstant.REMOTE_ADDRESS_KEY,
httpChannel.remoteAddress());
inv.getAttributes().putAll(context.getAttributes());
String consumerAppName =
httpMetadata.headers().getFirst(TripleHeaderEnum.CONSUMER_APP_NAME_KEY.getHeader());
if (null != consumerAppName) {
@@ -310,12 +278,11 @@ public abstract class
AbstractServerTransportListener<HEADER extends RequestMeta
}
} catch (Throwable t) {
LOGGER.warn(
- PROTOCOL_FAILED_PARSE,
- "",
- "",
- String.format(
- "Failed to parse request timeout set from:%s,
service=%s " + "method=%s",
- timeoutString,
context.getServiceDescriptor().getInterfaceName(), context.getMethodName()));
+ LoggerCodeConstants.PROTOCOL_FAILED_PARSE,
+ "Failed to parse request timeout set from: {}, service={},
method={}",
+ timeoutString,
+ context.getServiceDescriptor().getInterfaceName(),
+ context.getMethodName());
}
return invocation;
}
diff --git
a/dubbo-rpc/dubbo-rpc-triple/src/main/java/org/apache/dubbo/rpc/protocol/tri/rest/filter/DefaultFilterChain.java
b/dubbo-rpc/dubbo-rpc-triple/src/main/java/org/apache/dubbo/rpc/protocol/tri/rest/filter/DefaultFilterChain.java
index f4ddd2ad26..30cf418442 100644
---
a/dubbo-rpc/dubbo-rpc-triple/src/main/java/org/apache/dubbo/rpc/protocol/tri/rest/filter/DefaultFilterChain.java
+++
b/dubbo-rpc/dubbo-rpc-triple/src/main/java/org/apache/dubbo/rpc/protocol/tri/rest/filter/DefaultFilterChain.java
@@ -16,9 +16,7 @@
*/
package org.apache.dubbo.rpc.protocol.tri.rest.filter;
-import org.apache.dubbo.common.constants.LoggerCodeConstants;
-import org.apache.dubbo.common.logger.ErrorTypeAwareLogger;
-import org.apache.dubbo.common.logger.LoggerFactory;
+import org.apache.dubbo.common.logger.FluentLogger;
import org.apache.dubbo.remoting.http12.HttpRequest;
import org.apache.dubbo.remoting.http12.HttpResponse;
import org.apache.dubbo.rpc.AppResponse;
@@ -33,7 +31,7 @@ import java.util.function.Supplier;
final class DefaultFilterChain implements FilterChain, Listener {
- private static final ErrorTypeAwareLogger LOGGER =
LoggerFactory.getErrorTypeAwareLogger(DefaultFilterChain.class);
+ private static final FluentLogger LOGGER =
FluentLogger.of(DefaultFilterChain.class);
private final RestFilter[] filters;
private final Invocation invocation;
@@ -106,11 +104,7 @@ final class DefaultFilterChain implements FilterChain,
Listener {
try {
((Listener) filter).onResponse(result, request, response);
} catch (Throwable t) {
- LOGGER.error(
- LoggerCodeConstants.COMMON_UNEXPECTED_EXCEPTION,
- "",
- "",
- "Call onResponse for filter " + "[" + filter + "]
error");
+ LOGGER.internalError("Call onResponse for filter [{}]
error", filter);
}
}
}
@@ -124,11 +118,7 @@ final class DefaultFilterChain implements FilterChain,
Listener {
try {
((Listener) filter).onError(t, request, response);
} catch (Throwable th) {
- LOGGER.error(
- LoggerCodeConstants.COMMON_UNEXPECTED_EXCEPTION,
- "",
- "",
- "Call onError for filter " + "[" + filter + "]
error");
+ LOGGER.internalError("Call onError for filter [{}] error",
filter);
}
}
}
diff --git
a/dubbo-rpc/dubbo-rpc-triple/src/main/java/org/apache/dubbo/rpc/protocol/tri/rest/mapping/DefaultRequestMappingRegistry.java
b/dubbo-rpc/dubbo-rpc-triple/src/main/java/org/apache/dubbo/rpc/protocol/tri/rest/mapping/DefaultRequestMappingRegistry.java
index 3168e23c5a..eb7eb2e49c 100644
---
a/dubbo-rpc/dubbo-rpc-triple/src/main/java/org/apache/dubbo/rpc/protocol/tri/rest/mapping/DefaultRequestMappingRegistry.java
+++
b/dubbo-rpc/dubbo-rpc-triple/src/main/java/org/apache/dubbo/rpc/protocol/tri/rest/mapping/DefaultRequestMappingRegistry.java
@@ -19,8 +19,7 @@ package org.apache.dubbo.rpc.protocol.tri.rest.mapping;
import org.apache.dubbo.common.URL;
import org.apache.dubbo.common.config.Configuration;
import org.apache.dubbo.common.config.ConfigurationUtils;
-import org.apache.dubbo.common.constants.LoggerCodeConstants;
-import org.apache.dubbo.common.logger.ErrorTypeAwareLogger;
+import org.apache.dubbo.common.logger.FluentLogger;
import org.apache.dubbo.common.utils.ClassUtils;
import org.apache.dubbo.config.nested.RestConfig;
import org.apache.dubbo.remoting.http12.HttpRequest;
@@ -54,12 +53,9 @@ import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
-import static
org.apache.dubbo.common.logger.LoggerFactory.getErrorTypeAwareLogger;
-import static
org.apache.dubbo.rpc.protocol.tri.rest.Messages.AMBIGUOUS_MAPPING;
-
public final class DefaultRequestMappingRegistry implements
RequestMappingRegistry {
- private static final ErrorTypeAwareLogger LOGGER =
getErrorTypeAwareLogger(DefaultRequestMappingRegistry.class);
+ private static final FluentLogger LOGGER =
FluentLogger.of(DefaultRequestMappingRegistry.class);
private final FrameworkModel frameworkModel;
private final ContentNegotiator contentNegotiator;
@@ -173,8 +169,7 @@ public final class DefaultRequestMappingRegistry implements
RequestMappingRegist
}
counter.incrementAndGet();
} else if (LOGGER.isWarnEnabled()) {
- String msg = Messages.DUPLICATE_MAPPING.format(path,
mapping, handler.getMethod(), exists);
- LOGGER.warn(LoggerCodeConstants.INTERNAL_ERROR, "", "",
msg);
+
LOGGER.internalWarn(Messages.DUPLICATE_MAPPING.format(path, mapping,
handler.getMethod(), exists));
}
}
} finally {
@@ -274,7 +269,7 @@ public final class DefaultRequestMappingRegistry implements
RequestMappingRegist
Candidate first = candidates.get(0);
Candidate second = candidates.get(1);
if (first.mapping.compareTo(second.mapping, request) == 0) {
- throw new RestMappingException(AMBIGUOUS_MAPPING, path, first,
second);
+ throw new RestMappingException(Messages.AMBIGUOUS_MAPPING,
path, first, second);
}
}
