Fix bugs, ZIO anti-patterns, and optimize ZIO runloop performance

Jules Ivanic · guizmaii · commit bb86ba5b007f · 2026-04-09T15:26:39.000+10:00
- Fix integer overflow in ContextConverter.valueToAttribute for large Long values
- Fix FlagValueType.fromFlagType mapping Long and Float to Object instead of Int/Double
- Fix Clock.nanoTime / System.nanoTime() inconsistency in hooks
- Suspend side effects in ZIO.suspendSucceed instead of eager execution
- Use Exit.succeed/Exit.unit/Exit.none inside ZIO combinators for faster runloop
- Replace ZIO.collectAllParDiscard with sequential chain for trivial Ref ops
- Replace tapBoth with no-op error handler by tap
- Use try/catch + NonFatal instead of ZIO.attempt for non-blocking Java calls
diff --git a/core/src/main/scala-2/zio/openfeature/FlagValueType.scala b/core/src/main/scala-2/zio/openfeature/FlagValueType.scala
@@ -24,6 +24,8 @@ object FlagValueType {
       case "Boolean" => Boolean
       case "String"  => String
       case "Int"     => Int
+      case "Long"    => Int
+      case "Float"   => Double
       case "Double"  => Double
       case _         => Object
     }
diff --git a/core/src/main/scala-3/zio/openfeature/FlagValueType.scala b/core/src/main/scala-3/zio/openfeature/FlagValueType.scala
@@ -17,5 +17,7 @@ object FlagValueType:
       case "Boolean" => Boolean
       case "String"  => String
       case "Int"     => Int
+      case "Long"    => Int
+      case "Float"   => Double
       case "Double"  => Double
       case _         => Object
diff --git a/core/src/main/scala/zio/openfeature/FeatureFlagRegistry.scala b/core/src/main/scala/zio/openfeature/FeatureFlagRegistry.scala
@@ -60,34 +60,28 @@ final private class FeatureFlagRegistryLive(
 
   override def getClient(domain: String): UIO[FeatureFlags] =
     lock.withPermit {
-      clients.get.map(_.get(domain)).flatMap {
-        case Some(c) => ZIO.succeed(c)
+      clients.get.flatMap(_.get(domain) match {
+        case Some(c) => Exit.succeed(c)
         case None    => createDomainClient(domain)
-      }
+      })
     }
 
   override def setProvider(domain: String, provider: OFFeatureProvider): IO[FeatureFlagError, Unit] =
     lock.withPermit {
-      for {
-        existing <- clients.get.map(_.get(domain))
-        _ <- existing match {
-          case Some(client) =>
-            client
-              .setProvider(provider)
-              .tapBoth(
-                _ => ZIO.unit,
-                _ => providers.update(_ + (domain -> provider))
-              )
-          case None =>
-            providers.update(_ + (domain -> provider))
-        }
-      } yield ()
+      clients.get.flatMap(_.get(domain) match {
+        case Some(client) =>
+          client
+            .setProvider(provider)
+            .tap(_ => providers.update(_ + (domain -> provider)))
+        case None =>
+          providers.update(_ + (domain -> provider))
+      })
     }
 
   override def defaultClient: UIO[FeatureFlags] =
     lock.withPermit {
       defaultRef.get.flatMap {
-        case Some(c) => ZIO.succeed(c)
+        case Some(c) => Exit.succeed(c)
         case None    => createDefaultClient
       }
     }
diff --git a/core/src/main/scala/zio/openfeature/FeatureFlagsLive.scala b/core/src/main/scala/zio/openfeature/FeatureFlagsLive.scala
@@ -5,18 +5,20 @@ import zio.stream._
 import zio.openfeature.internal.{ClientEvaluator, ContextConverter, ErrorCodeConverter, FeatureFlagsState}
 import dev.openfeature.sdk.{
   Client => OFClient,
-  FeatureProvider => OFFeatureProvider,
-  FlagEvaluationDetails,
-  Reason => OFReason,
   ErrorCode => OFErrorCode,
-  OpenFeatureAPI,
-  MutableTrackingEventDetails,
+  FeatureProvider => OFFeatureProvider,
+  FlagValueType => JavaFlagValueType,
+  HookContext => JavaHookContext,
   ProviderEvent => JavaProviderEvent,
+  Reason => OFReason,
   EventDetails,
-  FlagValueType => JavaFlagValueType,
-  HookContext => JavaHookContext
+  FlagEvaluationDetails,
+  MutableTrackingEventDetails,
+  OpenFeatureAPI
 }
+
 import scala.jdk.CollectionConverters._
+import scala.util.control.NonFatal
 
 final private[openfeature] class FeatureFlagsLive(
   client: OFClient,
@@ -47,7 +49,9 @@ final private[openfeature] class FeatureFlagsLive(
           val javaMeta = details.getEventMetadata
           if (javaMeta == null || javaMeta.isEmpty) FlagMetadata.empty
           else convertImmutableMetadata(javaMeta)
-        } catch { case _: Exception => FlagMetadata.empty }
+        } catch {
+          case _: Exception => FlagMetadata.empty
+        }
 
       val readyHandler: java.util.function.Consumer[EventDetails] = details =>
         Unsafe.unsafe { implicit u =>
@@ -195,7 +199,7 @@ final private[openfeature] class FeatureFlagsLive(
       case ProviderStatus.Fatal    => ZIO.fail(FeatureFlagError.ProviderFatal)
       case ProviderStatus.NotReady => ZIO.fail(FeatureFlagError.ProviderNotReady(ProviderStatus.NotReady))
       case ProviderStatus.Error    => ZIO.fail(FeatureFlagError.ProviderNotReady(ProviderStatus.Error))
-      case _                       => ZIO.unit
+      case _                       => Exit.unit
     }
 
   // Context is already merged by evaluateWithDetails before entering the hook pipeline
@@ -609,7 +613,7 @@ final private[openfeature] class FeatureFlagsLive(
   override def currentEvaluatedFlags: UIO[Map[String, zio.openfeature.FlagEvaluation[_]]] =
     state.transactionRef.get.flatMap {
       case Some(ts) => ts.getEvaluations
-      case None     => ZIO.succeed(Map.empty)
+      case None     => Exit.succeed(Map.empty)
     }
 
   override def events: ZStream[Any, Nothing, ProviderEvent] =
@@ -715,13 +719,16 @@ final private[openfeature] class FeatureFlagsLive(
 
   private def getProviderHooks: UIO[List[FeatureHook]] =
     providerRef.get.flatMap { p =>
-      ZIO
-        .attempt {
-          val javaHooks = p.getProviderHooks
+      try {
+        val javaHooks = p.getProviderHooks
+        val res =
           if (javaHooks == null || javaHooks.isEmpty) Nil
           else javaHooks.asScala.toList.map(wrapJavaHook)
-        }
-        .catchAll(e => ZIO.logWarning(s"Failed to get provider hooks: ${e.getMessage}").as(Nil))
+        Exit.succeed(res)
+      } catch {
+        case NonFatal(e) =>
+          ZIO.logWarningCause(s"Failed to get provider hooks", Cause.fail(e)).as(Nil)
+      }
     }
 
   @scala.annotation.nowarn("msg=deprecated")
@@ -766,17 +773,17 @@ final private[openfeature] class FeatureFlagsLive(
     val hook = javaHook.asInstanceOf[dev.openfeature.sdk.Hook[Any]]
     new FeatureHook {
       override def before(ctx: HookContext, hints: HookHints): UIO[Option[(EvaluationContext, HookHints)]] =
-        ZIO
-          .attempt {
+        ZIO.succeed {
+          try {
             val jCtx   = toJavaHookContext(ctx)
             val jHints = hints.values.map { case (k, v) => k -> v.asInstanceOf[Object] }.asJava
             val result = hook.before(jCtx, jHints)
             if (result != null && result.isPresent) {
               val newCtx = fromJavaEvaluationContext(result.get())
               Some((newCtx, hints))
             } else None
-          }
-          .catchAll(_ => ZIO.none)
+          } catch { case NonFatal(_) => None }
+        }
 
       override def after[A](ctx: HookContext, details: FlagResolution[A], hints: HookHints): UIO[Unit] =
         ZIO.attempt {
@@ -846,15 +853,13 @@ final private[openfeature] class FeatureFlagsLive(
   // Shutdown API (spec 1.6.1, 1.6.2)
 
   override def shutdown: UIO[Unit] =
-    ZIO.collectAllParDiscard(
-      List(
-        state.statusRef.set(ProviderStatus.NotReady),
-        state.hooksRef.set(List.empty),
-        state.globalContextRef.set(EvaluationContext.empty),
-        state.clientContextRef.set(EvaluationContext.empty),
-        state.trackRecorder.set(List.empty)
-      )
-    ) *> state.eventHub.shutdown *> ZIO.attemptBlocking(api.shutdown()).ignore
+    state.statusRef.set(ProviderStatus.NotReady) *>
+      state.hooksRef.set(List.empty) *>
+      state.globalContextRef.set(EvaluationContext.empty) *>
+      state.clientContextRef.set(EvaluationContext.empty) *>
+      state.trackRecorder.set(List.empty) *>
+      state.eventHub.shutdown *>
+      ZIO.attemptBlocking(api.shutdown()).ignore
 
   // Tracking API
 
diff --git a/core/src/main/scala/zio/openfeature/Hook.scala b/core/src/main/scala/zio/openfeature/Hook.scala
@@ -49,6 +49,9 @@ final class HookData {
   def getOrElse[A](key: TypedKey[A], default: => A): A =
     get(key).getOrElse(default)
 
+  private[openfeature] def getOrNull(key: TypedKey[_]): Any =
+    data.get().getOrElse(key.name, null)
+
   def remove[A](key: TypedKey[A]): Unit = {
     data.updateAndGet(_ - key.name)
     ()
@@ -267,23 +270,22 @@ object FeatureHook {
     // so that `before` can return None and avoid corrupting the compose pipeline's
     // context-modified tracking.
     override def before(ctx: HookContext, hints: HookHints): UIO[Option[(EvaluationContext, HookHints)]] =
-      for {
-        now <- Clock.nanoTime
-        _ = ctx.hookData.set(startTimeKey, now)
-        _ <- beforeLevel match {
+      ZIO.suspendSucceed {
+        ctx.hookData.set(startTimeKey, java.lang.System.nanoTime())
+        beforeLevel match {
           case Some(level) =>
             annotate(baseAnnotations(ctx) ++ contextAnnotations(ctx))(
               logAtLevel(level, s"Evaluating flag '${ctx.flagKey}'")
-            )
-          case None => ZIO.unit
+            ).as(None)
+          case None => Exit.none
         }
-      } yield None
+      }
 
-    private def elapsed(ctx: HookContext): Duration = {
-      val end   = java.lang.System.nanoTime()
-      val start = ctx.hookData.get(startTimeKey).getOrElse(end)
-      Duration.fromNanos(end - start)
-    }
+    private def elapsed(ctx: HookContext): Duration =
+      ctx.hookData.getOrNull(startTimeKey) match {
+        case null  => Duration.Zero
+        case start => Duration.fromNanos(java.lang.System.nanoTime() - start.asInstanceOf[Long])
+      }
 
     override def after[A](ctx: HookContext, details: FlagResolution[A], hints: HookHints): UIO[Unit] =
       afterLevel match {
@@ -361,24 +363,28 @@ object FeatureHook {
     private val startTimeKey = TypedKey[Long]("metricsDetailed.startTime")
 
     override def before(ctx: HookContext, hints: HookHints): UIO[Option[(EvaluationContext, HookHints)]] =
-      for {
-        now <- Clock.nanoTime
-        _ = ctx.hookData.set(startTimeKey, now)
-      } yield None
-
-    override def after[A](ctx: HookContext, details: FlagResolution[A], hints: HookHints): UIO[Unit] = {
-      val end      = java.lang.System.nanoTime()
-      val start    = ctx.hookData.get(startTimeKey).getOrElse(end)
-      val duration = Duration.fromNanos(end - start)
-      onSuccess(ctx, details, duration)
-    }
+      ZIO.succeed {
+        ctx.hookData.set(startTimeKey, java.lang.System.nanoTime())
+        None
+      }
 
-    override def error(ctx: HookContext, err: FeatureFlagError, hints: HookHints): UIO[Unit] = {
-      val end      = java.lang.System.nanoTime()
-      val start    = ctx.hookData.get(startTimeKey).getOrElse(end)
-      val duration = Duration.fromNanos(end - start)
-      onError(ctx, err, duration)
-    }
+    override def after[A](ctx: HookContext, details: FlagResolution[A], hints: HookHints): UIO[Unit] =
+      ZIO.suspendSucceed {
+        val duration = ctx.hookData.getOrNull(startTimeKey) match {
+          case null  => Duration.Zero
+          case start => Duration.fromNanos(java.lang.System.nanoTime() - start.asInstanceOf[Long])
+        }
+        onSuccess(ctx, details, duration)
+      }
+
+    override def error(ctx: HookContext, err: FeatureFlagError, hints: HookHints): UIO[Unit] =
+      ZIO.suspendSucceed {
+        val duration = ctx.hookData.getOrNull(startTimeKey) match {
+          case null  => Duration.Zero
+          case start => Duration.fromNanos(java.lang.System.nanoTime() - start.asInstanceOf[Long])
+        }
+        onError(ctx, err, duration)
+      }
   }
 
   def contextValidator(
diff --git a/core/src/main/scala/zio/openfeature/internal/ContextConverter.scala b/core/src/main/scala/zio/openfeature/internal/ContextConverter.scala
@@ -75,9 +75,13 @@ private[openfeature] object ContextConverter {
     if (value.isBoolean) AttributeValue.BoolValue(value.asBoolean())
     else if (value.isString) AttributeValue.StringValue(value.asString())
     else if (value.isNumber) {
-      val num = value.asDouble()
-      if (num == num.toLong.toDouble) AttributeValue.IntValue(num.toInt)
-      else AttributeValue.DoubleValue(num)
+      val num           = value.asDouble()
+      val l             = num.toLong
+      val isWholeNumber = num == l.toDouble
+      if (isWholeNumber) {
+        if (l >= Int.MinValue && l <= Int.MaxValue) AttributeValue.IntValue(l.toInt)
+        else AttributeValue.LongValue(l)
+      } else AttributeValue.DoubleValue(num)
     } else if (value.isList) {
       val list = value.asList().asScala.map(valueToAttribute).toList
       AttributeValue.ListValue(list)
diff --git a/core/src/test/scala/zio/openfeature/EvaluationContextSpec.scala b/core/src/test/scala/zio/openfeature/EvaluationContextSpec.scala
@@ -232,6 +232,26 @@ object EvaluationContextSpec extends ZIOSpecDefault {
         val ofCtx     = zio.openfeature.internal.ContextConverter.toOpenFeature(ctx)
         val roundTrip = zio.openfeature.internal.ContextConverter.fromOpenFeature(ofCtx)
         assertTrue(roundTrip.targetingKey == None)
+      },
+      test("Long value larger than Int.MaxValue survives roundtrip as LongValue") {
+        val big       = Int.MaxValue.toLong + 1L
+        val ctx       = EvaluationContext.empty.withAttribute("big", AttributeValue.LongValue(big))
+        val ofCtx     = zio.openfeature.internal.ContextConverter.toOpenFeature(ctx)
+        val roundTrip = zio.openfeature.internal.ContextConverter.fromOpenFeature(ofCtx)
+        assertTrue(roundTrip.get("big") == Some(AttributeValue.LongValue(big)))
+      },
+      test("Long value smaller than Int.MinValue survives roundtrip as LongValue") {
+        val small     = Int.MinValue.toLong - 1L
+        val ctx       = EvaluationContext.empty.withAttribute("small", AttributeValue.LongValue(small))
+        val ofCtx     = zio.openfeature.internal.ContextConverter.toOpenFeature(ctx)
+        val roundTrip = zio.openfeature.internal.ContextConverter.fromOpenFeature(ofCtx)
+        assertTrue(roundTrip.get("small") == Some(AttributeValue.LongValue(small)))
+      },
+      test("Long value within Int range roundtrips as IntValue") {
+        val ctx       = EvaluationContext.empty.withAttribute("n", AttributeValue.LongValue(42L))
+        val ofCtx     = zio.openfeature.internal.ContextConverter.toOpenFeature(ctx)
+        val roundTrip = zio.openfeature.internal.ContextConverter.fromOpenFeature(ofCtx)
+        assertTrue(roundTrip.get("n") == Some(AttributeValue.IntValue(42)))
       }
     )
   )
diff --git a/core/src/test/scala/zio/openfeature/HookSpec.scala b/core/src/test/scala/zio/openfeature/HookSpec.scala
@@ -65,6 +65,14 @@ object HookSpec extends ZIOSpecDefault {
         val fvt = FlagValueType.fromFlagType[Double]
         assertTrue(fvt == FlagValueType.Double)
       },
+      test("fromFlagType returns Int for Long") {
+        val fvt = FlagValueType.fromFlagType[Long]
+        assertTrue(fvt == FlagValueType.Int)
+      },
+      test("fromFlagType returns Double for Float") {
+        val fvt = FlagValueType.fromFlagType[Float]
+        assertTrue(fvt == FlagValueType.Double)
+      },
       test("fromFlagType returns Object for Map") {
         val fvt = FlagValueType.fromFlagType[Map[String, Any]]
         assertTrue(fvt == FlagValueType.Object)

Original file line number	Diff line number	Diff line change
`@@ -24,6 +24,8 @@ object FlagValueType {`
`24`	`24`	`case "Boolean" => Boolean`
`25`	`25`	`case "String" => String`
`26`	`26`	`case "Int" => Int`
	`27`	`+ case "Long" => Int`
	`28`	`+ case "Float" => Double`
`27`	`29`	`case "Double" => Double`
`28`	`30`	`case _ => Object`
`29`	`31`	`}`