* Remove commons lang lib

CHANGELOG.md

@@ -12,6 +12,14 @@ enabling non-blocking operations. You can read more about Reactor Core and [Mono
 - [BREAKING] All synchronous query/management, streaming query/ingestion (StreamingClient) APIs now delegate to their asynchronous counterparts
 internally and block for results.
 
+## [6.0.1-ALPHA-01] - 2025-02-05
+### Added
+- Remove dependency on commons lang.
+- [BREAKING] setConnectorDetails method in ConnectionStringBuilder accepts a Map instead of varargs of Pairs.
+### Fixed
+- Some better error messages
+
+
 ## [6.0.0-ALPHA-01] - 2024-11-27
 ### Added
 - A new policy heuristic for choosing between queuing and streaming in Managed streaming client. A policy can be configured

data/pom.xml

@@ -191,11 +191,6 @@
             <groupId>com.fasterxml.jackson.core</groupId>
             <version>${fasterxml.jackson.core.version}</version>
         </dependency>
-        <dependency>
-            <groupId>org.apache.commons</groupId>
-            <artifactId>commons-lang3</artifactId>
-            <version>${commons-lang3.version}</version>
-        </dependency>
         <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-text</artifactId>

data/src/main/java/com/microsoft/azure/kusto/data/ClientDetails.java

@@ -1,63 +1,51 @@
 package com.microsoft.azure.kusto.data;
 
-import org.apache.commons.lang3.StringUtils;
-import org.apache.commons.lang3.concurrent.ConcurrentException;
-import org.apache.commons.lang3.concurrent.ConcurrentInitializer;
-import org.apache.commons.lang3.concurrent.LazyInitializer;
-import org.apache.commons.lang3.tuple.Pair;
 import reactor.util.annotation.Nullable;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.List;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.stream.Collectors;
 
 public class ClientDetails {
 
     public static final String NONE = "[none]";
-    private static ConcurrentInitializer<String> defaultApplication = new LazyInitializer() {
-        @Override
-        protected String initialize() {
-            return UriUtils.stripFileNameFromCommandLine(System.getProperty("sun.java.command"));
-        }
-    };
-    private static ConcurrentInitializer<String> defaultUser = new LazyInitializer() {
-        @Override
-        protected String initialize() {
-            String user = System.getProperty("user.name");
-            if (StringUtils.isBlank(user)) {
-                user = System.getenv("USERNAME");
-                String domain = System.getenv("USERDOMAIN");
-                if (StringUtils.isNotBlank(domain) && StringUtils.isNotBlank(user)) {
-                    user = domain + "\\" + user;
-                }
-            }
-            return StringUtils.isNotBlank(user) ? user : NONE;
-        }
-    };
-    private static ConcurrentInitializer<String> defaultVersion = new LazyInitializer() {
-        @Override
-        protected String initialize() {
-            return formatHeader(Arrays.asList(
-                    Pair.of("Kusto.Java.Client", Utils.getPackageVersion()),
-                    Pair.of(String.format("Runtime.%s", escapeField(getRuntime())), getJavaVersion())));
-        }
-    };
-    private String applicationForTracing;
-    private String userNameForTracing;
-    private String appendedClientVersionForTracing;
+
+    private static final ConcurrentHashMap<DefaultValues, String> defaultValues = new ConcurrentHashMap<>();
+
+    private final String applicationForTracing;
+    private final String userNameForTracing;
+    private final String appendedClientVersionForTracing;
 
     public ClientDetails(String applicationForTracing, String userNameForTracing, String appendedClientVersionForTracing) {
         this.applicationForTracing = applicationForTracing;
         this.userNameForTracing = userNameForTracing;
         this.appendedClientVersionForTracing = appendedClientVersionForTracing;
     }
 
-    private static String unpackLazy(ConcurrentInitializer<String> s) {
-        try {
-            return s.get();
-        } catch (ConcurrentException e) {
+    private static String unpackLazy(DefaultValues key) {
+        if(DefaultValues.DEFAULT_APPLICATION == key) {
+            return defaultValues.computeIfAbsent(key,
+                    k->UriUtils.stripFileNameFromCommandLine(System.getProperty("sun.java.command")));
+        } else if(DefaultValues.DEFAULT_USER == key) {
+            return defaultValues.computeIfAbsent(key, k -> {
+                String user = System.getProperty("user.name");
+                if (Utils.isNullOrEmpty(user)) {
+                    user = System.getenv("USERNAME");
+                    String domain = System.getenv("USERDOMAIN");
+                    if (!Utils.isNullOrEmpty(domain) && !Utils.isNullOrEmpty(user)) {
+                        user = domain + "\\" + user;
+                    }
+                }
+                return !Utils.isNullOrEmpty(user) ? user : NONE;
+            });
+        } else if(DefaultValues.DEFAULT_VERSION == key) {
+            return defaultValues.computeIfAbsent(key, k -> {
+                Map<String,String> baseMap = new LinkedHashMap<>();
+                baseMap.put("Kusto.Java.Client", Utils.getPackageVersion());
+                baseMap.put(String.format("Runtime.%s", escapeField(getRuntime())), getJavaVersion());
+                return formatHeader(baseMap);
+            });
+        } else {
             return NONE;
         }
     }
@@ -68,8 +56,10 @@ private static String unpackLazy(ConcurrentInitializer<String> s) {
      * @param args The fields to format.
      * @return The formatted string, for example: "field1:{value1}|field2:{value2}"
      */
-    private static String formatHeader(Collection<Pair<String, String>> args) {
-        return args.stream().filter(arg -> StringUtils.isNotBlank(arg.getKey()) && StringUtils.isNotBlank(arg.getValue()))
+    private static String formatHeader(Map<String, String> args) {
+        return args.entrySet().stream().
+                filter(arg -> !Utils.isNullOrEmpty(arg.getKey())
+                        && !Utils.isNullOrEmpty(arg.getValue()))
                 .map(arg -> String.format("%s:%s", arg.getKey(), escapeField(arg.getValue())))
                 .collect(Collectors.joining("|"));
     }
@@ -91,33 +81,32 @@ private static String escapeField(String field) {
      *                         Example: "Kusto.MyConnector:{1.0.0}|App.{connector}:{0.5.3}|Kusto.MyField:{MyValue}"
      */
     public static ClientDetails fromConnectorDetails(String name, String version, boolean sendUser, @Nullable String overrideUser, @Nullable String appName,
-            @Nullable String appVersion, Pair<String, String>... additionalFields) {
+            @Nullable String appVersion, Map<String, String> additionalFields) {
         // make an array
-        List<Pair<String, String>> additionalFieldsList = new ArrayList<>();
-        additionalFieldsList.add(Pair.of("Kusto." + name, version));
+        Map<String, String> additionalFieldsMap = new LinkedHashMap<>();
+        additionalFieldsMap.put("Kusto." + name, version);
 
         if (appName == null) {
-            appName = unpackLazy(defaultApplication);
+            appName = unpackLazy(DefaultValues.DEFAULT_APPLICATION);
         }
-
         if (appVersion == null) {
             appVersion = NONE;
         }
 
-        additionalFieldsList
-                .add(Pair.of(String.format("App.%s", escapeField(appName)), appVersion));
+        additionalFieldsMap
+                .put(String.format("App.%s", escapeField(appName)), appVersion);
         if (additionalFields != null) {
-            additionalFieldsList.addAll(Arrays.asList(additionalFields));
+            additionalFieldsMap.putAll(additionalFields);
         }
 
-        String app = formatHeader(additionalFieldsList);
+        String app = formatHeader(additionalFieldsMap);
 
         String user = NONE;
         if (sendUser) {
             if (overrideUser != null) {
                 user = overrideUser;
             } else {
-                user = unpackLazy(defaultUser);
+                user = unpackLazy(DefaultValues.DEFAULT_USER);
             }
         }
 
@@ -126,37 +115,51 @@ public static ClientDetails fromConnectorDetails(String name, String version, bo
 
     private static String getJavaVersion() {
         String version = System.getProperty("java.version");
-        if (StringUtils.isBlank(version)) {
+        if (Utils.isNullOrEmpty(version)) {
             return "UnknownVersion";
         }
         return version;
     }
 
     private static String getRuntime() {
         String runtime = System.getProperty("java.runtime.name");
-        if (StringUtils.isBlank(runtime)) {
+        if (Utils.isNullOrEmpty(runtime)) {
             runtime = System.getProperty("java.vm.name");
         }
-        if (StringUtils.isBlank(runtime)) {
+        if (Utils.isNullOrEmpty(runtime)) {
             runtime = System.getProperty("java.vendor");
         }
-        if (StringUtils.isBlank(runtime)) {
+        if (Utils.isNullOrEmpty(runtime)) {
             runtime = "UnknownRuntime";
         }
-
         return runtime;
     }
 
     public String getApplicationForTracing() {
-        return applicationForTracing == null ? unpackLazy(defaultApplication) : applicationForTracing;
+        return applicationForTracing == null ? unpackLazy(DefaultValues.DEFAULT_APPLICATION) : applicationForTracing;
     }
 
     public String getUserNameForTracing() {
-        return userNameForTracing == null ? unpackLazy(defaultUser) : userNameForTracing;
+        return userNameForTracing == null ? unpackLazy(DefaultValues.DEFAULT_USER) : userNameForTracing;
     }
 
     public String getClientVersionForTracing() {
-        return unpackLazy(defaultVersion) + (appendedClientVersionForTracing == null ? "" : "|" + appendedClientVersionForTracing);
+        return unpackLazy(DefaultValues.DEFAULT_VERSION) + (appendedClientVersionForTracing == null ? "" : "|" + appendedClientVersionForTracing);
     }
 
+    enum DefaultValues {
+        DEFAULT_APPLICATION("defaultApplication"),
+        DEFAULT_USER("defaultUser"),
+        DEFAULT_VERSION("defaultVersion");
+
+        private final String value;
+
+        DefaultValues(String value) {
+            this.value = value;
+        }
+
+        public String getValue() {
+            return value;
+        }
+    }
 }

data/src/main/java/com/microsoft/azure/kusto/data/ClientImpl.java

@@ -11,7 +11,7 @@
 import java.util.Map;
 import java.util.concurrent.TimeUnit;
 
-import org.apache.commons.lang3.StringUtils;
+
 import org.jetbrains.annotations.NotNull;
 
 import com.azure.core.http.HttpClient;
@@ -331,18 +331,18 @@ private Mono<KustoOperationResult> executeStreamingIngest(String clusterEndpoint
     }
 
     private String buildClusterEndpoint(String database, String table, String format, String mappingName) {
-        if (StringUtils.isBlank(database)) {
+        if (Utils.isNullOrEmpty(database)) {
             throw new IllegalArgumentException("Parameter database is empty.");
         }
-        if (StringUtils.isBlank(table)) {
+        if (Utils.isNullOrEmpty(table)) {
             throw new IllegalArgumentException("Parameter table is empty.");
         }
-        if (StringUtils.isBlank(format)) {
+        if (Utils.isNullOrEmpty(format)) {
             throw new IllegalArgumentException("Parameter format is empty.");
         }
         String clusterEndpoint = String.format(CommandType.STREAMING_INGEST.getEndpoint(), clusterUrl, database, table, format);
 
-        if (!StringUtils.isEmpty(mappingName)) {
+        if (!Utils.isNullOrEmpty(mappingName)) {
             clusterEndpoint = clusterEndpoint.concat(String.format("&mappingName=%s", mappingName));
         }
         return clusterEndpoint;

data/src/main/java/com/microsoft/azure/kusto/data/Ensure.java

@@ -6,12 +6,11 @@
 import java.io.File;
 import java.io.FileNotFoundException;
 
-import org.apache.commons.lang3.StringUtils;
 
-public class Ensure {
 
+public class Ensure {
     public static void stringIsNotBlank(String str, String varName) {
-        if (StringUtils.isBlank(str)) {
+        if (Utils.isNullOrEmpty(str)) {
             throw new IllegalArgumentException(varName + " is blank.");
         }
     }
@@ -50,7 +49,7 @@ public static void isFalse(boolean condition, String message) {
     }
 
     public static void stringIsNotEmpty(String str, String varName) {
-        if (StringUtils.isEmpty(str)) {
+        if (Utils.isNullOrEmpty(str)) {
             throw new IllegalArgumentException(varName + " is empty.");
         }
     }

data/src/main/java/com/microsoft/azure/kusto/data/KustoResultSetTable.java

@@ -3,6 +3,7 @@
 
 package com.microsoft.azure.kusto.data;
 
+
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.fasterxml.jackson.databind.node.JsonNodeType;
@@ -91,7 +92,7 @@ protected KustoResultSetTable(JsonNode jsonTable) {
         }
         tableId = jsonTable.has(TABLE_ID_PROPERTY_NAME) ? jsonTable.get(TABLE_ID_PROPERTY_NAME).asText() : EMPTY_STRING;
         String tableKindString = jsonTable.has(TABLE_KIND_PROPERTY_NAME) ? jsonTable.get(TABLE_KIND_PROPERTY_NAME).asText() : EMPTY_STRING;
-        tableKind = StringUtils.isBlank(tableKindString) ? null : WellKnownDataSet.valueOf(tableKindString);
+        tableKind = Utils.isNullOrEmpty(tableKindString) ? null : WellKnownDataSet.valueOf(tableKindString);
 
         if (jsonTable.has(COLUMNS_PROPERTY_NAME) && jsonTable.get(COLUMNS_PROPERTY_NAME).getNodeType() == JsonNodeType.ARRAY) {
             ArrayNode columnsJson = (ArrayNode) jsonTable.get(COLUMNS_PROPERTY_NAME);

data/src/main/java/com/microsoft/azure/kusto/data/StringUtils.java

@@ -1,6 +1,8 @@
 package com.microsoft.azure.kusto.data;
 
-public class StringUtils extends org.apache.commons.lang3.StringUtils {
+
+
+public class StringUtils {
     private StringUtils() {
         // Hide constructor for static class
     }
@@ -18,7 +20,7 @@ public static String getStringTail(String val, int minRuleLength) {
     }
 
     public static String normalizeEntityName(String name) {
-        if (StringUtils.isBlank(name)) {
+        if (Utils.isNullOrEmpty(name)) {
             return name;
         } else if (name.startsWith("[")) {
             return name;

data/src/main/java/com/microsoft/azure/kusto/data/Utils.java

@@ -21,6 +21,8 @@
 import com.azure.core.http.HttpHeader;
 import com.azure.core.http.HttpHeaderName;
 import com.azure.core.http.HttpResponse;
+
+import com.azure.core.util.CoreUtils;
 import com.fasterxml.jackson.core.JsonGenerator;
 import com.fasterxml.jackson.databind.DeserializationFeature;
 import com.fasterxml.jackson.databind.MapperFeature;
@@ -211,4 +213,7 @@ public static InputStream resolveInputStream(HttpResponse response, InputStream
         }
     }
 
+    public static boolean isNullOrEmpty(String str) {
+        return str == null || CoreUtils.isNullOrEmpty(str.trim());
+    }
 }