From 97cb23fc914679f837c2a35109870adc228fb019 Mon Sep 17 00:00:00 2001 From: "Breno A." Date: Tue, 30 Apr 2024 10:29:36 -0300 Subject: [PATCH] refactor: log4j-api to slf4j-api --- README.md | 5 - docs/src/guide/installation.md | 47 ---- pom.xml | 6 +- .../brenoepics/at4j/AzureApiBuilder.java | 4 +- .../at4j/core/ratelimit/RateLimitManager.java | 3 +- .../logging/FallbackLoggerConfiguration.java | 60 ----- .../util/logging/Log4jPropertySource.java | 46 ---- .../at4j/util/logging/LoggerUtil.java | 96 ++------ .../util/logging/PrivacyProtectionLogger.java | 212 ------------------ .../at4j/util/logging/ProtectedLogger.java | 138 ++++++++++++ .../at4j/util/rest/RestRequest.java | 4 +- .../at4j/util/rest/RestRequestResult.java | 4 +- ...g.apache.logging.log4j.util.PropertySource | 1 - .../FallbackLoggerConfigurationTest.java | 53 ----- .../logging/PrivacyProtectionLoggerTest.java | 44 ---- .../util/logging/ProtectedLoggerTest.java | 79 +++++++ 16 files changed, 251 insertions(+), 551 deletions(-) delete mode 100644 src/main/java/io/github/brenoepics/at4j/util/logging/FallbackLoggerConfiguration.java delete mode 100644 src/main/java/io/github/brenoepics/at4j/util/logging/Log4jPropertySource.java delete mode 100644 src/main/java/io/github/brenoepics/at4j/util/logging/PrivacyProtectionLogger.java create mode 100644 src/main/java/io/github/brenoepics/at4j/util/logging/ProtectedLogger.java delete mode 100644 src/main/resources/META-INF/services/org.apache.logging.log4j.util.PropertySource delete mode 100644 src/test/java/io/github/brenoepics/at4j/util/logging/FallbackLoggerConfigurationTest.java delete mode 100644 src/test/java/io/github/brenoepics/at4j/util/logging/PrivacyProtectionLoggerTest.java create mode 100644 src/test/java/io/github/brenoepics/at4j/util/logging/ProtectedLoggerTest.java diff --git a/README.md b/README.md index 496a1068..d496391f 100644 --- a/README.md +++ b/README.md @@ -102,11 +102,6 @@ libraryDependencies += "io.github.brenoepics" % "at4j" % "1.0.0" **A:** You can access your Azure Translator Keys through your Azure portal. Remember to keep your keys secure and refrain from sharing them publicly. If you suspect a key has been compromised, it's crucial to regenerate it promptly. For detailed instructions on generating your own keys, refer to [this guide](https://brenoepics.github.io/at4j/guide/azure-subscription.html#azure-subscription). Additionally, you can explore the [Azure Free Tier](https://brenoepics.github.io/at4j/guide/azure-subscription.html#azure-free-tier) for more information. -Optional Logger Dependency -**Q:** Is there a recommended logger dependency for the project? - -**A:** While our project is compatible with any Log4j-2-compatible logging framework, integrating one can enhance your logging experience significantly. This allows you to configure log format, log targets (console, file, database, etc.), log levels per class, and more. For further details, please visit our [Docs](https://brenoepics.github.io/at4j/guide/installation.html#logger-dependency). - ## 🤝 Thank You! - **Microsoft Azure**: Supporting our project with a generous grant of $10,000+ in Azure credits, enabling us to use virtual machines, document translation and other essential cloud resources for our development needs. - We extend our sincere thanks to all contributors for their invaluable contributions. diff --git a/docs/src/guide/installation.md b/docs/src/guide/installation.md index 9172831f..7fb9a8ca 100644 --- a/docs/src/guide/installation.md +++ b/docs/src/guide/installation.md @@ -25,50 +25,3 @@ implementation group: 'io.github.brenoepics', name: 'at4j', version: 'AT4J-VERSI libraryDependencies += "io.github.brenoepics" % "at4j" % "AT4J-VERSION" ``` ::: - -## Optional Logger Dependency {#logger-dependency} - -In addition to AT4J, it is also recommended to install a Log4j-2-compatible logging framework. -A logging framework can be used to provide a more sophisticated logging experience with being able to configure log format, -log targets (console, file, database, Discord direct message, ...), log levels per class, and much more. - -For example, Log4j Core: - -::: code-group -```groovy [Gradle] -dependencies { runtimeOnly 'org.apache.logging.log4j:log4j-core:2.17.0' } -``` - -```xml [Maven] - - org.apache.logging.log4j - log4j-core - 2.17.0 - -``` - -```scala [Sbt] -libraryDependencies ++= Seq("org.apache.logging.log4j" % "log4j-core" % "2.17.0") -``` -::: - -Or Log4j to Slf4j: - -::: code-group -```groovy [Gradle] -dependencies { runtimeOnly 'org.apache.logging.log4j:log4j-to-slf4j:2.22.1' } -``` - -```xml [Maven] - - org.apache.logging.log4j - log4j-to-slf4j - 2.22.1 - -``` -```scala [Sbt] -libraryDependencies ++= Seq("org.apache.logging.log4j" % "log4j-to-slf4j" % "2.22.1") -``` -::: - -Take a look at the logger configuration doc for further information. diff --git a/pom.xml b/pom.xml index ccf43189..beb2546a 100644 --- a/pom.xml +++ b/pom.xml @@ -52,9 +52,9 @@ - org.apache.logging.log4j - log4j-api - 2.23.1 + org.slf4j + slf4j-api + 2.0.13 com.fasterxml.jackson.core diff --git a/src/main/java/io/github/brenoepics/at4j/AzureApiBuilder.java b/src/main/java/io/github/brenoepics/at4j/AzureApiBuilder.java index fc013d6d..f2f83a22 100644 --- a/src/main/java/io/github/brenoepics/at4j/AzureApiBuilder.java +++ b/src/main/java/io/github/brenoepics/at4j/AzureApiBuilder.java @@ -2,7 +2,7 @@ import io.github.brenoepics.at4j.azure.BaseURL; import io.github.brenoepics.at4j.core.AzureApiImpl; -import io.github.brenoepics.at4j.util.logging.PrivacyProtectionLogger; +import io.github.brenoepics.at4j.util.logging.ProtectedLogger; import javax.net.ssl.SSLContext; import javax.net.ssl.SSLParameters; @@ -52,7 +52,7 @@ public AzureApiBuilder baseURL(BaseURL baseURL) { */ public AzureApiBuilder setKey(String subscriptionKey) { this.subscriptionKey = subscriptionKey; - PrivacyProtectionLogger.addPrivateData(subscriptionKey); + ProtectedLogger.addPrivateData(subscriptionKey); return this; } diff --git a/src/main/java/io/github/brenoepics/at4j/core/ratelimit/RateLimitManager.java b/src/main/java/io/github/brenoepics/at4j/core/ratelimit/RateLimitManager.java index 311b66d6..af7de92b 100644 --- a/src/main/java/io/github/brenoepics/at4j/core/ratelimit/RateLimitManager.java +++ b/src/main/java/io/github/brenoepics/at4j/core/ratelimit/RateLimitManager.java @@ -7,6 +7,8 @@ import io.github.brenoepics.at4j.util.rest.RestRequestHandler; import io.github.brenoepics.at4j.util.rest.RestRequestResponseInfoImpl; import io.github.brenoepics.at4j.util.rest.RestRequestResult; +import org.slf4j.Logger; + import java.net.http.HttpHeaders; import java.net.http.HttpResponse; import java.util.HashSet; @@ -15,7 +17,6 @@ import java.util.Set; import java.util.concurrent.CompletableFuture; import java.util.function.Function; -import org.apache.logging.log4j.Logger; /** This class manages rate-limits and keeps track of them. */ public class RateLimitManager { diff --git a/src/main/java/io/github/brenoepics/at4j/util/logging/FallbackLoggerConfiguration.java b/src/main/java/io/github/brenoepics/at4j/util/logging/FallbackLoggerConfiguration.java deleted file mode 100644 index 903301f5..00000000 --- a/src/main/java/io/github/brenoepics/at4j/util/logging/FallbackLoggerConfiguration.java +++ /dev/null @@ -1,60 +0,0 @@ -package io.github.brenoepics.at4j.util.logging; - -import java.util.concurrent.atomic.AtomicBoolean; - -/** This class can be used to configure AT4J's fallback logger. */ -public class FallbackLoggerConfiguration { - - private static final AtomicBoolean debug = new AtomicBoolean(); - - private static final AtomicBoolean trace = new AtomicBoolean(); - - /** This class should not be instantiated. */ - FallbackLoggerConfiguration() { - throw new UnsupportedOperationException(); - } - - /** - * Checks whether debug logging is enabled. - * - * @return Whether debug logging is enabled or not. - */ - public static boolean isDebugEnabled() { - return debug.get(); - } - - /** - * Sets whether debug logging should be enabled. Disabling debug logging automatically disables - * trace logging, too. - * - * @param debug Whether debug logging should be enabled or not. - */ - public static void setDebug(boolean debug) { - FallbackLoggerConfiguration.debug.set(debug); - if (!debug) { - trace.set(false); - } - } - - /** - * Checks whether trace logging is enabled. - * - * @return Whether trace logging is enabled or not. - */ - public static boolean isTraceEnabled() { - return trace.get(); - } - - /** - * Sets whether trace logging should be enabled. Enabling trace logging automatically enables - * debug logging, too. - * - * @param trace Whether trace logging should be enabled or not. - */ - public static void setTrace(boolean trace) { - FallbackLoggerConfiguration.trace.set(trace); - if (trace) { - debug.set(true); - } - } -} diff --git a/src/main/java/io/github/brenoepics/at4j/util/logging/Log4jPropertySource.java b/src/main/java/io/github/brenoepics/at4j/util/logging/Log4jPropertySource.java deleted file mode 100644 index 7c9f2bdd..00000000 --- a/src/main/java/io/github/brenoepics/at4j/util/logging/Log4jPropertySource.java +++ /dev/null @@ -1,46 +0,0 @@ -package io.github.brenoepics.at4j.util.logging; - -import org.apache.logging.log4j.util.BiConsumer; -import org.apache.logging.log4j.util.PropertySource; - -/** - * This class implements the PropertySource interface from the Log4j utility package. It is used to - * provide custom properties for the Log4j configuration. - */ -public class Log4jPropertySource implements PropertySource { - - /** - * This method returns the priority of this PropertySource. The returned value is the minimum - * integer value, indicating that any other PropertySource should override this one. - * - * @return the priority of this PropertySource - */ - @Override - public int getPriority() { - // any value coming from somewhere else should beat us, we only want to change the default - return Integer.MIN_VALUE; - } - - /** - * This method accepts a BiConsumer action and applies it to the property - * "log4j.isThreadContextMapInheritable" with the value "true". - * - * @param action the BiConsumer action to be applied to the property - */ - @Override - public void forEach(BiConsumer action) { - action.accept("log4j.isThreadContextMapInheritable", "true"); - } - - /** - * This method takes an Iterable of CharSequences as tokens and returns a CharSequence in the form - * of "log4j." followed by the tokens joined as camel case. - * - * @param tokens an Iterable of CharSequences to be joined as camel case - * @return a CharSequence in the form of "log4j." followed by the tokens joined as camel case - */ - @Override - public CharSequence getNormalForm(Iterable tokens) { - return "log4j." + Util.joinAsCamelCase(tokens); - } -} diff --git a/src/main/java/io/github/brenoepics/at4j/util/logging/LoggerUtil.java b/src/main/java/io/github/brenoepics/at4j/util/logging/LoggerUtil.java index 205b764f..ca1484f1 100644 --- a/src/main/java/io/github/brenoepics/at4j/util/logging/LoggerUtil.java +++ b/src/main/java/io/github/brenoepics/at4j/util/logging/LoggerUtil.java @@ -1,81 +1,31 @@ package io.github.brenoepics.at4j.util.logging; -import java.util.Map; -import java.util.Properties; -import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.atomic.AtomicBoolean; -import java.util.concurrent.atomic.AtomicReference; -import org.apache.logging.log4j.Level; -import org.apache.logging.log4j.LogManager; -import org.apache.logging.log4j.Logger; -import org.apache.logging.log4j.simple.SimpleLogger; -import org.apache.logging.log4j.util.PropertiesUtil; -import org.apache.logging.log4j.util.ProviderUtil; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; /** This class is used to get a {@link Logger} instance. */ public class LoggerUtil { - LoggerUtil() { - throw new UnsupportedOperationException(); - } - - private static final AtomicReference initialized = new AtomicReference<>(false); - private static final AtomicBoolean noLogger = new AtomicBoolean(); - private static final Map loggers = new ConcurrentHashMap<>(); - - /** - * Get or create a logger with the given name. - * - * @param name The name of the logger. - * @return The logger with the given name. - */ - public static Logger getLogger(String name) { - AtomicBoolean logWarning = new AtomicBoolean(false); - initialized.updateAndGet( - initialized -> { - if (Boolean.TRUE.equals(!initialized) && !ProviderUtil.hasProviders()) { - noLogger.set(true); - logWarning.set(true); - } - return true; - }); + LoggerUtil() { + throw new UnsupportedOperationException(); + } - if (noLogger.get()) { - return loggers.computeIfAbsent( - name, - key -> { - Level debugLevel = - FallbackLoggerConfiguration.isDebugEnabled() ? Level.DEBUG : Level.INFO; - Level level = FallbackLoggerConfiguration.isTraceEnabled() ? Level.TRACE : debugLevel; - Logger logger = - new SimpleLogger( - name, - level, - true, - false, - true, - true, - "yyyy-MM-dd HH:mm:ss.SSSZ", - null, - new PropertiesUtil(new Properties()), - System.out); - if (logWarning.get()) { - logger.info( - "No Log4j2 compatible logger was found. Using default AT4J implementation!"); - } - return new PrivacyProtectionLogger(logger); - }); - } else { - return new PrivacyProtectionLogger(LogManager.getLogger(name)); + /** + * Get or create a logger with the given name. + * + * @param name The name of the logger. + * @return The logger with the given name. + */ + public static Logger getLogger(String name) { + return LoggerFactory.getLogger(name); } - } - /** - * Gets or creates a logger for the given name. - * - * @param clazz The class of the logger. - * @return A logger for the given class. - */ - public static Logger getLogger(Class clazz) { - return getLogger(clazz.getName()); - } -} + /** + * Gets or creates a logger for the given class. + * + * @param clazz The class of the logger. + * @return A logger for the given class. + */ + public static Logger getLogger(Class clazz) { + return LoggerFactory.getLogger(clazz); + } +} \ No newline at end of file diff --git a/src/main/java/io/github/brenoepics/at4j/util/logging/PrivacyProtectionLogger.java b/src/main/java/io/github/brenoepics/at4j/util/logging/PrivacyProtectionLogger.java deleted file mode 100644 index 94a8f521..00000000 --- a/src/main/java/io/github/brenoepics/at4j/util/logging/PrivacyProtectionLogger.java +++ /dev/null @@ -1,212 +0,0 @@ -package io.github.brenoepics.at4j.util.logging; - -import java.util.HashSet; -import java.util.Set; -import org.apache.logging.log4j.Level; -import org.apache.logging.log4j.Logger; -import org.apache.logging.log4j.Marker; -import org.apache.logging.log4j.message.Message; -import org.apache.logging.log4j.spi.AbstractLogger; - -/** - * This logger is used to wrap another logger and replace configured sensitive data by asterisks. - */ -public class PrivacyProtectionLogger extends AbstractLogger { - private static final long serialVersionUID = 91095837261631L; - private static final String PRIVATE_DATA_REPLACEMENT = "**********"; - private static final Set privateDataSet = new HashSet<>(); - - private final transient Logger delegate; - - /** - * Class constructor. It's recommended to use {@link LoggerUtil#getLogger(String)}. - * - * @param delegate The delegate logger that gets the cleaned messages. - */ - PrivacyProtectionLogger(Logger delegate) { - this.delegate = delegate; - } - - /** - * Adds private data to be asterisked out in log messages. A {@code null} argument is simply - * ignored. - * - * @param privateData The private data. - */ - public static void addPrivateData(String privateData) { - if (privateData != null && !privateData.trim().isEmpty()) { - privateDataSet.add(privateData); - } - } - - @Override - public void logMessage(String fqcn, Level level, Marker marker, Message message, Throwable t) { - String formattedMessage = message.getFormattedMessage(); - if (privateDataSet.stream().anyMatch(formattedMessage::contains)) { - String replacedMessage = formattedMessage; - for (String privateData : privateDataSet) { - if (formattedMessage.contains(privateData)) { - replacedMessage = replacedMessage.replace(privateData, PRIVATE_DATA_REPLACEMENT); - } - } - delegate.log(level, marker, replacedMessage, t); - } else { - delegate.log(level, marker, message, t); - } - } - - @Override - public boolean isEnabled(Level level, Marker marker, Message message, Throwable t) { - return delegate.isEnabled(level, marker); - } - - @Override - public boolean isEnabled(Level level, Marker marker, CharSequence message, Throwable t) { - return delegate.isEnabled(level, marker); - } - - @Override - public boolean isEnabled(Level level, Marker marker, Object message, Throwable t) { - return delegate.isEnabled(level, marker); - } - - @Override - public boolean isEnabled(Level level, Marker marker, String message, Throwable t) { - return delegate.isEnabled(level, marker); - } - - @Override - public boolean isEnabled(Level level, Marker marker, String message) { - return delegate.isEnabled(level, marker); - } - - @Override - public boolean isEnabled(Level level, Marker marker, String message, Object... params) { - return delegate.isEnabled(level, marker); - } - - @Override - public boolean isEnabled(Level level, Marker marker, String message, Object p0) { - return delegate.isEnabled(level, marker); - } - - @Override - public boolean isEnabled(Level level, Marker marker, String message, Object p0, Object p1) { - return delegate.isEnabled(level, marker); - } - - @Override - public boolean isEnabled( - Level level, Marker marker, String message, Object p0, Object p1, Object p2) { - return delegate.isEnabled(level, marker); - } - - @Override - public boolean isEnabled( - Level level, Marker marker, String message, Object p0, Object p1, Object p2, Object p3) { - return delegate.isEnabled(level, marker); - } - - @Override - public boolean isEnabled( - Level level, - Marker marker, - String message, - Object p0, - Object p1, - Object p2, - Object p3, - Object p4) { - return delegate.isEnabled(level, marker); - } - - @Override - public boolean isEnabled( - Level level, - Marker marker, - String message, - Object p0, - Object p1, - Object p2, - Object p3, - Object p4, - Object p5) { - return delegate.isEnabled(level, marker); - } - - @Override - public boolean isEnabled( - Level level, - Marker marker, - String message, - Object p0, - Object p1, - Object p2, - Object p3, - Object p4, - Object p5, - Object p6) { - return delegate.isEnabled(level, marker); - } - - @Override - public boolean isEnabled( - Level level, - Marker marker, - String message, - Object p0, - Object p1, - Object p2, - Object p3, - Object p4, - Object p5, - Object p6, - Object p7) { - return delegate.isEnabled(level, marker); - } - - @Override - public boolean isEnabled( - Level level, - Marker marker, - String message, - Object p0, - Object p1, - Object p2, - Object p3, - Object p4, - Object p5, - Object p6, - Object p7, - Object p8) { - return delegate.isEnabled(level, marker); - } - - @Override - public boolean isEnabled( - Level level, - Marker marker, - String message, - Object p0, - Object p1, - Object p2, - Object p3, - Object p4, - Object p5, - Object p6, - Object p7, - Object p8, - Object p9) { - return delegate.isEnabled(level, marker); - } - - @Override - public Level getLevel() { - return delegate.getLevel(); - } - - @Override - public String getName() { - return delegate.getName(); - } -} diff --git a/src/main/java/io/github/brenoepics/at4j/util/logging/ProtectedLogger.java b/src/main/java/io/github/brenoepics/at4j/util/logging/ProtectedLogger.java new file mode 100644 index 00000000..aa7e3e48 --- /dev/null +++ b/src/main/java/io/github/brenoepics/at4j/util/logging/ProtectedLogger.java @@ -0,0 +1,138 @@ +package io.github.brenoepics.at4j.util.logging; + +import java.util.HashSet; +import java.util.Set; +import org.slf4j.Logger; +import org.slf4j.Marker; +import org.slf4j.event.Level; +import org.slf4j.helpers.AbstractLogger; + +/** + * This logger is used to wrap another logger and replace configured sensitive data by asterisks. + */ +public class ProtectedLogger extends AbstractLogger { + private static final long serialVersionUID = 91095837261631L; + private static final String PRIVATE_DATA_REPLACEMENT = "**********"; + private static final Set privateDataSet = new HashSet<>(); + + private final transient Logger delegate; + + /** + * Class constructor. It's recommended to use {@link LoggerUtil#getLogger(String)}. + * + * @param delegate The delegate logger that gets the cleaned messages. + */ + ProtectedLogger(Logger delegate) { + this.delegate = delegate; + } + + /** + * Adds private data to be asterisked out in log messages. A {@code null} argument is simply + * ignored. + * + * @param privateData The private data. + */ + public static void addPrivateData(String privateData) { + if (privateData != null && !privateData.trim().isEmpty()) { + privateDataSet.add(privateData); + } + } + + @Override + public String getName() { + return delegate.getName(); + } + + @Override + public boolean isTraceEnabled() { + return delegate.isTraceEnabled(); + } + + @Override + public boolean isTraceEnabled(Marker marker) { + return delegate.isTraceEnabled(marker); + } + + @Override + public boolean isDebugEnabled() { + return delegate.isDebugEnabled(); + } + + @Override + public boolean isDebugEnabled(Marker marker) { + return delegate.isDebugEnabled(marker); + } + + @Override + public boolean isInfoEnabled() { + return delegate.isInfoEnabled(); + } + + @Override + public boolean isInfoEnabled(Marker marker) { + return delegate.isInfoEnabled(marker); + } + + @Override + public boolean isWarnEnabled() { + return delegate.isWarnEnabled(); + } + + @Override + public boolean isWarnEnabled(Marker marker) { + return delegate.isWarnEnabled(marker); + } + + @Override + public boolean isErrorEnabled() { + return delegate.isErrorEnabled(); + } + + @Override + public boolean isErrorEnabled(Marker marker) { + return delegate.isErrorEnabled(marker); + } + + @Override + protected String getFullyQualifiedCallerName() { + return delegate.getName(); + } + + @Override + protected void handleNormalizedLoggingCall( + Level level, Marker marker, String message, Object[] objects, Throwable t) { + if (privateDataSet.stream().noneMatch(message::contains)) { + log(level, marker, objects, t, message); + return; + } + + String replacedMessage = message; + for (String privateData : privateDataSet) { + if (message.contains(privateData)) { + replacedMessage = replacedMessage.replace(privateData, PRIVATE_DATA_REPLACEMENT); + } + } + + log(level, marker, objects, t, replacedMessage); + } + + private void log(Level level, Marker marker, Object[] objects, Throwable t, String message) { + switch (level) { + case TRACE: + delegate.trace(marker, message, objects, t); + break; + case DEBUG: + delegate.debug(marker, message, objects, t); + break; + case INFO: + delegate.info(marker, message, objects, t); + break; + case WARN: + delegate.warn(marker, message, objects, t); + break; + case ERROR: + delegate.error(marker, message, objects, t); + break; + } + } +} diff --git a/src/main/java/io/github/brenoepics/at4j/util/rest/RestRequest.java b/src/main/java/io/github/brenoepics/at4j/util/rest/RestRequest.java index 8d5c2c8d..4547a557 100644 --- a/src/main/java/io/github/brenoepics/at4j/util/rest/RestRequest.java +++ b/src/main/java/io/github/brenoepics/at4j/util/rest/RestRequest.java @@ -5,6 +5,8 @@ import io.github.brenoepics.at4j.AzureApi; import io.github.brenoepics.at4j.core.exceptions.AzureException; import io.github.brenoepics.at4j.util.logging.LoggerUtil; +import org.slf4j.Logger; + import java.io.IOException; import java.net.MalformedURLException; import java.net.URI; @@ -15,8 +17,6 @@ import java.util.concurrent.CompletableFuture; import java.util.function.Function; -import org.apache.logging.log4j.Logger; - /** This class is used to wrap a rest request. */ public class RestRequest { diff --git a/src/main/java/io/github/brenoepics/at4j/util/rest/RestRequestResult.java b/src/main/java/io/github/brenoepics/at4j/util/rest/RestRequestResult.java index 8f28f262..f6cb2e96 100644 --- a/src/main/java/io/github/brenoepics/at4j/util/rest/RestRequestResult.java +++ b/src/main/java/io/github/brenoepics/at4j/util/rest/RestRequestResult.java @@ -5,11 +5,11 @@ import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.node.NullNode; import io.github.brenoepics.at4j.util.logging.LoggerUtil; +import org.slf4j.Logger; + import java.io.IOException; import java.net.http.HttpResponse; import java.util.Optional; -import org.apache.logging.log4j.Logger; - /** The result of a {@link RestRequest}. */ public class RestRequestResult { diff --git a/src/main/resources/META-INF/services/org.apache.logging.log4j.util.PropertySource b/src/main/resources/META-INF/services/org.apache.logging.log4j.util.PropertySource deleted file mode 100644 index 7dcda44b..00000000 --- a/src/main/resources/META-INF/services/org.apache.logging.log4j.util.PropertySource +++ /dev/null @@ -1 +0,0 @@ -io.github.brenoepics.at4j.util.logging.Log4jPropertySource \ No newline at end of file diff --git a/src/test/java/io/github/brenoepics/at4j/util/logging/FallbackLoggerConfigurationTest.java b/src/test/java/io/github/brenoepics/at4j/util/logging/FallbackLoggerConfigurationTest.java deleted file mode 100644 index 6b6ddd08..00000000 --- a/src/test/java/io/github/brenoepics/at4j/util/logging/FallbackLoggerConfigurationTest.java +++ /dev/null @@ -1,53 +0,0 @@ -package io.github.brenoepics.at4j.util.logging; - -import org.junit.jupiter.api.Test; - -import static org.junit.jupiter.api.Assertions.*; - -class FallbackLoggerConfigurationTest { - - @Test - void invokingConstructorThrowsException() { - assertThrows(UnsupportedOperationException.class, FallbackLoggerConfiguration::new); - } - - @Test - void debugInitiallyEnabled() { - assertTrue(FallbackLoggerConfiguration.isDebugEnabled()); - } - - @Test - void traceInitiallyDisabled() { - assertFalse(FallbackLoggerConfiguration.isTraceEnabled()); - } - - @Test - void enablingDebugEnablesDebugLogging() { - FallbackLoggerConfiguration.setDebug(true); - assertTrue(FallbackLoggerConfiguration.isDebugEnabled()); - FallbackLoggerConfiguration.setDebug(false); // reset for other tests - } - - @Test - void disablingDebugDisablesTraceLogging() { - FallbackLoggerConfiguration.setTrace(true); - FallbackLoggerConfiguration.setDebug(false); - assertFalse(FallbackLoggerConfiguration.isTraceEnabled()); - FallbackLoggerConfiguration.setTrace(false); // reset for other tests - } - - @Test - void enablingTraceEnablesDebugLogging() { - FallbackLoggerConfiguration.setTrace(true); - assertTrue(FallbackLoggerConfiguration.isDebugEnabled()); - FallbackLoggerConfiguration.setTrace(false); // reset for other tests - } - - @Test - void disablingTraceDoesNotDisableDebugLogging() { - FallbackLoggerConfiguration.setDebug(true); - FallbackLoggerConfiguration.setTrace(false); - assertTrue(FallbackLoggerConfiguration.isDebugEnabled()); - FallbackLoggerConfiguration.setDebug(false); // reset for other tests - } -} diff --git a/src/test/java/io/github/brenoepics/at4j/util/logging/PrivacyProtectionLoggerTest.java b/src/test/java/io/github/brenoepics/at4j/util/logging/PrivacyProtectionLoggerTest.java deleted file mode 100644 index 8ef30044..00000000 --- a/src/test/java/io/github/brenoepics/at4j/util/logging/PrivacyProtectionLoggerTest.java +++ /dev/null @@ -1,44 +0,0 @@ -package io.github.brenoepics.at4j.util.logging; - -import org.apache.logging.log4j.Level; -import org.apache.logging.log4j.Logger; -import org.apache.logging.log4j.Marker; -import org.apache.logging.log4j.MarkerManager; -import org.apache.logging.log4j.message.Message; -import org.apache.logging.log4j.message.SimpleMessage; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.mockito.Mockito; - -import static org.junit.jupiter.api.Assertions.*; -import static org.mockito.Mockito.*; - -class PrivacyProtectionLoggerTest { - private Logger delegate; - private PrivacyProtectionLogger privacyProtectionLogger; - - @BeforeEach - public void setup() { - delegate = Mockito.mock(Logger.class); - privacyProtectionLogger = new PrivacyProtectionLogger(delegate); - } - - @Test - void logMessageTest() { - String privateData = "secret"; - PrivacyProtectionLogger.addPrivateData(privateData); - Message message = new SimpleMessage("This is a secret message"); - Marker marker = MarkerManager.getMarker("TEST"); - privacyProtectionLogger.logMessage( - PrivacyProtectionLoggerTest.class.getName(), Level.INFO, marker, message, null); - verify(delegate) - .log(eq(Level.INFO), eq(marker), eq("This is a ********** message"), (Throwable) isNull()); - } - - @Test - void isEnabledTest() { - Marker marker = MarkerManager.getMarker("TEST"); - when(delegate.isEnabled(Level.INFO, marker)).thenReturn(true); - assertTrue(privacyProtectionLogger.isEnabled(Level.INFO, marker, "Test message")); - } -} diff --git a/src/test/java/io/github/brenoepics/at4j/util/logging/ProtectedLoggerTest.java b/src/test/java/io/github/brenoepics/at4j/util/logging/ProtectedLoggerTest.java new file mode 100644 index 00000000..61854d3f --- /dev/null +++ b/src/test/java/io/github/brenoepics/at4j/util/logging/ProtectedLoggerTest.java @@ -0,0 +1,79 @@ +package io.github.brenoepics.at4j.util.logging; + +import static org.mockito.Mockito.*; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; +import org.slf4j.Logger; +import org.slf4j.Marker; +import org.slf4j.event.Level; + +class ProtectedLoggerTest { + private Logger delegate; + private ProtectedLogger protectedLogger; + + @BeforeEach + public void setup() { + delegate = Mockito.mock(Logger.class); + protectedLogger = new ProtectedLogger(delegate); + } + + @Test + void logMessageTest() { + String privateData = "secret"; + ProtectedLogger.addPrivateData(privateData); + String message = "This is a secret message"; + Marker marker = Mockito.mock(Marker.class); + protectedLogger.handleNormalizedLoggingCall(Level.INFO, marker, message, null, null); + verify(delegate).info(eq(marker), eq("This is a ********** message"), isNull(), isNull()); + } + + @Test + void logTraceMessageTest() { + String privateData = "secret"; + ProtectedLogger.addPrivateData(privateData); + String message = "This is a secret trace message"; + Marker marker = Mockito.mock(Marker.class); + protectedLogger.handleNormalizedLoggingCall(Level.TRACE, marker, message, null, null); + verify(delegate).trace(eq(marker), eq("This is a ********** trace message"), isNull(), isNull()); + } + + @Test + void logDebugMessageTest() { + String privateData = "secret"; + ProtectedLogger.addPrivateData(privateData); + String message = "This is a secret debug message"; + Marker marker = Mockito.mock(Marker.class); + protectedLogger.handleNormalizedLoggingCall(Level.DEBUG, marker, message, null, null); + verify(delegate).debug(eq(marker), eq("This is a ********** debug message"), isNull(), isNull()); + } + + @Test + void logWarnMessageTest() { + String privateData = "secret"; + ProtectedLogger.addPrivateData(privateData); + String message = "This is a secret warn message"; + Marker marker = Mockito.mock(Marker.class); + protectedLogger.handleNormalizedLoggingCall(Level.WARN, marker, message, null, null); + verify(delegate).warn(eq(marker), eq("This is a ********** warn message"), isNull(), isNull()); + } + + @Test + void logErrorMessageTest() { + String privateData = "secret"; + ProtectedLogger.addPrivateData(privateData); + String message = "This is a secret error message"; + Marker marker = Mockito.mock(Marker.class); + protectedLogger.handleNormalizedLoggingCall(Level.ERROR, marker, message, null, null); + verify(delegate).error(eq(marker), eq("This is a ********** error message"), isNull(), isNull()); + } + + @Test + void logMessageWithoutPrivateDataTest() { + String message = "This is a regular message"; + Marker marker = Mockito.mock(Marker.class); + protectedLogger.handleNormalizedLoggingCall(Level.INFO, marker, message, null, null); + verify(delegate).info(eq(marker), eq("This is a regular message"), isNull(), isNull()); + } +}