fix include by default

Author: SylvainJuge

sdk/common/src/main/java/io/opentelemetry/sdk/common/internal/IncludeExcludePredicate.java

@@ -9,6 +9,7 @@
 import static java.util.stream.Collectors.joining;
 
 import java.util.Collection;
+import java.util.Collections;
 import java.util.LinkedHashSet;
 import java.util.Set;
 import java.util.StringJoiner;
@@ -29,28 +30,29 @@
 public final class IncludeExcludePredicate implements Predicate<String> {
 
   private final boolean globMatchingEnabled;
-  @Nullable private final Set<String> included;
-  @Nullable private final Set<String> excluded;
+  private final Set<String> included;
+  private final Set<String> excluded;
   private final Predicate<String> predicate;
 
   private IncludeExcludePredicate(
       @Nullable Collection<String> included,
       @Nullable Collection<String> excluded,
       boolean globMatchingEnabled) {
     this.globMatchingEnabled = globMatchingEnabled;
-    this.included = included == null ? null : new LinkedHashSet<>(included);
-    this.excluded = excluded == null ? null : new LinkedHashSet<>(excluded);
-    if (this.included != null && this.excluded != null) {
-      this.predicate =
-          includedPredicate(this.included, globMatchingEnabled)
-              .and(excludedPredicate(this.excluded, globMatchingEnabled));
-    } else if (this.included == null && this.excluded != null) {
+    this.included = included == null ? Collections.emptySet() : new LinkedHashSet<>(included);
+    this.excluded = excluded == null ? Collections.emptySet() : new LinkedHashSet<>(excluded);
+    if (this.included.isEmpty() && this.excluded.isEmpty()) {
+      throw new IllegalArgumentException(
+          "At least one of include or exclude patterns must not be null or empty");
+    }
+    if (this.included.isEmpty()) {
       this.predicate = excludedPredicate(this.excluded, globMatchingEnabled);
-    } else if (this.excluded == null && this.included != null) {
+    } else if (this.excluded.isEmpty()) {
       this.predicate = includedPredicate(this.included, globMatchingEnabled);
     } else {
-      throw new IllegalArgumentException(
-          "At least one of includedPatterns or excludedPatterns must not be null");
+      this.predicate =
+          includedPredicate(this.included, globMatchingEnabled)
+              .and(excludedPredicate(this.excluded, globMatchingEnabled));
     }
   }
 
@@ -85,10 +87,10 @@ public boolean test(String s) {
   public String toString() {
     StringJoiner joiner = new StringJoiner(", ", "IncludeExcludePredicate{", "}");
     joiner.add("globMatchingEnabled=" + globMatchingEnabled);
-    if (included != null) {
+    if (!included.isEmpty()) {
       joiner.add("included=" + included.stream().collect(joining(", ", "[", "]")));
     }
-    if (excluded != null) {
+    if (!excluded.isEmpty()) {
       joiner.add("excluded=" + excluded.stream().collect(joining(", ", "[", "]")));
     }
     return joiner.toString();

sdk/common/src/test/java/io/opentelemetry/sdk/common/internal/IncludeExcludePredicateTest.java

@@ -9,6 +9,7 @@
 import static java.util.Collections.singletonList;
 import static org.assertj.core.api.Assertions.assertThat;
 
+import java.util.Collections;
 import java.util.function.Predicate;
 import java.util.stream.Stream;
 import org.junit.jupiter.params.ParameterizedTest;
@@ -20,7 +21,7 @@ class IncludeExcludePredicateTest {
   private static final Predicate<String> EXACT_INCLUDE =
       IncludeExcludePredicate.createExactMatching(singletonList("foo"), null);
   private static final Predicate<String> EXACT_EXCLUDE =
-      IncludeExcludePredicate.createExactMatching(null, singletonList("bar"));
+      IncludeExcludePredicate.createExactMatching(Collections.emptyList(), singletonList("bar"));
   private static final Predicate<String> EXACT_INCLUDE_AND_EXCLUDE =
       IncludeExcludePredicate.createExactMatching(singletonList("foo"), singletonList("bar"));
   private static final Predicate<String> EXACT_MULTI =