Added canLogAtLevel API in logging.

sdk/core/azure-core/src/main/java/com/azure/core/http/policy/HttpLoggingPolicy.java

@@ -10,11 +10,11 @@
 import com.azure.core.http.HttpPipelineNextPolicy;
 import com.azure.core.http.HttpRequest;
 import com.azure.core.http.HttpResponse;
-import com.azure.core.implementation.LogLevel;
 import com.azure.core.implementation.LoggingUtil;
 import com.azure.core.util.CoreUtils;
 import com.azure.core.util.UrlBuilder;
 import com.azure.core.util.logging.ClientLogger;
+import com.azure.core.util.logging.LogLevel;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.SerializationFeature;
 import reactor.core.publisher.Mono;
@@ -101,7 +101,7 @@ public Mono<HttpResponse> process(HttpPipelineCallContext context, HttpPipelineN
      * @return A Mono which will emit the string to log.
      */
     private Mono<Void> logRequest(final ClientLogger logger, final HttpRequest request) {
-        int numericLogLevel = LoggingUtil.getEnvironmentLoggingLevel().toNumeric();
+        int numericLogLevel = LoggingUtil.getEnvironmentLoggingLevel().getLogLevel();
         if (shouldLoggingBeSkipped(numericLogLevel)) {
             return Mono.empty();
         }
@@ -181,7 +181,7 @@ private Mono<Void> logRequest(final ClientLogger logger, final HttpRequest reque
      * @return A Mono containing the HTTP response.
      */
     private Mono<HttpResponse> logResponse(final ClientLogger logger, final HttpResponse response, long startNs) {
-        int numericLogLevel = LoggingUtil.getEnvironmentLoggingLevel().toNumeric();
+        int numericLogLevel = LoggingUtil.getEnvironmentLoggingLevel().getLogLevel();
         if (shouldLoggingBeSkipped(numericLogLevel)) {
             return Mono.just(response);
         }
@@ -260,7 +260,7 @@ private <T> Mono<T> logAndReturn(ClientLogger logger, StringBuilder logMessageBu
      * @return A flag indicating if logging should be skipped.
      */
     private boolean shouldLoggingBeSkipped(int environmentLogLevel) {
-        return environmentLogLevel > LogLevel.INFORMATIONAL.toNumeric();
+        return environmentLogLevel > LogLevel.INFORMATIONAL.getLogLevel();
     }
 
     /*
@@ -318,7 +318,7 @@ private String getAllowedQueryString(String queryString) {
      */
     private void addHeadersToLogMessage(HttpHeaders headers, StringBuilder sb, int logLevel) {
         // Either headers shouldn't be logged or the logging level isn't set to VERBOSE, don't add headers.
-        if (!httpLogDetailLevel.shouldLogHeaders() || logLevel > LogLevel.VERBOSE.toNumeric()) {
+        if (!httpLogDetailLevel.shouldLogHeaders() || logLevel > LogLevel.VERBOSE.getLogLevel()) {
             return;
         }
 

sdk/core/azure-core/src/main/java/com/azure/core/implementation/LoggingUtil.java

@@ -4,33 +4,24 @@
 package com.azure.core.implementation;
 
 import com.azure.core.util.Configuration;
-import com.azure.core.util.CoreUtils;
-
-import java.util.Arrays;
-import java.util.Map;
-import java.util.stream.Collectors;
+import com.azure.core.util.logging.LogLevel;
 
 /**
  * This class contains utility methods useful for logging.
  */
 public final class LoggingUtil {
-    private static final Map<Integer, LogLevel> LOG_LEVEL_MAPPER = Arrays.stream(LogLevel.values())
-        .collect(Collectors.toMap(LogLevel::toNumeric, logLevel -> logLevel));
-
     /**
      * Retrieve the environment logging level which is used to determine if and what we are allowed to log.
      *
      * <p>The value returned from this method should be used throughout a single logging event as it may change during
      * the logging operation, this will help prevent difficult to debug timing issues.</p>
      *
-     * @return Environment logging level if set, otherwise {@link LogLevel#DISABLED}.
+     * @return Environment logging level if set, otherwise null.
      */
     public static LogLevel getEnvironmentLoggingLevel() {
         String environmentLogLevel = Configuration.getGlobalConfiguration().get(Configuration.PROPERTY_AZURE_LOG_LEVEL);
 
-        return CoreUtils.isNullOrEmpty(environmentLogLevel)
-            ? LogLevel.DISABLED
-            : LOG_LEVEL_MAPPER.getOrDefault(Integer.parseInt(environmentLogLevel), LogLevel.DISABLED);
+        return LogLevel.fromString(environmentLogLevel);
     }
 
     // Private constructor

sdk/core/azure-core/src/main/java/com/azure/core/util/logging/ClientLogger.java

@@ -3,7 +3,6 @@
 
 package com.azure.core.util.logging;
 
-import com.azure.core.implementation.LogLevel;
 import com.azure.core.util.Configuration;
 import com.azure.core.util.CoreUtils;
 import org.slf4j.Logger;
@@ -173,6 +172,17 @@ private RuntimeException logException(RuntimeException runtimeException, LogLeve
         return runtimeException;
     }
 
+    /**
+     * Determines if the environment and logger support logging at the given log level.
+     *
+     * @param logLevel The {@link LogLevel} being validated as supported.
+     * @return Flag indicating if the environment and logger support logging at the given log level.
+     */
+    public boolean canLogAtLevel(LogLevel logLevel) {
+        LogLevel environmentLoggingLevel = getEnvironmentLoggingLevel();
+        return canLogAtLevel(logLevel, environmentLoggingLevel);
+    }
+
     /*
      * Performs the logging.
      *
@@ -198,7 +208,7 @@ private void performLogging(LogLevel logLevel, LogLevel environmentLogLevel, boo
              * Environment is logging at a level higher than verbose, strip out the throwable as it would log its
              * stack trace which is only expected when logging at a verbose level.
              */
-            if (environmentLogLevel.toNumeric() > LogLevel.VERBOSE.toNumeric()) {
+            if (environmentLogLevel.getLogLevel() > LogLevel.VERBOSE.getLogLevel()) {
                 args = removeThrowable(args);
             }
         }
@@ -236,8 +246,13 @@ private void performLogging(LogLevel logLevel, LogLevel environmentLogLevel, boo
      * @return Flag indicating if the environment and logger are configured to support logging at the given log level.
      */
     private boolean canLogAtLevel(LogLevel logLevel, LogLevel environmentLoggingLevel) {
+        // Do not log if logLevel is null or env variable is not set.
+        if (logLevel == null || environmentLoggingLevel == null) {
+            return false;
+        }
+
         // Attempting to log at a level not supported by the environment.
-        if (logLevel.toNumeric() < environmentLoggingLevel.toNumeric()) {
+        if (logLevel.getLogLevel() < environmentLoggingLevel.getLogLevel()) {
             return false;
         }
 

sdk/core/azure-core/src/main/java/com/azure/core/util/logging/LogLevel.java

@@ -0,0 +1,77 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+package com.azure.core.util.logging;
+
+import java.util.Arrays;
+import java.util.Locale;
+import java.util.Map;
+import java.util.stream.Collectors;
+import reactor.util.function.Tuple2;
+import reactor.util.function.Tuples;
+
+/**
+ * Enum which represent logging levels used in Azure SDKs.
+ */
+public enum LogLevel {
+    /**
+     * Indicates that log level is at verbose level.
+     */
+    VERBOSE("1", "verbose"),
+
+    /**
+     * Indicates that log level is at information level.
+     */
+    INFORMATIONAL("2", "info", "information", "informational"),
+
+    /**
+     * Indicates that log level is at warning level.
+     */
+    WARNING("3", "warn", "warning"),
+
+    /**
+     * Indicates that log level is at error level.
+     */
+    ERROR("4", "err", "error");
+
+    private final String[] allowedLogLevelVariables;
+
+    LogLevel(String... allowedLogLevelVariables) {
+        this.allowedLogLevelVariables = allowedLogLevelVariables;
+    }
+
+    /**
+     * Converts the log level into a numeric representation used for comparisons.
+     *
+     * @return The numeric representation of the log level.
+     */
+    public int getLogLevel() {
+        return Integer.parseInt(allowedLogLevelVariables[0]);
+    }
+
+    /**
+     * Converts the log level into string representations used for comparisons.
+     *
+     * @return The string representations of the log level.
+     */
+    private String[] getAllowedLogLevels() {
+        return allowedLogLevelVariables;
+    }
+
+    private static final Map<String, LogLevel> LOG_LEVEL_STRING_MAPPER = Arrays.stream(LogLevel.values())
+        .flatMap(logLevel -> Arrays.stream(logLevel.getAllowedLogLevels()).map(v -> Tuples.of(v, logLevel)))
+        .collect(Collectors.toMap(Tuple2::getT1, Tuple2::getT2));
+
+    /**
+     * Converts the passed log level string to the corresponding {@link LogLevel}.
+     *
+     * @param logLevelVal The log level value which needs to convert
+     * @return The LogLevel Enum.
+     */
+    public static LogLevel fromString(String logLevelVal) {
+        if (logLevelVal == null) {
+            return null;
+        }
+        return LOG_LEVEL_STRING_MAPPER.get(logLevelVal.toLowerCase(Locale.ROOT));
+    }
+}

sdk/core/azure-core/src/test/java/com/azure/core/util/logging/ClientLoggerTests.java

@@ -9,12 +9,14 @@
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
 import org.junit.jupiter.params.provider.ValueSource;
 
 import java.io.ByteArrayOutputStream;
 import java.io.PrintStream;
 import java.nio.charset.StandardCharsets;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
@@ -276,6 +278,14 @@ public void logExceptionAsErrorStackTrace() {
         assertTrue(logValues.contains(runtimeException.getStackTrace()[0].toString()));
     }
 
+    @ParameterizedTest(name = "{index} from logLevelToConfigure = {0}, logLevelToValidate={1}, expected={2}")
+    @CsvSource({"1, 1, true", "1, 2, true", "1, 3, true", "1, 4, true", "2, 1, false", "2, 5, false", "1, VERBOSE, true", "1, info, true", "1, warning, true", "1, error, true", "2, verbose, false", "2, invalid, false"})
+    public void canLogAtLevel(int logLevelToConfigure, String logLevelToValidate, boolean expected) {
+        setupLogLevel(logLevelToConfigure);
+        LogLevel logLevel = LogLevel.fromString(logLevelToValidate);
+        assertEquals(new ClientLogger(ClientLoggerTests.class).canLogAtLevel(logLevel), expected);
+    }
+
     private String setupLogLevel(int logLevelToSet) {
         String originalLogLevel = Configuration.getGlobalConfiguration().get(Configuration.PROPERTY_AZURE_CLOUD);
         System.setProperty(Configuration.PROPERTY_AZURE_LOG_LEVEL, Integer.toString(logLevelToSet));