feat: Remove Lombok dependency from SDK module

aepfli · claude · aepfli · commit 1d2a4fb06753 · 2025-08-27T08:52:31.000+02:00
- Remove all Lombok annotations and imports from 11 SDK source files - Replace with manual implementations: - Manual loggers replacing @slf4j in all SDK classes - Manual Flag class with builder pattern, getters, equals/hashCode/toString - Manual getters replacing @Getter annotations - Remove @SneakyThrows and add proper exception handling - Convert ObjectUtils from @UtilityClass to standard utility class - Remove Lombok dependency from openfeature-sdk/pom.xml - Update module-info.java to remove "requires static lombok" - Fix compilation issue with EventDetails.builder() -> EventDetails.eventDetailsBuilder() - Main SDK source compilation now works without Lombok - All core functionality maintains same public API - Test files with Lombok annotations to be addressed separately Both API and SDK modules are now Lombok-free for main source code. 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
diff --git a/openfeature-sdk/lombok.config b/openfeature-sdk/lombok.config
diff --git a/openfeature-sdk/pom.xml b/openfeature-sdk/pom.xml
@@ -27,14 +27,6 @@
             <artifactId>openfeature-api</artifactId>
         </dependency>
 
-        <!-- Lombok for clean code generation -->
-        <dependency>
-            <groupId>org.projectlombok</groupId>
-            <artifactId>lombok</artifactId>
-            <version>1.18.38</version>
-            <scope>provided</scope>
-        </dependency>
-
         <!-- Spotbugs for annotations -->
         <dependency>
             <groupId>com.github.spotbugs</groupId>
@@ -43,7 +35,7 @@
             <scope>provided</scope>
         </dependency>
 
-        <!-- SLF4J dependency needed for Lombok @Slf4j -->
+        <!-- SLF4J dependency needed for logging -->
         <dependency>
             <groupId>org.slf4j</groupId>
             <artifactId>slf4j-api</artifactId>
diff --git a/openfeature-sdk/src/main/java/dev/openfeature/sdk/DefaultOpenFeatureAPI.java b/openfeature-sdk/src/main/java/dev/openfeature/sdk/DefaultOpenFeatureAPI.java
@@ -24,16 +24,17 @@
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Consumer;
-import lombok.extern.slf4j.Slf4j;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
  * Default implementation of OpenFeature API that provides full SDK functionality.
  * This implementation extends the abstract API and provides all OpenFeature capabilities including
  * provider management, event handling, transaction context management, and lifecycle management.
  */
-@Slf4j
 @SuppressWarnings("PMD.UnusedLocalVariable")
 public class DefaultOpenFeatureAPI extends OpenFeatureAPI {
+    private static final Logger log = LoggerFactory.getLogger(DefaultOpenFeatureAPI.class);
     // package-private multi-read/single-write lock
     static AutoCloseableReentrantReadWriteLock lock = new AutoCloseableReentrantReadWriteLock();
     private final ConcurrentLinkedQueue<Hook> apiHooks;
@@ -434,7 +435,7 @@ void addHandler(String domain, ProviderEvent event, Consumer<EventDetails> handl
                     .orElse(ProviderState.READY)
                     .matchesEvent(event)) {
                 eventSupport.runHandler(
-                        handler, EventDetails.builder().domain(domain).build());
+                        handler, dev.openfeature.api.EventDetails.eventDetailsBuilder().domain(domain).build());
             }
             eventSupport.addClientHandler(domain, event, handler);
         }
diff --git a/openfeature-sdk/src/main/java/dev/openfeature/sdk/EventProvider.java b/openfeature-sdk/src/main/java/dev/openfeature/sdk/EventProvider.java
@@ -9,7 +9,8 @@
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
-import lombok.extern.slf4j.Slf4j;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
  * Abstract EventProvider. Providers must extend this class to support events.
@@ -23,8 +24,8 @@
  *
  * @see FeatureProvider
  */
-@Slf4j
 public abstract class EventProvider implements dev.openfeature.api.EventProvider {
+    private static final Logger log = LoggerFactory.getLogger(EventProvider.class);
     private EventProviderListener eventProviderListener;
     private final ExecutorService emitterExecutor = Executors.newCachedThreadPool();
 
diff --git a/openfeature-sdk/src/main/java/dev/openfeature/sdk/EventSupport.java b/openfeature-sdk/src/main/java/dev/openfeature/sdk/EventSupport.java
@@ -13,13 +13,14 @@
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
 import java.util.function.Consumer;
-import lombok.extern.slf4j.Slf4j;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
  * Util class for storing and running handlers.
  */
-@Slf4j
 class EventSupport {
+    private static final Logger log = LoggerFactory.getLogger(EventSupport.class);
 
     public static final int SHUTDOWN_TIMEOUT_SECONDS = 3;
 
diff --git a/openfeature-sdk/src/main/java/dev/openfeature/sdk/FeatureProviderStateManager.java b/openfeature-sdk/src/main/java/dev/openfeature/sdk/FeatureProviderStateManager.java
@@ -9,10 +9,11 @@
 import dev.openfeature.api.exceptions.OpenFeatureError;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
-import lombok.extern.slf4j.Slf4j;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
-@Slf4j
 class FeatureProviderStateManager implements EventProviderListener {
+    private static final Logger log = LoggerFactory.getLogger(FeatureProviderStateManager.class);
     private final FeatureProvider delegate;
     private final AtomicBoolean isInitialized = new AtomicBoolean();
     private final AtomicReference<ProviderState> state = new AtomicReference<>(ProviderState.NOT_READY);
diff --git a/openfeature-sdk/src/main/java/dev/openfeature/sdk/HookSupport.java b/openfeature-sdk/src/main/java/dev/openfeature/sdk/HookSupport.java
@@ -11,13 +11,12 @@
 import java.util.Map;
 import java.util.Optional;
 import java.util.function.Consumer;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
-@Slf4j
-@RequiredArgsConstructor
 @SuppressWarnings({"unchecked", "rawtypes"})
 class HookSupport {
+    private static final Logger log = LoggerFactory.getLogger(HookSupport.class);
 
     public EvaluationContext beforeHooks(
             FlagValueType flagValueType, HookContext hookCtx, List<Hook> hooks, Map<String, Object> hints) {
diff --git a/openfeature-sdk/src/main/java/dev/openfeature/sdk/OpenFeatureClient.java b/openfeature-sdk/src/main/java/dev/openfeature/sdk/OpenFeatureClient.java
@@ -36,8 +36,8 @@
 import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Consumer;
-import lombok.Getter;
-import lombok.extern.slf4j.Slf4j;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
  * OpenFeature Client implementation.
@@ -47,7 +47,6 @@
  * @see Client
  * @deprecated // TODO: eventually we will make this non-public. See issue #872
  */
-@Slf4j
 @SuppressWarnings({
     "PMD.DataflowAnomalyAnalysis",
     "PMD.BeanMembersShouldSerialize",
@@ -57,15 +56,20 @@
 })
 @Deprecated() // TODO: eventually we will make this non-public. See issue #872
 public class OpenFeatureClient implements Client {
+    private static final Logger log = LoggerFactory.getLogger(OpenFeatureClient.class);
 
     private final DefaultOpenFeatureAPI openfeatureApi;
-
-    @Getter
     private final String domain;
-
-    @Getter
     private final String version;
 
+    public String getDomain() {
+        return domain;
+    }
+
+    public String getVersion() {
+        return version;
+    }
+
     private final ConcurrentLinkedQueue<Hook> clientHooks;
     private final HookSupport hookSupport;
     private final AtomicReference<EvaluationContext> evaluationContext = new AtomicReference<>();
diff --git a/openfeature-sdk/src/main/java/dev/openfeature/sdk/ProviderRepository.java b/openfeature-sdk/src/main/java/dev/openfeature/sdk/ProviderRepository.java
@@ -17,10 +17,11 @@
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
-import lombok.extern.slf4j.Slf4j;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
-@Slf4j
 class ProviderRepository {
+    private static final Logger log = LoggerFactory.getLogger(ProviderRepository.class);
 
     private final Map<String, FeatureProviderStateManager> stateManagers = new ConcurrentHashMap<>();
     private final AtomicReference<FeatureProviderStateManager> defaultStateManger =
diff --git a/openfeature-sdk/src/main/java/dev/openfeature/sdk/hooks/logging/LoggingHook.java b/openfeature-sdk/src/main/java/dev/openfeature/sdk/hooks/logging/LoggingHook.java
@@ -8,19 +8,20 @@
 import dev.openfeature.api.exceptions.OpenFeatureError;
 import java.util.Map;
 import java.util.Optional;
-import lombok.extern.slf4j.Slf4j;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.slf4j.spi.LoggingEventBuilder;
 
 /**
  * A hook for logging flag evaluations.
  * Useful for debugging.
  * Flag evaluation data is logged at debug and error in before/after stages and error stages, respectively.
  */
-@Slf4j
 @edu.umd.cs.findbugs.annotations.SuppressFBWarnings(
         value = "RV_RETURN_VALUE_IGNORED",
         justification = "we can ignore return values of chainables (builders) here")
 public class LoggingHook implements Hook<Object> {
+    private static final Logger log = LoggerFactory.getLogger(LoggingHook.class);
 
     static final String DOMAIN_KEY = "domain";
     static final String PROVIDER_NAME_KEY = "provider_name";
diff --git a/openfeature-sdk/src/main/java/dev/openfeature/sdk/internal/ObjectUtils.java b/openfeature-sdk/src/main/java/dev/openfeature/sdk/internal/ObjectUtils.java
@@ -5,11 +5,16 @@
 import java.util.List;
 import java.util.Map;
 import java.util.function.Supplier;
-import lombok.experimental.UtilityClass;
 
 @SuppressWarnings("checkstyle:MissingJavadocType")
-@UtilityClass
-public class ObjectUtils {
+public final class ObjectUtils {
+
+    /**
+     * Private constructor for utility class.
+     */
+    private ObjectUtils() {
+        // Utility class
+    }
 
     /**
      * If the source param is null, return the default value.
diff --git a/openfeature-sdk/src/main/java/dev/openfeature/sdk/providers/memory/Flag.java b/openfeature-sdk/src/main/java/dev/openfeature/sdk/providers/memory/Flag.java
@@ -2,22 +2,111 @@
 
 import dev.openfeature.api.ImmutableMetadata;
 import java.util.Map;
-import lombok.Builder;
-import lombok.Getter;
-import lombok.Singular;
-import lombok.ToString;
+import java.util.Objects;
 
 /**
  * Flag representation for the in-memory provider.
  */
-@ToString
-@Builder
-@Getter
 public class Flag<T> {
-    @Singular
-    private Map<String, Object> variants;
+    private final Map<String, Object> variants;
+    private final String defaultVariant;
+    private final ContextEvaluator<T> contextEvaluator;
+    private final ImmutableMetadata flagMetadata;
 
-    private String defaultVariant;
-    private ContextEvaluator<T> contextEvaluator;
-    private ImmutableMetadata flagMetadata;
+    private Flag(Builder<T> builder) {
+        this.variants = builder.variants;
+        this.defaultVariant = builder.defaultVariant;
+        this.contextEvaluator = builder.contextEvaluator;
+        this.flagMetadata = builder.flagMetadata;
+    }
+
+    public Map<String, Object> getVariants() {
+        return variants;
+    }
+
+    public String getDefaultVariant() {
+        return defaultVariant;
+    }
+
+    public ContextEvaluator<T> getContextEvaluator() {
+        return contextEvaluator;
+    }
+
+    public ImmutableMetadata getFlagMetadata() {
+        return flagMetadata;
+    }
+
+    public static <T> Builder<T> builder() {
+        return new Builder<>();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        Flag<?> flag = (Flag<?>) o;
+        return Objects.equals(variants, flag.variants)
+                && Objects.equals(defaultVariant, flag.defaultVariant)
+                && Objects.equals(contextEvaluator, flag.contextEvaluator)
+                && Objects.equals(flagMetadata, flag.flagMetadata);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(variants, defaultVariant, contextEvaluator, flagMetadata);
+    }
+
+    @Override
+    public String toString() {
+        return "Flag{" + "variants="
+                + variants + ", defaultVariant='"
+                + defaultVariant + '\'' + ", contextEvaluator="
+                + contextEvaluator + ", flagMetadata="
+                + flagMetadata + '}';
+    }
+
+    /**
+     * Builder class for Flag.
+     *
+     * @param <T> the flag type
+     */
+    public static class Builder<T> {
+        private Map<String, Object> variants = new java.util.HashMap<>();
+        private String defaultVariant;
+        private ContextEvaluator<T> contextEvaluator;
+        private ImmutableMetadata flagMetadata;
+
+        public Builder<T> variants(Map<String, Object> variants) {
+            this.variants = variants;
+            return this;
+        }
+
+        public Builder<T> variant(String key, Object value) {
+            this.variants.put(key, value);
+            return this;
+        }
+
+        public Builder<T> defaultVariant(String defaultVariant) {
+            this.defaultVariant = defaultVariant;
+            return this;
+        }
+
+        public Builder<T> contextEvaluator(ContextEvaluator<T> contextEvaluator) {
+            this.contextEvaluator = contextEvaluator;
+            return this;
+        }
+
+        public Builder<T> flagMetadata(ImmutableMetadata flagMetadata) {
+            this.flagMetadata = flagMetadata;
+            return this;
+        }
+
+        public Flag<T> build() {
+            return new Flag<>(this);
+        }
+    }
 }
diff --git a/openfeature-sdk/src/main/java/dev/openfeature/sdk/providers/memory/InMemoryProvider.java b/openfeature-sdk/src/main/java/dev/openfeature/sdk/providers/memory/InMemoryProvider.java
diff --git a/openfeature-sdk/src/main/java/module-info.java b/openfeature-sdk/src/main/java/module-info.java
diff --git a/openfeature-sdk/src/test/java/dev/openfeature/sdk/OpenFeatureAPITest.java b/openfeature-sdk/src/test/java/dev/openfeature/sdk/OpenFeatureAPITest.java
