remove TamerError from signatures, run and runWith lift errors into failures, examples remove .exitCode which converts failures into exit code 1 and swallows traces (#1377)

sirocchj · web-flow · commit f5825378c1b3 · 2024-01-23T15:05:01.000+01:00
diff --git a/core/src/main/scala/tamer/Registry.scala b/core/src/main/scala/tamer/Registry.scala
@@ -92,10 +92,10 @@ object Registry {
     override final def verifySchema(id: Int, schema: Schema): Task[Unit]           = ZIO.unit
   }
 
-  private[tamer] final val fakeRegistryZIO: ZIO[Scope, TamerError, Registry] = ZIO.succeed(Registry.FakeRegistry)
+  private[tamer] final val fakeRegistryZIO: RIO[Scope, Registry] = ZIO.succeed(Registry.FakeRegistry)
 }
 
-final case class RegistryProvider(from: RegistryConfig => ZIO[Scope, TamerError, Registry])
+final case class RegistryProvider(from: RegistryConfig => RIO[Scope, Registry])
 
 object RegistryProvider {
   implicit final val defaultRegistryProvider: RegistryProvider = RegistryProvider { config =>
diff --git a/core/src/main/scala/tamer/Serdes.scala b/core/src/main/scala/tamer/Serdes.scala
@@ -32,15 +32,15 @@ sealed trait Serdes[K, V, SV] {
     "  - \u001b[36mtamer.RegistryProvider\u001b[0m\n"
 )
 sealed trait SerdesProvider[K, V, SV] {
-  def using(maybeRegistryConfig: Option[RegistryConfig]): ZIO[Scope, TamerError, Serdes[K, V, SV]]
+  def using(maybeRegistryConfig: Option[RegistryConfig]): RIO[Scope, Serdes[K, V, SV]]
 }
 
 object SerdesProvider {
   implicit final def serdesProviderFromCodecs[K: Codec, V: Codec, SV: Codec](
       implicit SK: Codec[Tamer.StateKey],
       registryProvider: RegistryProvider
   ): SerdesProvider[K, V, SV] = new SerdesProvider[K, V, SV] {
-    override final def using(maybeRegistryConfig: Option[RegistryConfig]): ZIO[Scope, TamerError, Serdes[K, V, SV]] =
+    override final def using(maybeRegistryConfig: Option[RegistryConfig]): RIO[Scope, Serdes[K, V, SV]] =
       maybeRegistryConfig.fold(Registry.fakeRegistryZIO)(registryProvider.from(_)).map { registry =>
         new Serdes[K, V, SV] {
           override final val keySerializer: Serializer[Any, K]          = Serde.key[K].using(registry)
diff --git a/core/src/main/scala/tamer/Setup.scala b/core/src/main/scala/tamer/Setup.scala
@@ -9,7 +9,6 @@ abstract class Setup[-R, K: Tag, V: Tag, SV: Tag](implicit val serdesProvider: S
   val repr: String = "no repr string implemented, if you want a neat description of the source configuration please implement it"
   def iteration(currentState: SV, queue: Enqueue[NonEmptyChunk[(K, V)]]): RIO[R, SV]
 
-  final val run: ZIO[R with KafkaConfig, TamerError, Unit] = runLoop.provideSomeLayer(Tamer.live(this))
-  final def runWith[E >: TamerError, R1](layer: Layer[E, R with KafkaConfig with R1]): IO[E, Unit] =
-    runLoop.provideLayer(layer >>> Tamer.live(this))
+  final val run: RIO[R with KafkaConfig, Unit]                                    = runLoop.provideSomeLayer(Tamer.live(this)).orDie
+  final def runWith[R1](layer: TaskLayer[R with KafkaConfig with R1]): Task[Unit] = runLoop.provideLayer(layer >>> Tamer.live(this)).orDie
 }
diff --git a/core/src/main/scala/tamer/Tamer.scala b/core/src/main/scala/tamer/Tamer.scala
@@ -13,7 +13,7 @@ import zio.kafka.serde.{Serde => ZSerde, Serializer}
 import zio.stream.{Stream, ZStream}
 
 trait Tamer {
-  def runLoop: IO[TamerError, Unit]
+  def runLoop: Task[Unit]
 }
 
 object Tamer {
@@ -24,11 +24,6 @@ object Tamer {
 
   private[this] final val tenTimes = Schedule.recurs(10L) && Schedule.exponential(100.milliseconds) // FIXME make configurable
 
-  private[this] final val tamerErrors: PartialFunction[Throwable, TamerError] = {
-    case ke: KafkaException => TamerError(ke.getLocalizedMessage, ke)
-    case te: TamerError     => te
-  }
-
   private[this] implicit final class OffsetOps(private val _underlying: Offset) extends AnyVal {
     def info: String = s"${_underlying.topicPartition}@${_underlying.offset}"
   }
@@ -203,16 +198,12 @@ object Tamer {
       runSink <&> runSource
     }
 
-    override val runLoop: IO[TamerError, Unit] = {
-      val logic = for {
-        log   <- logTask
-        _     <- log.info(s"initializing Tamer with setup: \n$repr")
-        queue <- Queue.bounded[(TransactionInfo, Chunk[(K, V)])](config.bufferSize)
-        _     <- runLoop(queue, log)
-      } yield ()
-
-      logic.refineOrDie(tamerErrors)
-    }
+    override val runLoop: Task[Unit] = for {
+      log   <- logTask
+      _     <- log.info(s"initializing Tamer with setup: \n$repr")
+      queue <- Queue.bounded[(TransactionInfo, Chunk[(K, V)])](config.bufferSize)
+      _     <- runLoop(queue, log)
+    } yield ()
   }
 
   object LiveTamer {
@@ -224,7 +215,7 @@ object Tamer {
         stateKey: Int,
         iterationFunction: (SV, Enqueue[NonEmptyChunk[(K, V)]]) => Task[SV],
         repr: String
-    ): ZIO[Scope, TamerError, LiveTamer[K, V, SV]] = {
+    ): RIO[Scope, LiveTamer[K, V, SV]] = {
 
       val KafkaConfig(brokers, _, closeTimeout, _, _, StateConfig(_, groupId, clientId), transactionalId, properties) = config
 
@@ -251,9 +242,7 @@ object Tamer {
         .mapError(TamerError("Could not build Kafka client", _))
     }
 
-    private[tamer] final def getLayer[R, K: Tag, V: Tag, SV: Tag](
-        setup: Setup[R, K, V, SV]
-    ): ZLayer[R with KafkaConfig, TamerError, Tamer] =
+    private[tamer] final def getLayer[R, K: Tag, V: Tag, SV: Tag](setup: Setup[R, K, V, SV]): RLayer[R with KafkaConfig, Tamer] =
       ZLayer.scoped[R with KafkaConfig] {
         for {
           config <- ZIO.service[KafkaConfig]
@@ -265,7 +254,5 @@ object Tamer {
       }
   }
 
-  final def live[R, K: Tag, V: Tag, SV: Tag](
-      setup: Setup[R, K, V, SV]
-  ): ZLayer[R with KafkaConfig, TamerError, Tamer] = LiveTamer.getLayer(setup)
+  final def live[R, K: Tag, V: Tag, SV: Tag](setup: Setup[R, K, V, SV]): RLayer[R with KafkaConfig, Tamer] = LiveTamer.getLayer(setup)
 }
diff --git a/core/src/main/scala/tamer/config.scala b/core/src/main/scala/tamer/config.scala
@@ -69,7 +69,7 @@ object KafkaConfig {
     KafkaConfig(brokers, maybeRegistry, closeTimeout, bufferSize, sink, state, transactionalId)
   }.nested("kafka")
 
-  final val fromEnvironment: Layer[TamerError, KafkaConfig] = ZLayer {
+  final val fromEnvironment: TaskLayer[KafkaConfig] = ZLayer {
     ZIO.config(kafkaConfigValue).mapError(ce => TamerError(ce.getMessage(), ce))
   }
 }
diff --git a/core/src/main/scala/tamer/package.scala b/core/src/main/scala/tamer/package.scala
@@ -1,7 +1,7 @@
-import zio.ZIO
+import zio.{RIO, ZIO}
 
 package object tamer {
-  final val runLoop: ZIO[Tamer, TamerError, Unit] = ZIO.serviceWithZIO(_.runLoop)
+  final val runLoop: RIO[Tamer, Unit] = ZIO.serviceWithZIO(_.runLoop)
 
   implicit final class HashableOps[A](private val _underlying: A) extends AnyVal {
     def hash(implicit A: Hashable[A]): Int = A.hash(_underlying)
diff --git a/core/src/test/scala/tamer/TamerSpec.scala b/core/src/test/scala/tamer/TamerSpec.scala
@@ -19,7 +19,7 @@ object TamerSpec extends ZIOSpecDefault with TamerSpecGen {
       override final val initialState = State(0)
       override final val stateKey     = 0
       override final val recordKey    = (s: State, _: Value) => Key(s.state + 1)
-      override final def iteration(s: State, q: Enqueue[NonEmptyChunk[(Key, Value)]]): ZIO[Ref[Log], TamerError, State] =
+      override final def iteration(s: State, q: Enqueue[NonEmptyChunk[(Key, Value)]]): RIO[Ref[Log], State] =
         ZIO.service[Ref[Log]].flatMap { variable =>
           val cursor = s.state + 1
           if (cursor <= 10)
diff --git a/db/src/main/scala/tamer/db/config.scala b/db/src/main/scala/tamer/db/config.scala
@@ -16,7 +16,7 @@ object DbConfig {
       DbConfig(driver, uri, username, password, fetchChunkSize)
     }
 
-  final val fromEnvironment: Layer[TamerError, DbConfig] = ZLayer {
+  final val fromEnvironment: TaskLayer[DbConfig] = ZLayer {
     ZIO.config(dbConfigValue).mapError(ce => TamerError(ce.getMessage(), ce))
   }
 }
diff --git a/db/src/main/scala/tamer/db/package.scala b/db/src/main/scala/tamer/db/package.scala
@@ -19,19 +19,19 @@ package object db {
     def -(d: Duration): Instant                              = instant.minus(d)
   }
 
-  final val hikariLayer: ZLayer[DbConfig, TamerError, Transactor[Task]] =
-    ZLayer.scoped.apply {
+  final val hikariLayer: RLayer[DbConfig, Transactor[Task]] =
+    ZLayer.scoped {
       ZIO
         .service[DbConfig]
         .zip(ZIO.descriptor.map(_.executor.asExecutionContext))
         .flatMap { case (config, ec) => mkTransactor(config, ec) }
     }
 
-  final def mkTransactor(config: DbConfig, connectEC: ExecutionContext): ZIO[Scope, TamerError, HikariTransactor[Task]] =
+  final def mkTransactor(config: DbConfig, connectEC: ExecutionContext): RIO[Scope, HikariTransactor[Task]] =
     newHikariTransactor[Task](config.driver, config.uri, config.username, config.password.value.asString, connectEC).toScopedZIO
       .refineToOrDie[SQLException]
       .mapError(sqle => TamerError(sqle.getLocalizedMessage, sqle))
 
-  final val dbLayerFromEnvironment: Layer[TamerError, DbConfig with Transactor[Task]] =
+  final val dbLayerFromEnvironment: TaskLayer[DbConfig with Transactor[Task]] =
     DbConfig.fromEnvironment >+> hikariLayer
 }
diff --git a/example/src/main/scala/tamer/db/DatabaseGeneralized.scala b/example/src/main/scala/tamer/db/DatabaseGeneralized.scala
@@ -20,6 +20,6 @@ object DatabaseGeneralized extends ZIOAppDefault {
             val mostRecent = results.sortBy(_.modifiedAt).max.timestamp
             Clock.instant.map(now => MyState(mostRecent, (mostRecent + 5.minutes).or(now)))
         }
-      ).runWith(dbLayerFromEnvironment ++ KafkaConfig.fromEnvironment).exitCode
+      ).runWith(dbLayerFromEnvironment ++ KafkaConfig.fromEnvironment)
     }
 }
diff --git a/example/src/main/scala/tamer/db/DatabaseSimple.scala b/example/src/main/scala/tamer/db/DatabaseSimple.scala
@@ -15,5 +15,4 @@ object DatabaseSimple extends ZIOAppDefault {
       sql"""SELECT id, name, description, modified_at FROM users WHERE modified_at > ${window.from} AND modified_at <= ${window.to}""".query[Row]
     )(recordKey = (_, v) => v.id, from = Instant.parse("2020-01-01T00:00:00.00Z"), tumblingStep = 5.days)
     .runWith(dbLayerFromEnvironment ++ KafkaConfig.fromEnvironment)
-    .exitCode
 }
diff --git a/example/src/main/scala/tamer/oci/objectstorage/OciObjectStorageSimple.scala b/example/src/main/scala/tamer/oci/objectstorage/OciObjectStorageSimple.scala
@@ -22,5 +22,5 @@ object OciObjectStorageSimple extends ZIOAppDefault {
     },
     objectName = _.current,
     startAfter = _.startAfter
-  ).runWith(objectStorageLayer(US_PHOENIX_1, ObjectStorageAuth.fromConfigFileDefaultProfile) ++ KafkaConfig.fromEnvironment).exitCode
+  ).runWith(objectStorageLayer(US_PHOENIX_1, ObjectStorageAuth.fromConfigFileDefaultProfile) ++ KafkaConfig.fromEnvironment)
 }
diff --git a/example/src/main/scala/tamer/rest/RESTBasicAuth.scala b/example/src/main/scala/tamer/rest/RESTBasicAuth.scala
@@ -31,5 +31,4 @@ object RESTBasicAuth extends ZIOAppDefault {
       increment = 2
     )
     .runWith(restLive() ++ KafkaConfig.fromEnvironment)
-    .exitCode
 }
diff --git a/example/src/main/scala/tamer/rest/RESTCustomAuth.scala b/example/src/main/scala/tamer/rest/RESTCustomAuth.scala
@@ -18,7 +18,7 @@ object RESTCustomAuth extends ZIOAppDefault {
 
   val authentication: Authentication[SttpClient] = new Authentication[SttpClient] {
     override def addAuthentication(request: SttpRequest, bearerToken: Option[String]): SttpRequest = request.auth.bearer(bearerToken.getOrElse(""))
-    override def setSecret(secretRef: Ref[Option[String]]): ZIO[SttpClient, TamerError, Unit] = {
+    override def setSecret(secretRef: Ref[Option[String]]): RIO[SttpClient, Unit] = {
       val fetchToken = send(basicRequest.get(uri"http://localhost:9395/auth").auth.basic("user", "pass"))
         .flatMap(_.body match {
           case Left(error)  => ZIO.fail(TamerError(error))
@@ -43,5 +43,4 @@ object RESTCustomAuth extends ZIOAppDefault {
       increment = 2
     )
     .runWith(restLive() ++ KafkaConfig.fromEnvironment)
-    .exitCode
 }
diff --git a/example/src/main/scala/tamer/rest/RESTDynamicData.scala b/example/src/main/scala/tamer/rest/RESTDynamicData.scala
@@ -15,14 +15,13 @@ object RESTDynamicData extends ZIOAppDefault {
       ZIO.attempt(body.split(",").toList.filterNot(_.isBlank))
     }
 
-  def program(now: Instant) = RESTSetup
-    .periodicallyPaginated(
-      baseUrl = "http://localhost:9395/dynamic-pagination",
-      pageDecoder = pageDecoder,
-      periodStart = now
-    )((_, data) => data)
-    .runWith(restLive() ++ KafkaConfig.fromEnvironment)
-    .exitCode
-
-  override final val run = Clock.instant.flatMap(program(_))
+  override final val run = Clock.instant.flatMap { now =>
+    RESTSetup
+      .periodicallyPaginated(
+        baseUrl = "http://localhost:9395/dynamic-pagination",
+        pageDecoder = pageDecoder,
+        periodStart = now
+      )((_, data) => data)
+      .runWith(restLive() ++ KafkaConfig.fromEnvironment)
+  }
 }
diff --git a/example/src/main/scala/tamer/rest/RESTSimple.scala b/example/src/main/scala/tamer/rest/RESTSimple.scala
@@ -20,5 +20,4 @@ object RESTSimple extends ZIOAppDefault {
       fixedPageElementCount = Some(3)
     )
     .runWith(restLive() ++ KafkaConfig.fromEnvironment)
-    .exitCode
 }
diff --git a/example/src/main/scala/tamer/s3/S3Generalized.scala b/example/src/main/scala/tamer/s3/S3Generalized.scala
@@ -48,5 +48,5 @@ object S3Generalized extends ZIOAppDefault {
     recordKey = (l: Long, _: String) => l,
     selectObjectForState = (l: Long, _: Keys) => internals.selectObjectForInstant(l),
     stateFold = internals.getNextState
-  ).runWith(Scope.default >>> (liveZIO(AF_SOUTH_1, s3.providers.default, Some(new URI("http://localhost:9000"))) ++ myKafkaConfigLayer)).exitCode
+  ).runWith(Scope.default >>> (liveZIO(AF_SOUTH_1, s3.providers.default, Some(new URI("http://localhost:9000"))) ++ myKafkaConfigLayer))
 }
diff --git a/example/src/main/scala/tamer/s3/S3Simple.scala b/example/src/main/scala/tamer/s3/S3Simple.scala
@@ -19,5 +19,4 @@ object S3Simple extends ZIOAppDefault {
       dateTimeFormatter = ZonedDateTimeFormatter.fromPattern("yyyy-MM-dd HH:mm:ss", ZoneId.of("Europe/Rome"))
     )
     .runWith(Scope.default >>> (liveZIO(AF_SOUTH_1, s3.providers.default, Some(new URI("http://localhost:9000"))) ++ KafkaConfig.fromEnvironment))
-    .exitCode
 }
diff --git a/oci-objectstorage/src/main/scala/tamer/oci/objectstorage/package.scala b/oci-objectstorage/src/main/scala/tamer/oci/objectstorage/package.scala
@@ -2,11 +2,11 @@ package tamer
 package oci
 
 import com.oracle.bmc.Region
-import zio.{RIO, ZLayer}
+import zio.{RIO, RLayer, ZLayer}
 import zio.oci.objectstorage._
 
 package object objectstorage {
-  final def objectStorageLayer[R](region: Region, auth: RIO[R, ObjectStorageAuth]): ZLayer[R, TamerError, ObjectStorage] =
+  final def objectStorageLayer[R](region: Region, auth: RIO[R, ObjectStorageAuth]): RLayer[R, ObjectStorage] =
     ZLayer(auth).flatMap(auth => ObjectStorage.live(ObjectStorageSettings(region, auth.get))).mapError { e =>
       TamerError(e.getLocalizedMessage, e)
     }
diff --git a/rest/src/main/scala/tamer/rest/package.scala b/rest/src/main/scala/tamer/rest/package.scala
@@ -5,7 +5,7 @@ import sttp.capabilities.{Effect, WebSockets}
 import sttp.capabilities.zio.ZioStreams
 import sttp.client4.{BackendOptions, Request, Response}
 import sttp.client4.httpclient.zio._
-import zio.{Layer, Ref, Task}
+import zio.{Ref, Task, TaskLayer}
 
 package object rest {
   type EphemeralSecretCache = Ref[Option[String]]
@@ -16,7 +16,7 @@ package object rest {
       options: BackendOptions = BackendOptions.Default,
       customizeRequest: HttpRequest => HttpRequest = identity,
       customEncodingHandler: HttpClientZioBackend.ZioEncodingHandler = PartialFunction.empty
-  ): Layer[TamerError, SttpClient with EphemeralSecretCache] =
+  ): TaskLayer[SttpClient with EphemeralSecretCache] =
     HttpClientZioBackend
       .layer(options, customizeRequest, customEncodingHandler)
       .mapError(e => TamerError(e.getLocalizedMessage(), e)) ++ EphemeralSecretCache.live

Original file line number	Diff line number	Diff line change
`@@ -92,10 +92,10 @@ object Registry {`
`92`	`92`	`override final def verifySchema(id: Int, schema: Schema): Task[Unit] = ZIO.unit`
`93`	`93`	`}`
`94`	`94`
`95`		`- private[tamer] final val fakeRegistryZIO: ZIO[Scope, TamerError, Registry] = ZIO.succeed(Registry.FakeRegistry)`
	`95`	`+ private[tamer] final val fakeRegistryZIO: RIO[Scope, Registry] = ZIO.succeed(Registry.FakeRegistry)`
`96`	`96`	`}`
`97`	`97`
`98`		`-final case class RegistryProvider(from: RegistryConfig => ZIO[Scope, TamerError, Registry])`
	`98`	`+final case class RegistryProvider(from: RegistryConfig => RIO[Scope, Registry])`
`99`	`99`
`100`	`100`	`object RegistryProvider {`
`101`	`101`	`implicit final val defaultRegistryProvider: RegistryProvider = RegistryProvider { config =>`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,6 @@ abstract class Setup[-R, K: Tag, V: Tag, SV: Tag](implicit val serdesProvider: S`
`9`	`9`	`val repr: String = "no repr string implemented, if you want a neat description of the source configuration please implement it"`
`10`	`10`	`def iteration(currentState: SV, queue: Enqueue[NonEmptyChunk[(K, V)]]): RIO[R, SV]`
`11`	`11`
`12`		`- final val run: ZIO[R with KafkaConfig, TamerError, Unit] = runLoop.provideSomeLayer(Tamer.live(this))`
`13`		`- final def runWith[E >: TamerError, R1](layer: Layer[E, R with KafkaConfig with R1]): IO[E, Unit] =`
`14`		`- runLoop.provideLayer(layer >>> Tamer.live(this))`
	`12`	`+ final val run: RIO[R with KafkaConfig, Unit] = runLoop.provideSomeLayer(Tamer.live(this)).orDie`
	`13`	`+ final def runWith[R1](layer: TaskLayer[R with KafkaConfig with R1]): Task[Unit] = runLoop.provideLayer(layer >>> Tamer.live(this)).orDie`
`15`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ object KafkaConfig {`
`69`	`69`	`KafkaConfig(brokers, maybeRegistry, closeTimeout, bufferSize, sink, state, transactionalId)`
`70`	`70`	`}.nested("kafka")`
`71`	`71`
`72`		`- final val fromEnvironment: Layer[TamerError, KafkaConfig] = ZLayer {`
	`72`	`+ final val fromEnvironment: TaskLayer[KafkaConfig] = ZLayer {`
`73`	`73`	`ZIO.config(kafkaConfigValue).mapError(ce => TamerError(ce.getMessage(), ce))`
`74`	`74`	`}`
`75`	`75`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ object DbConfig {`
`16`	`16`	`DbConfig(driver, uri, username, password, fetchChunkSize)`
`17`	`17`	`}`
`18`	`18`
`19`		`- final val fromEnvironment: Layer[TamerError, DbConfig] = ZLayer {`
	`19`	`+ final val fromEnvironment: TaskLayer[DbConfig] = ZLayer {`
`20`	`20`	`ZIO.config(dbConfigValue).mapError(ce => TamerError(ce.getMessage(), ce))`
`21`	`21`	`}`
`22`	`22`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,6 @@ object DatabaseGeneralized extends ZIOAppDefault {`
`20`	`20`	`val mostRecent = results.sortBy(_.modifiedAt).max.timestamp`
`21`	`21`	`Clock.instant.map(now => MyState(mostRecent, (mostRecent + 5.minutes).or(now)))`
`22`	`22`	`}`
`23`		`- ).runWith(dbLayerFromEnvironment ++ KafkaConfig.fromEnvironment).exitCode`
	`23`	`+ ).runWith(dbLayerFromEnvironment ++ KafkaConfig.fromEnvironment)`
`24`	`24`	`}`
`25`	`25`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,5 +15,4 @@ object DatabaseSimple extends ZIOAppDefault {`
`15`	`15`	`sql"""SELECT id, name, description, modified_at FROM users WHERE modified_at > ${window.from} AND modified_at <= ${window.to}""".query[Row]`
`16`	`16`	`)(recordKey = (_, v) => v.id, from = Instant.parse("2020-01-01T00:00:00.00Z"), tumblingStep = 5.days)`
`17`	`17`	`.runWith(dbLayerFromEnvironment ++ KafkaConfig.fromEnvironment)`
`18`		`- .exitCode`
`19`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,5 +22,5 @@ object OciObjectStorageSimple extends ZIOAppDefault {`
`22`	`22`	`},`
`23`	`23`	`objectName = _.current,`
`24`	`24`	`startAfter = _.startAfter`
`25`		`- ).runWith(objectStorageLayer(US_PHOENIX_1, ObjectStorageAuth.fromConfigFileDefaultProfile) ++ KafkaConfig.fromEnvironment).exitCode`
	`25`	`+ ).runWith(objectStorageLayer(US_PHOENIX_1, ObjectStorageAuth.fromConfigFileDefaultProfile) ++ KafkaConfig.fromEnvironment)`
`26`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,5 +31,4 @@ object RESTBasicAuth extends ZIOAppDefault {`
`31`	`31`	`increment = 2`
`32`	`32`	`)`
`33`	`33`	`.runWith(restLive() ++ KafkaConfig.fromEnvironment)`
`34`		`- .exitCode`
`35`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ object RESTCustomAuth extends ZIOAppDefault {`
`18`	`18`
`19`	`19`	`val authentication: Authentication[SttpClient] = new Authentication[SttpClient] {`
`20`	`20`	`override def addAuthentication(request: SttpRequest, bearerToken: Option[String]): SttpRequest = request.auth.bearer(bearerToken.getOrElse(""))`
`21`		`- override def setSecret(secretRef: Ref[Option[String]]): ZIO[SttpClient, TamerError, Unit] = {`
	`21`	`+ override def setSecret(secretRef: Ref[Option[String]]): RIO[SttpClient, Unit] = {`
`22`	`22`	`val fetchToken = send(basicRequest.get(uri"http://localhost:9395/auth").auth.basic("user", "pass"))`
`23`	`23`	`.flatMap(_.body match {`
`24`	`24`	`case Left(error) => ZIO.fail(TamerError(error))`
`@@ -43,5 +43,4 @@ object RESTCustomAuth extends ZIOAppDefault {`
`43`	`43`	`increment = 2`
`44`	`44`	`)`
`45`	`45`	`.runWith(restLive() ++ KafkaConfig.fromEnvironment)`
`46`		`- .exitCode`
`47`	`46`	`}`
Original file line number	Diff line number	Diff line change
`@@ -20,5 +20,4 @@ object RESTSimple extends ZIOAppDefault {`
`20`	`20`	`fixedPageElementCount = Some(3)`
`21`	`21`	`)`
`22`	`22`	`.runWith(restLive() ++ KafkaConfig.fromEnvironment)`
`23`		`- .exitCode`
`24`	`23`	`}`