Merge branch 'main' of github.com:splunk/splunk-library-javalogging into ci_updates

� Conflicts:
�	.gitignore

Author: zenmoto

src/main/java/com/splunk/logging/HttpEventCollectorLog4jAppender.java

@@ -16,7 +16,6 @@
  */
 
 import java.io.Serializable;
-import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
 import java.util.HashMap;
 import java.util.Map;
@@ -162,6 +161,19 @@ public static HttpEventCollectorLog4jAppender createAppender(
             @PluginElement("Filter") final Filter filter
     )
     {
+        // The raw endpoint presumes that a single post is a single event.
+        // The batch size should be 1 if "type" is raw, and we should error if batch
+        // configuration is specified.
+        int clampedBatchCountDefault = HttpEventCollectorSender.DefaultBatchCount;
+
+        if ("raw".equalsIgnoreCase(type)) {
+            if (batchSize != null || batchCount != null || batchInterval != null) {
+                LOGGER.error("batch configuration is not compatible with the raw endpoint");
+                return null;
+            }
+            clampedBatchCountDefault = 1;
+        }
+
         if (name == null)
         {
             LOGGER.error("No name provided for HttpEventCollectorLog4jAppender");
@@ -199,7 +211,7 @@ public static HttpEventCollectorLog4jAppender createAppender(
                 includeLoggerName, includeThreadName, includeMDC, includeException, includeMarker,
                 ignoreExceptionsBool,
                 parseInt(batchInterval, HttpEventCollectorSender.DefaultBatchInterval),
-                parseInt(batchCount, HttpEventCollectorSender.DefaultBatchCount),
+                parseInt(batchCount, clampedBatchCountDefault),
                 parseInt(batchSize, HttpEventCollectorSender.DefaultBatchSize),
                 parseInt(retriesOnError, 0),
                 sendMode,

src/main/java/com/splunk/logging/HttpEventCollectorLogbackAppender.java

@@ -53,6 +53,7 @@ public class HttpEventCollectorLogbackAppender<E> extends AppenderBase<E> {
     private String _sendMode;
     private long _retriesOnError = 0;
     private Map<String, String> _metadata = new HashMap<>();
+    private boolean _batchingConfigured = false;
 
 
     private HttpEventCollectorSender.TimeoutSettings timeoutSettings = new HttpEventCollectorSender.TimeoutSettings();
@@ -79,6 +80,11 @@ public void start() {
         if (_messageFormat != null)
             metadata.put(MetadataTags.MESSAGEFORMAT, _messageFormat);
 
+        // This should have been caught at configuration time, but double-check at start
+        if ("raw".equalsIgnoreCase(_type) && _batchingConfigured) {
+            throw new IllegalArgumentException("Batching configuration and sending type of raw are incompatible.");
+        }
+
         this.sender = new HttpEventCollectorSender(
                 _url, _token, _channel, _type, _batchInterval, _batchCount, _batchSize, _sendMode, metadata, timeoutSettings);
 
@@ -188,6 +194,18 @@ public String getChannel() {
 
     public void setType(String type) {
         this._type = type;
+        if ("raw".equalsIgnoreCase(type)) {
+            validateNotBatchedAndRaw();
+            this._batchCount = 1; // Enforce sending on every event
+        }
+    }
+
+    private void validateNotBatchedAndRaw() {
+        if ("raw".equalsIgnoreCase(_type)) {
+            if (_batchingConfigured) {
+                throw new IllegalArgumentException("Batching configuration and sending type of raw are incompatible.");
+            }
+        }
     }
 
     public String getType() {
@@ -292,14 +310,20 @@ public void setDisableCertificateValidation(String disableCertificateValidation)
 
     public void setbatch_size_count(String value) {
         _batchCount = parseLong(value, HttpEventCollectorSender.DefaultBatchCount);
+        _batchingConfigured = true;
+        validateNotBatchedAndRaw();
     }
 
     public void setbatch_size_bytes(String value) {
         _batchSize = parseLong(value, HttpEventCollectorSender.DefaultBatchSize);
+        _batchingConfigured = true;
+        validateNotBatchedAndRaw();
     }
 
     public void setbatch_interval(String value) {
         _batchInterval = parseLong(value, HttpEventCollectorSender.DefaultBatchInterval);
+        _batchingConfigured = true;
+        validateNotBatchedAndRaw();
     }
 
     public void setretries_on_error(String value) {

src/main/java/com/splunk/logging/HttpEventCollectorLoggingHandler.java

@@ -168,6 +168,15 @@ public HttpEventCollectorLoggingHandler() {
             getConfigurationNumericProperty(WriteTimeoutConfTag, HttpEventCollectorSender.TimeoutSettings.DEFAULT_WRITE_TIMEOUT)
         );
 
+        if ("raw".equalsIgnoreCase(type)) {
+            if (batchCount != HttpEventCollectorSender.DefaultBatchCount
+                        || batchSize != HttpEventCollectorSender.DefaultBatchSize
+                        || delay != HttpEventCollectorSender.DefaultBatchInterval) {
+                throw new IllegalArgumentException("Batching configuration and sending type of raw are incompatible.");
+            }
+            batchCount = 1;
+        }
+
         // delegate all configuration params to event sender
         this.sender = new HttpEventCollectorSender(
                 url, token, channel, type, delay, batchCount, batchSize, sendMode, metadata, timeoutSettings);

src/main/java/com/splunk/logging/HttpEventCollectorSender.java

@@ -29,7 +29,6 @@
 import java.io.Serializable;
 import java.security.cert.CertificateException;
 import java.util.*;
-import java.util.concurrent.TimeUnit;
 import java.util.stream.Collectors;
 
 
@@ -112,9 +111,13 @@ public HttpEventCollectorSender(
 
         if ("Raw".equalsIgnoreCase(type)) {
             if (channel == null || channel.trim().equals("")) {
-                throw new IllegalArgumentException("Channel cannot be null or empty");
+                this.channel = UUID.randomUUID().toString();
             }
-            HttpUrl.Builder urlBuilder = HttpUrl.parse(Url + HttpRawCollectorUriPath)
+            HttpUrl fullUrl = HttpUrl.parse(Url + HttpRawCollectorUriPath);
+            if (fullUrl == null) {
+                throw new IllegalArgumentException(String.format("Unparseable URL argument: %s",  Url + HttpEventCollectorUriPath));
+            }
+            HttpUrl.Builder urlBuilder = fullUrl
                     .newBuilder()
                     .addQueryParameter(ChannelQueryParam, channel);
             metadata.forEach(urlBuilder::addQueryParameter);