ZIO

https://zio.dev
Admin
ZIO is a type-safe, composable library for asynchronous and concurrent programming in Scala that...
Tokens:1,064,327
Snippets:10,702
Trust Score:9
Update:3 months ago
Show doc for...
Tokens:
Raw
### Clone ZIO Quickstarts Project

Source: https://zio.dev/guides/quickstarts/hello-world

Clone the ZIO Quickstarts project to get started with the hello world example.

```bash
git clone https://github.com/zio/zio-quickstarts.git
```

```bash
cd zio-quickstarts/zio-quickstart-hello-world
```

--------------------------------

### Clone and Run ZIO Quickstart

Source: https://zio.dev/guides/tutorials/enable-logging-in-a-zio-application

Commands to clone the repository and start the application.

```bash
$ git clone https://github.com/zio/zio-quickstarts.git  

$ cd zio-quickstarts/zio-quickstart-restful-webservice-logging  
```

```bash
$ sbt run  
```

```bash
sbt reStart  
```

--------------------------------

### Serve the microsite locally

Source: https://zio.dev/contributing-to-documentation

Installs dependencies and starts the local development server for the documentation website.

```bash
cd website
npm install
npm run start --watch
```

--------------------------------

### Run Backend Application

Source: https://zio.dev/zio-telemetry/opentelemetry-example

Starts the backend component of the example application using sbt.

```bash
sbt "opentelemetryExample/runMain zio.telemetry.opentelemetry.example.BackendApp"  
```

--------------------------------

### Define Product instances

Source: https://zio.dev/zio-blocks/guides/query-dsl-reified-optics

Setup of sample Product data for evaluation examples.

```scala
val laptop = Product("Laptop", 999.99, "Electronics", true, 5)  

val pen    = Product("Pen", 2.50, "Office", true, 3)  
```

--------------------------------

### Run Proxy Application

Source: https://zio.dev/zio-telemetry/opentelemetry-example

Starts the proxy component of the example application using sbt.

```bash
sbt "opentelemetryExample/runMain zio.telemetry.opentelemetry.example.ProxyApp"  
```

--------------------------------

### Initialize CompleteExample for Request Context

Source: https://zio.dev/guides/tutorials/getting-started-threadlocal-bridge

Boilerplate setup for the request context propagation example.

```scala
package threadlocalbridge  
  
  

import zio._
```

--------------------------------

### SQL Context Setup

Source: https://zio.dev/zio-quill/writing-queries

Basic setup for a SQL mirror context.

```scala
val ctx = new SqlMirrorContext(MirrorSqlDialect, Literal)  
import ctx._  
```

--------------------------------

### Wire server and clients together

Source: https://zio.dev/reference/stream/subscription-ref

This example demonstrates starting a server, running multiple clients in parallel, and collecting their observed changes.

```scala
for {  

  subscriptionRef <- SubscriptionRef.make(0L)  

  server          <- server(subscriptionRef).fork  

  chunks          <- ZIO.collectAllPar(List.fill(100)(client(subscriptionRef.changes)))  

  _               <- server.interrupt  

  _               <- ZIO.foreach(chunks)(chunk => Console.printLine(chunk))  

} yield ()  
```

--------------------------------

### Example Execution and Compilation

Source: https://zio.dev/guides/compositional-fiberref-updates-with-differ

Commands to run the complete demonstration or compile the project examples.

```bash
sbt "differ-compositional-updates/runMain differcompositionalupdates.CompleteExample"
```

```bash
sbt "differ-compositional-updates/compile"
```

--------------------------------

### Run Example with SBT

Source: https://zio.dev/zio-blocks/reference/resource-management/wire

Command to execute the basic wire construction example using sbt.

```bash
sbt "scope-examples/runMain wire.wireBasicExample"  
```

--------------------------------

### Run Database Example

Source: https://zio.dev/zio-blocks/reference/resource-management/resource

Command to execute the database example using sbt.

```bash
sbt "scope-examples/runMain scope.examples.runDatabaseExample"
```

--------------------------------

### Clone and Navigate to Examples

Source: https://zio.dev/guides/compositional-fiberref-updates-with-differ

Commands to clone the ZIO repository and enter the examples directory.

```bash
git clone https://github.com/zio/zio.git  

cd zio/zio-examples  
```

--------------------------------

### Run Example Command

Source: https://zio.dev/zio-blocks/reference/resource-management/wire

Command to execute the manual wire construction example via sbt.

```bash
sbt "scope-examples/runMain wire.wireFromFunctionExample"
```

--------------------------------

### Running the Configuration Reader Example

Source: https://zio.dev/zio-blocks/reference/resource-management/scope

Command to execute the configuration reader example via sbt.

```bash
sbt "scope-examples/runMain scope.examples.runConfigReaderExample"
```

--------------------------------

### Integration Test Harness Example

Source: https://zio.dev/zio-blocks/reference/resource-management/scope

Demonstrates manual fixture acquisition and DI-wired application setup within a scoped block for automatic resource cleanup.

```scala
  /**  
   * Runs the integration test harness example.  
   *  
   * Demonstrates:  
   *   1. Manual fixture via [[Resource.acquireRelease]] for test infrastructure  
   *   2. DI-wired application via [[Resource.from]] consuming the fixture  
   *   3. Proper cleanup ordering: app closes before fixtures  
   */  
  def run(): Unit = {  
    println("=== Integration Test Harness Example ===\n")  
  
    val config = TestConfig("jdbc:h2:mem:test", 8080)  
  
    // Combine manual fixtures with DI-wired application  
    val testHarnessResource: Resource[(TestFixture, AppUnderTest)] =  
      testFixtureResource(config).flatMap { fixture =>  
        // Seed test data  
        fixture.db.seed(Map("user:1" -> "Alice", "user:2" -> "Bob"))  
  
        // Wire the app using DI, injecting the fixture's database  
        val appWire     = Wire.shared[AppUnderTest]  
        val dbWire      = Wire(fixture.db)  
        val appResource = Resource.from[AppUnderTest](appWire, dbWire)  
  
        appResource.map(app => (fixture, app))  
      }  
  
    // Run in a scoped block - all resources cleaned up on exit  
    Scope.global.scoped { scope =>  
      import scope._  
      println("Allocating resources...")  
      val harness: $[(TestFixture, AppUnderTest)] = allocate(testHarnessResource)  
      println()  
  
      // Run test scenarios - access the tuple via $  
      println("Running test scenarios:")  
      $(harness) { h =>  
        println(s"  GET user:1 -> ${h._2.handleRequest("user:1")}")  
        println(s"  GET user:2 -> ${h._2.handleRequest("user:2")}")  
        println(s"  GET user:3 -> ${h._2.handleRequest("user:3")}")  
        println(s"  Server URL: ${h._1.server.baseUrl}")  
      }  
      println()  
  
      println("Scope closing, releasing resources in LIFO order...")  
    }  
  
    println("\n=== Example Complete ===")  
  }  
}  
  
@main def runIntegrationTestHarness(): Unit = IntegrationTestHarnessExample.run()
```

--------------------------------

### Restart Database Services

Source: https://zio.dev/zio-quill/how-to-contribute

Stops existing containers and starts the setup service with ports exposed to the host machine.

```bash
docker compose down && docker compose run --rm --service-ports setup
```

--------------------------------

### Run Scope Example

Source: https://zio.dev/zio-blocks/reference/resource-management/scope

Command to execute the HTTP client pipeline example.

```bash
sbt "scope-examples/runMain scope.examples.httpClientPipelineExample"
```

--------------------------------

### Running the ThreadLocalBridge Example

Source: https://zio.dev/guides/tutorials/getting-started-threadlocal-bridge

Command to execute the provided example via sbt.

```bash
sbt "threadlocal-bridge/runMain threadlocalbridge.Concept2Example"
```

--------------------------------

### Run the Built-in Differs Example

Source: https://zio.dev/guides/compositional-fiberref-updates-with-differ

Command to execute the example application via sbt.

```bash
sbt "differ-compositional-updates/runMain differcompositionalupdates.BuiltInDiffersExample"  
```

--------------------------------

### Run the ThreadLocalBridge Example

Source: https://zio.dev/guides/tutorials/getting-started-threadlocal-bridge

Command to execute the complete end-to-end example via sbt.

```bash
sbt "threadlocal-bridge/runMain threadlocalbridge.CompleteExample"
```

--------------------------------

### Manage schema examples

Source: https://zio.dev/zio-blocks/reference/dynamic-schema

Retrieve or define example values for the schema.

```scala
final case class DynamicSchema(reflect: Reflect.Unbound[_]) {  

  def examples: Seq[DynamicValue]  

  def examples(value: DynamicValue, values: DynamicValue*): DynamicSchema  

}  
```

--------------------------------

### Run Caching Example

Source: https://zio.dev/zio-blocks/reference/resource-management/resource

Command to execute the caching example using sbt.

```bash
sbt "scope-examples/runMain scope.examples.runCachingExample"
```

--------------------------------

### Run Plugin Architecture Example

Source: https://zio.dev/zio-blocks/reference/resource-management/scope

Command to execute the plugin architecture example via sbt.

```bash
sbt "scope-examples/runMain scope.examples.pluginArchitectureExample"
```

--------------------------------

### Run individual concept examples

Source: https://zio.dev/guides/tutorials/reloadable-services

Commands to execute specific reloadable service examples.

```sbt
sbt "runMain reloadableservices.ReloadableManualExample"  

sbt "runMain reloadableservices.ReloadableReloadExample"  

sbt "runMain reloadableservices.ReloadableAutoExample"  

sbt "runMain reloadableservices.ReloadableFullExample"  
```

--------------------------------

### Running TypeId Examples

Source: https://zio.dev/zio-blocks/reference/typeid

Command to execute the TypeId example suite via sbt.

```bash
sbt "schema-examples/runMain typeid.TypeIdBasicExample"
```

--------------------------------

### Compile all scope examples

Source: https://zio.dev/zio-blocks/guides/compile-time-resource-safety-with-scope

Use this command to compile all examples within the scope-examples module.

```bash
sbt "scope-examples/compile"  
```

--------------------------------

### Clone and Run the Quickstart Project

Source: https://zio.dev/guides/tutorials/configurable-zio-application

Commands to initialize the base project used for this tutorial.

```bash
git clone https://github.com/zio/zio-quickstarts.git  

cd zio-quickstarts/zio-quickstart-restful-webservice  

sbt run  
```

--------------------------------

### Quick Start: Creating a Request

Source: https://zio.dev/zio-blocks/reference/http-model

Example of creating an HTTP GET request with query parameters and a header.

```APIDOC
## Quick Start: Creating a Request

### Description
Demonstrates how to create an HTTP request with query parameters and headers.

### Example
```scala
import zio.http._

val url = URL.parse("https://api.example.com/users?active=true").toOption.get
val request = Request.get(url)

val withHeader = request.addHeader("authorization", "Bearer token123")
```
```

--------------------------------

### Run the Example

Source: https://zio.dev/guides/compositional-fiberref-updates-with-differ

Command to execute the demonstration application via sbt.

```bash
sbt "differ-compositional-updates/runMain differcompositionalupdates.LastWriteWinsVsCompositionalMergingExample"  
```

--------------------------------

### Configure get Query Operations

Source: https://zio.dev/zio-dynamodb/reference/hi-level-api/crud-operations/get

Example showing how to chain `get` with consistency mode and a `where` clause for filtering.

```scala
<GET_QUERY>
  .consistency(<ConsistencyMode>)
  .where(<ConditionExpression>)
```

--------------------------------

### Clone and navigate the repository

Source: https://zio.dev/zio-blocks/reference/allows

Commands to set up the local environment for running examples.

```bash

git clone https://github.com/zio/zio-blocks.git  

cd zio-blocks  



```

--------------------------------

### Start Seq Observability Backend

Source: https://zio.dev/zio-telemetry/opentelemetry-instrumentation-example

Configures and starts the Seq container with an admin password.

```bash
PH=$(echo 'admin123' | docker run --rm -i datalust/seq config hash)

docker run \
  -d \
  --restart unless-stopped \
  -e ACCEPT_EULA=Y \
  -e SEQ_FIRSTRUN_ADMINPASSWORDHASH="$PH" \
  -p 80:80 \
  -p 5341:5341 \
  datalust/seq
```

--------------------------------

### Retrieve an Item using get

Source: https://zio.dev/zio-dynamodb/reference/hi-level-api/crud-operations/get

Example of using the `get` operation to retrieve a 'person' item by its ID.

```scala
for {
  errorOrPerson <- DynamoDBQuery.get("person")(Person.id.primaryKey === "1").execute
} yield errorOrPerson
```

--------------------------------

### Transactional Resource Management Setup

Source: https://zio.dev/zio-blocks/reference/resource-management/resource

Boilerplate for the transactional resource management example.

```scala
/*  

 * Copyright 2024-2026 John A. De Goes and the ZIO Contributors  

 *  

 * Licensed under the Apache License, Version 2.0 (the "License");  

 * you may not use this file except in compliance with the License.  

 * You may obtain a copy of the License at  

 *  

 *     http://www.apache.org/licenses/LICENSE-2.0  

 *  

 * Unless required by applicable law or agreed to in writing, software  

 * distributed under the License is distributed on an "AS IS" BASIS,  

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  

 * See the License for the specific language governing permissions and  

 * limitations under the License.  

 */  

  

package scope.examples  

  

import zio.blocks.scope._  

  

/**  

 * Transaction Boundary Example  

 *  

 * Demonstrates nested scopes and resource-returning methods for database  

 * transaction management.  

 *  

 * Key patterns shown:  

 *   - '''Resource-returning methods''': `beginTransaction` returns  

 *     `Resource[DbTransaction]`  

 *   - '''Nested scopes''': Transactions live in child scopes of the connection  
```

--------------------------------

### Run the Composing Differs Example

Source: https://zio.dev/guides/compositional-fiberref-updates-with-differ

Command to execute the compositional updates example via sbt.

```bash
sbt "differ-compositional-updates/runMain differcompositionalupdates.ComposingDiffersExample"
```

--------------------------------

### Clone and Navigate to ZIO Quickstarts

Source: https://zio.dev/guides/tutorials/monitor-a-zio-application-using-zio-built-in-metric-system

Commands to download the ZIO quickstart repository and enter the specific metrics project directory.

```bash
$ git clone https://github.com/zio/zio-quickstarts.git  

$ cd zio-quickstarts/zio-quickstart-restful-webservice-metrics  
```

--------------------------------

### Clone and navigate to the project

Source: https://zio.dev/guides/quickstarts/graphql-webservice

Commands to download the ZIO quickstarts repository and enter the GraphQL service directory.

```bash
$ git clone https://github.com/zio/zio-quickstarts.git  

$ cd zio-quickstarts/zio-quickstart-graphql-webservice  
```

--------------------------------

### Start Grafana Server

Source: https://zio.dev/zio-metrics-connectors/metrics/prometheus-client

Execute this command within your Grafana installation directory to start the Grafana server. Ensure Grafana is downloaded and extracted to your chosen directory (`$GRAFANADIR`).

```bash
./bin/grafana-server
```

--------------------------------

### Run Event Bus Example

Source: https://zio.dev/zio-blocks/reference/allows

Command to execute the event bus example via sbt.

```bash
sbt "schema-examples/runMain comptime.AllowsEventBusExample"  
```

--------------------------------

### Clone and Navigate to the Project

Source: https://zio.dev/guides/tutorials/create-custom-logger-for-a-zio-application

Commands to clone the ZIO quickstarts repository and enter the specific directory for the custom logger tutorial.

```bash
$ git clone https://github.com/zio/zio-quickstarts.git  

$ cd zio-quickstarts/zio-quickstart-restful-webservice-custom-logger  
```

--------------------------------

### Clone and Run ZIO Kafka Quickstart

Source: https://zio.dev/zio-kafka/tutorial

Commands to clone the repository and execute the application using sbt.

```bash
$ git clone https://github.com/zio/zio-quickstarts.git  

$ cd zio-quickstarts/zio-quickstart-kafka  
```

```bash
$ sbt run  
```

--------------------------------

### Setup Generic Types

Source: https://zio.dev/zio-blocks/reference/typeid

Example case classes with varying arities for testing TypeId functionality.

```scala
import zio.blocks.typeid._  

  

case class Single[A](value: A)           // Arity 1  

case class Pair[A, B](a: A, b: B)       // Arity 2  

case class Triple[A, B, C](a: A, b: B, c: C) // Arity 3  

case class Value(x: Int)                 // Arity 0  
```

--------------------------------

### Using Prism for Sealed Traits in ZIO Blocks Schema

Source: https://zio.dev/zio-blocks/guides/zio-schema-migration

Example of using `Prism` for sealed traits to get or reverse get operations. Requires `zio.blocks.schema._` import and schema derivation for the sealed trait.

```scala
import zio.blocks.schema._  

sealed trait Shape  
case class Circle(radius: Double)    extends Shape  
case class Rectangle(w: Double, h: Double) extends Shape  

object Shape {  
  implicit val schema: Schema[Shape] = Schema.derived[Shape]  
  
  val circlePrism: Prism[Shape, Circle] =  
    schema.reflect.asVariant.get.prismByName[Circle]("Circle").get  
}

val shape: Shape = Circle(5.0)  
Shape.circlePrism.getOption(shape)          // Some(Circle(5.0))  
Shape.circlePrism.reverseGet(Circle(3.0))   // Circle(3.0): Shape
```

--------------------------------

### Clone the ZIO Quickstarts repository

Source: https://zio.dev/guides/tutorials/deploy-a-zio-application-using-docker

Use these commands to download the project and navigate to the specific directory for the Docker tutorial.

```bash
$ git clone https://github.com/zio/zio-quickstarts.git  

$ cd zio-quickstarts/zio-quickstart-restful-webservice-dockerize  
```

--------------------------------

### Implement TranzactIO with Doobie

Source: https://zio.dev/ecosystem/community/tranzactio

A complete example demonstrating database setup, insertion, and querying using TranzactIO and Doobie.

```scala
import doobie.implicits._  

import io.github.gaelrenoux.tranzactio.doobie  

import io.github.gaelrenoux.tranzactio.doobie.{Connection, Database, TranzactIO, tzio}  

import org.h2.jdbcx.JdbcDataSource  

import zio.blocking.Blocking  

import zio.clock.Clock  

import zio.console.{Console, putStrLn}  

import zio.{ExitCode, Has, URIO, ZIO, ZLayer, blocking}  

  

import javax.sql.DataSource  

  

object TranzactIOExample extends zio.App {  

  

  val query: ZIO[Connection with Console, Throwable, Unit] = for {  

    _ <- PersonQuery.setup  

    _ <- PersonQuery.insert(Person("William", "Stewart"))  

    _ <- PersonQuery.insert(Person("Michelle", "Streeter"))  

    _ <- PersonQuery.insert(Person("Johnathon", "Martinez"))  

    users <- PersonQuery.list  

    _ <- putStrLn(users.toString)  

  } yield ()  

  

  val myApp: ZIO[zio.ZEnv, Throwable, Unit] =  

    Database.transactionOrWidenR(query).provideCustom(services.database)  

  

  override def run(args: List[String]): URIO[zio.ZEnv, ExitCode] =  

    myApp.exitCode  

}  

  

case class Person(firstName: String, lastName: String)  

  

object PersonQuery {  

  def list: TranzactIO[List[Person]] = tzio {  

    sql"""SELECT first_name, last_name FROM person""".query[Person].to[List]  

  }  

  

  def setup: TranzactIO[Unit] = tzio {  

    sql"""  

        CREATE TABLE person (  

          first_name VARCHAR NOT NULL,  

          last_name VARCHAR NOT NULL  

        )  

        """.update.run.map(_ => ())  

  }  

  

  def insert(p: Person): TranzactIO[Unit] = tzio {  

    sql"""INSERT INTO person (first_name, last_name) VALUES (${p.firstName}, ${p.lastName})""".update.run  

      .map(_ => ())  

  }  

}  

  

object services {  

  val datasource: ZLayer[Blocking, Throwable, Has[DataSource]] =  

    ZLayer.fromEffect(  

      blocking.effectBlocking {  

        val ds = new JdbcDataSource  

        ds.setURL(s"jdbc:h2:mem:mydb;DB_CLOSE_DELAY=10")  

        ds.setUser("sa")  

        ds.setPassword("sa")  

        ds  

      }  

    )  

  

  val database: ZLayer[Any, Throwable, doobie.Database.Database] =  

    (Blocking.live >>> datasource ++ Blocking.live ++ Clock.live) >>> Database.fromDatasource  

}  
```

--------------------------------

### Quick Start: Creating a Response

Source: https://zio.dev/zio-blocks/reference/http-model

Example of creating a JSON HTTP response with a specific status and content type.

```APIDOC
## Quick Start: Creating a Response

### Description
Demonstrates how to create an HTTP response, including setting the status, body, and headers.

### Example
```scala
import zio.http._

val jsonBody = Body.fromString("{\"message\":\"ok\"}", Charset.UTF8)
val response = Response(
  status = Status.Ok,
  body = jsonBody,
  headers = Headers("content-type" -> "application/json")
)
```
```

--------------------------------

### Full KeyValueStore Implementation Example

Source: https://zio.dev/reference/service-pattern/accessor-methods

A complete example demonstrating service definition, implementation, layer creation, and usage via generated accessors.

```scala
import zio._  

import zio.macros.accessible  

  

@accessible  

trait KeyValueStore {  

  def set(key: String, value: Int): Task[Int]  

  

  def get(key: String): Task[Int]  

}  

  

  

case class InmemoryKeyValueStore(map: Ref[Map[String, Int]])  

  extends KeyValueStore {  

  override def set(key: String, value: Int): Task[Int] =  

    map.update(_.updated(key, value)).map(_ => value)  

  

  override def get(key: String): Task[Int] =  

    map.get.map(_.get(key)).someOrFailException  

}  

  

object InmemoryKeyValueStore {  

  val layer: ULayer[KeyValueStore] =  

    ZLayer {  

      for {  

        map <- Ref.make(Map[String, Int]())  

      } yield InmemoryKeyValueStore(map)  

    }  

}  

  

object MainApp extends ZIOAppDefault {  

  val myApp =  

    for {  

      _ <- KeyValueStore.set("key", 5)  

      key <- KeyValueStore.get("key")  

    } yield key  

  

  def run = myApp.provide(InmemoryKeyValueStore.layer).debug  

}
```

--------------------------------

### Start Akka Cluster Nodes

Source: https://zio.dev/guides/migrate/from-akka

Commands to initialize seed and additional nodes for an Akka Cluster Sharding example.

```bash
sbt -DHTTP_PORT=8081 -DPORT=2552 "runMain AkkaClusterShardingExample"
```

```bash
sbt -DHTTP_PORT=8082 -DPORT=2552 "runMain AkkaClusterShardingExample"

sbt -DHTTP_PORT=8083 -DPORT=2553 "runMain AkkaClusterShardingExample"
```

--------------------------------

### ZIO Redis with Protobuf Codec Example

Source: https://zio.dev/zio-redis

This example demonstrates basic Redis operations like SET, GET, HSET, RPUSH, and SADD using ZIO effects and a Protobuf codec. It requires both zio-redis and zio-schema-protobuf dependencies.

```scala
import zio._
import zio.redis._
import zio.schema._
import zio.schema.codec._

object ZIORedisExample extends ZIOAppDefault {

  object ProtobufCodecSupplier extends CodecSupplier {
    def get[A: Schema]: BinaryCodec[A] = ProtobufCodec.protobufCodec
  }

  val myApp: ZIO[Redis, RedisError, Unit] = 
    for {
      redis <- ZIO.service[Redis]
      _     <- redis.set("myKey", 8L, Some(1.minutes))
      v     <- redis.get("myKey").returning[Long]
      _     <- Console.printLine(s"Value of myKey: $v").orDie
      _     <- redis.hSet("myHash", ("k1", 6), ("k2", 2))
      _     <- redis.rPush("myList", 1, 2, 3, 4)
      _     <- redis.sAdd("mySet", "a", "b", "a", "c")
    } yield ()

  override def run = 
    myApp.provide(Redis.local, ZLayer.succeed[CodecSupplier](ProtobufCodecSupplier))
}
```

--------------------------------

### Test a logger with ZLogger#test

Source: https://zio.dev/reference/observability/logging/zlogger

Example of verifying that a logger produces the expected output format without starting a fiber.

```scala
import zio._  

  

// Produce a formatted line without a live fiber  

val line: String = ZLogger.default.test("hello world")  

// e.g. timestamp=2026-07-15T12:00:00Z level=INFO thread=#0 message="hello world"  

  

// Assert the formatter includes the expected keys  

assert(line.contains("message=\"hello world\""))  

assert(line.contains("level=INFO"))  


```

--------------------------------

### Basic Imports and Configuration Setup

Source: https://zio.dev/zio-config/read-from-various-sources

Initial imports and definition of a sample configuration case class.

```scala
import zio._, Config._, ConfigProvider._  

import zio.config._, magnolia._  
```

```scala
case class MyConfig(ldap: String, port: Int, dburl: String)  
```

--------------------------------

### Compile tutorial examples with mdoc

Source: https://zio.dev/zio-blocks/guides/compile-time-resource-safety-with-scope

Verify that the documentation examples compile correctly using the mdoc tool.

```bash
sbt "docs/mdoc --in docs/guides/compile-time-resource-safety-with-scope.md"  
```

--------------------------------

### Configure OpenTelemetry ZIO Logging

Source: https://zio.dev/zio-telemetry/opentelemetry-zio-logging

Example setup for OpenTelemetry SDK and ZIO Logging integration with span and trace ID support.

```scala
//> using scala "3.4.2"  

//> using dep dev.zio::zio:2.1.7  

//> using dep dev.zio::zio-opentelemetry:3.0.0-RC24  

//> using dep dev.zio::zio-opentelemetry-zio-logging:3.0.0-RC24  

//> using dep io.opentelemetry:opentelemetry-sdk:1.40.0  

//> using dep io.opentelemetry:opentelemetry-sdk-trace:1.40.0  

//> using dep io.opentelemetry:opentelemetry-exporter-logging-otlp:1.40.0  

//> using dep io.opentelemetry.semconv:opentelemetry-semconv:1.22.0-alpha  

  

import io.opentelemetry.exporter.logging.otlp.OtlpJsonLoggingSpanExporter  

import io.opentelemetry.exporter.logging.otlp.OtlpJsonLoggingLogRecordExporter  

import io.opentelemetry.api.common.Attributes  

import io.opentelemetry.sdk.trace.SdkTracerProvider  

import io.opentelemetry.sdk.trace.`export`.SimpleSpanProcessor  

import io.opentelemetry.sdk.logs.SdkLoggerProvider  

import io.opentelemetry.sdk.logs.`export`.SimpleLogRecordProcessor  

import io.opentelemetry.sdk.resources.Resource  

import io.opentelemetry.semconv.ServiceAttributes  

import io.opentelemetry.sdk.OpenTelemetrySdk  

import io.opentelemetry.api  

import zio.*  

import zio.logging.console  

import zio.logging.LogFormat._  

import zio.telemetry.opentelemetry.tracing.Tracing  

import zio.telemetry.opentelemetry.OpenTelemetry  

import zio.telemetry.opentelemetry.context.ContextStorage  

import zio.telemetry.opentelemetry.zio.logging.LogFormats  

import zio.telemetry.opentelemetry.zio.logging.ZioLogging  

  

object ZioLoggingApp extends ZIOAppDefault {  

  

  val instrumentationScopeName = "dev.zio.LoggingApp"  

  val resourceName             = "logging-app"  

  

  // Prints to stdout in OTLP Json format  

  val stdoutLoggerProvider: RIO[Scope, SdkLoggerProvider] =  

    for {  

      logRecordExporter  <- ZIO.fromAutoCloseable(ZIO.succeed(OtlpJsonLoggingLogRecordExporter.create()))  

      logRecordProcessor <- ZIO.fromAutoCloseable(ZIO.succeed(SimpleLogRecordProcessor.create(logRecordExporter)))  

      loggerProvider     <-  

        ZIO.fromAutoCloseable(  

          ZIO.succeed(  

            SdkLoggerProvider  

              .builder()  

              .setResource(Resource.create(Attributes.of(ServiceAttributes.SERVICE_NAME, resourceName)))  

              .addLogRecordProcessor(logRecordProcessor)  

              .build()  

          )  

        )  

    } yield loggerProvider  

  

  // Prints to stdout in OTLP Json format  

  val stdoutTracerProvider: RIO[Scope, SdkTracerProvider] =  

    for {  

      spanExporter   <- ZIO.fromAutoCloseable(ZIO.succeed(OtlpJsonLoggingSpanExporter.create()))  

      spanProcessor  <- ZIO.fromAutoCloseable(ZIO.succeed(SimpleSpanProcessor.create(spanExporter)))  

      tracerProvider <-  

        ZIO.fromAutoCloseable(  

          ZIO.succeed(  

            SdkTracerProvider  

              .builder()  

              .setResource(Resource.create(Attributes.of(ServiceAttributes.SERVICE_NAME, resourceName)))  

              .addSpanProcessor(spanProcessor)  

              .build()  

          )  

        )  

    } yield tracerProvider  

  

  val otelSdkLayer: TaskLayer[api.OpenTelemetry] =  

    OpenTelemetry.custom(  

      for {  

        tracerProvider <- stdoutTracerProvider  

        loggerProvider <- stdoutLoggerProvider  

        sdk            <- ZIO.fromAutoCloseable(  

                            ZIO.succeed(  

                              OpenTelemetrySdk  

                                .builder()  

                                .setTracerProvider(tracerProvider)  

                                .setLoggerProvider(loggerProvider)  

                                .build()  

                            )  

                          )  

      } yield sdk  

    )  

  

  // Setup zio-logging with spanId and traceId labels  

  val loggingLayer: URLayer[LogFormats, Unit] = ZLayer {  

    for {  

      logFormats     <- ZIO.service[LogFormats]  

      format          =  

        timestamp.fixed(32) |-|  

          level |-|  

          label("message", quoted(line)) |-|
```

--------------------------------

### Run Connection Pool Example

Source: https://zio.dev/zio-blocks/reference/resource-management/resource

Command to execute the connection pool demonstration.

```bash
sbt "scope-examples/runMain scope.examples.connectionPoolExample"
```

--------------------------------

### Start the Server

Source: https://zio.dev/guides/tutorials/build-a-restful-webservice

Initializes the server with the defined routes using the default server configuration.

```scala
import zio._  

import zio.http._  

  

object MainApp extends ZIOAppDefault {  

  def run =  

    Server.serve(GreetingRoutes()).provide(Server.default)  

}  
```

--------------------------------

### Define generic types for TypeId inspection

Source: https://zio.dev/zio-blocks/reference/typeid

Setup code for defining generic traits and case classes to be used in TypeId derivation examples.

```scala
import zio.blocks.typeid._  

  

sealed trait Container[+A]  

case class Box[+A](value: A) extends Container[A]  

  

sealed trait Cache[K, +V]  

case class LRUCache[K, +V](maxSize: Int) extends Cache[K, V]  
```

--------------------------------

### Compile the project

Source: https://zio.dev/guides/tutorials/reloadable-services

Command to compile all companion examples.

```sbt
sbt compile  
```

--------------------------------

### Define File API for Resource Conversion

Source: https://zio.dev/guides/interop/with-cats-effect

Example File API setup used to demonstrate conversion between Cats Effect Resource and ZIO ZManaged.

```scala
case class File[F[_]: cats.effect.Sync]() {  
  import cats.syntax.apply._  
  def read: F[String] =  
    cats.effect.Sync[F].delay(println("Reading file.")) *>  
      cats.effect.Sync[F].pure("Hello, World!")  
  def close: F[Unit]  =  
    cats.effect.Sync[F].delay(println("Closing file."))  
}  
  
  
object File {  
  import cats.syntax.apply._  
  def open[F[_]: cats.effect.Sync](name: String): F[File[F]] =  
    cats.effect.Sync[F].delay(println(s"opening $name file")) *>  
      cats.effect.Sync[F].delay(File())  
}  
```

```scala
def fileResource[F[_]: cats.effect.Sync](name: String): cats.effect.Resource[F, File[F]] =  
  cats.effect.Resource.make(File.open[F](name))(_.close)  
```

--------------------------------

### Clone and Navigate to ZIO Examples

Source: https://zio.dev/guides/tutorials/retry-and-repeat-policies-with-schedule

Commands to clone the ZIO repository and enter the directory containing schedule-basics examples.

```bash
git clone https://github.com/zio/zio.git  

cd zio/zio-examples/schedule-basics  
```

--------------------------------

### Implement ZIO Temporal Workflow Application

Source: https://zio.dev/ecosystem/community/zio-temporal

A complete example demonstrating a workflow interface, implementation, worker setup, and client invocation using scala-cli.

```scala
//> using scala "3.3.0"  
  
//> using lib "dev.zio::zio:2.0.16"  
//> using lib "dev.vhonta::zio-temporal-core:0.4.0"  
//> using lib "dev.zio::zio-logging:2.1.14"  
//> using lib "dev.zio::zio-logging-slf4j2-bridge:2.1.14"  
  
import zio.*
import zio.temporal.*
import zio.temporal.worker.*
import zio.temporal.workflow.*
import zio.logging.*
  
// This is our workflow interface  
@workflowInterface  
trait EchoWorkflow:
  
  @workflowMethod  
  def echo(str: String): String  
  
// Workflow implementation  
class EchoWorkflowImpl extends EchoWorkflow:
  private val logger = ZWorkflow.makeLogger  
  
  override def echo(str: String): String =
    logger.info(s"Worker: Received \"$str\"")  
    s"ACK: $str"
  
// Main Application  
object Main extends ZIOAppDefault:
  val taskQueue = "echo-queue"  
  
  // Worker implementation  
  val setupWorker = ZWorkerFactory.newWorker(taskQueue) @@
    ZWorker.addWorkflow[EchoWorkflowImpl].fromClass  
  
  // Client implementation  
  def invokeWorkflow(msg: String) = ZIO.serviceWithZIO[ZWorkflowClient]: client =>
    for
      uuid <- Random.nextUUID  
      workflowID = s"echo-$uuid"  
      echoWorkflow <- client
                        .newWorkflowStub[EchoWorkflow]
                        .withTaskQueue(taskQueue)
                        .withWorkflowId(workflowID)
                        .withWorkflowRunTimeout(2.seconds)
                        .withRetryOptions(ZRetryOptions.default.withMaximumAttempts(3))
                        .build
      _   <- ZIO.logInfo(s"Will submit message \"$msg\" with workflow ID $workflowID")  
      res <- ZWorkflowStub.execute(echoWorkflow.echo(msg))  
      _   <- ZIO.logInfo(s"Greeting received: $res")  
    yield res  
  
  // Logging configuration  
  val logFilter: LogFilter[String] = LogFilter.logLevelByName(
    LogLevel.Info,
    "io.grpc.netty" -> LogLevel.Warning,
    "io.netty"      -> LogLevel.Warning,
    "io.temporal"   -> LogLevel.Error,
  )
  override val bootstrap: ZLayer[ZIOAppArgs, Any, Any] =
    Runtime.removeDefaultLoggers >>> consoleLogger(ConsoleLoggerConfig(LogFormat.colored, logFilter))
  
  // ZIO Main Program  
  def run: ZIO[ZIOAppArgs & Scope, Any, Any] =
    val program =
      for
        args           <- getArgs  
        msg             = if args.isEmpty then "testMsg" else args.mkString(" ")  
        _              <- setupWorker  
        _              <- ZWorkerFactory.setup  
        _              <- ZWorkflowServiceStubs.setup()
        workflowResult <- invokeWorkflow(msg)  
        _              <- ZIO.logInfo(s"The workflow result: $workflowResult")  
      yield ExitCode.success  
  
    program
      .provideSome[ZIOAppArgs & Scope](
        ZWorkflowServiceStubsOptions.make,
        ZWorkflowClientOptions.make,
        ZWorkerFactoryOptions.make,
        ZWorkflowClient.make,
        ZWorkflowServiceStubs.make,
        ZWorkerFactory.make,
        slf4j.bridge.Slf4jBridge.initialize,
      )
```

--------------------------------

### Run the Verification Example

Source: https://zio.dev/guides/compositional-fiberref-updates-with-differ

Command to execute the verification suite via sbt.

```bash
sbt "differ-compositional-updates/runMain differcompositionalupdates.DifferLawsVerificationExample"  
```

--------------------------------

### Run Caliban GraphQL Server

Source: https://zio.dev/ecosystem/community/caliban

Implement the ZIOAppDefault to run the Caliban GraphQL server. This example sets up a simple employee query API and starts the server on a specified port.

```scala
object CalibanExample extends zio.ZIOAppDefault {
  import ArgBuilder.auto._  
  import Schema.auto._  
  
  val employees = List(  
    Employee("Alex", Role.DevOps),
    Employee("Maria", Role.SoftwareDeveloper),
    Employee("James", Role.SiteReliabilityEngineer),
    Employee("Peter", Role.SoftwareDeveloper),
    Employee("Julia", Role.SiteReliabilityEngineer),
    Employee("Roberta", Role.DevOps)
  )  
  
  override def run =  
    graphQL(
      RootResolver(
        Queries(
          args => employees.filter(e => args.role == e.role),
          args => employees.find(e => e.name == args.name)
        )
      )
    ).runServer(
      port = 8088,
      apiPath = "/api/graphql",
      graphiqlPath = Some("/api/graphiql"),
    )
}
```

--------------------------------

### ZIO Application with Runtime Logger Reconfiguration

Source: https://zio.dev/zio-logging/reconfigurable-logger

An example ZIO application that utilizes `ReconfigurableLogger` to dynamically update its logging configuration from a file. It sets up a layer that periodically reloads the configuration and installs it.

```Scala
package zio.logging.example

import com.typesafe.config.ConfigFactory
import zio.config.typesafe.TypesafeConfigProvider
import zio.logging.{ConsoleLoggerConfig, LogAnnotation, ReconfigurableLogger, _}
import zio.{ Config, ExitCode, Runtime, Scope, ZIO, ZIOAppDefault, _ }

import java.util.UUID

object LoggerReconfigureApp extends ZIOAppDefault {

  def configuredLogger(
            loadConfig: => ZIO[Any, Config.Error, ConsoleLoggerConfig]
    ): ZLayer[Any, Config.Error, Unit] = 
    ReconfigurableLogger
            .make[Any, Config.Error, String, Any, ConsoleLoggerConfig](
              loadConfig,
              (config, _) => makeConsoleLogger(config),
              Schedule.fixed(500.millis)
            )
            .installUnscoped

  override val bootstrap: ZLayer[ZIOAppArgs, Any, Any] = 
    Runtime.removeDefaultLoggers >>> configuredLogger(
      for {
        config       <- ZIO.succeed(ConfigFactory.load("logger.conf"))
        _            <- Console.printLine(config.getConfig("logger")).orDie
        loggerConfig <- ConsoleLoggerConfig.load().withConfigProvider(TypesafeConfigProvider.fromTypesafeConfig(config))
      } yield loggerConfig
    )

  def exec(): ZIO[Any, Nothing, Unit] = 
    for {
      ok      <- Random.nextBoolean
      traceId <- ZIO.succeed(UUID.randomUUID())
      _       <- ZIO.logDebug("Start") @@ LogAnnotation.TraceId(traceId)
      userIds <- ZIO.succeed(List.fill(2)(UUID.randomUUID().toString))
      _       <- ZIO.foreachPar(userIds) {
        userId =>
          {
            ZIO.logDebug("Starting operation") *> 
                    ZIO.logInfo("OK operation").when(ok) *> 
                    ZIO.logError("Error operation").when(!ok) *> 
                    ZIO.logDebug("Stopping operation")
          } @@ LogAnnotation.UserId(userId)
      } @@ LogAnnotation.TraceId(traceId)
      _       <- ZIO.logDebug("Done") @@ LogAnnotation.TraceId(traceId)
    } yield ()
  
  override def run: ZIO[Scope, Any, ExitCode] = 
    for {
      _ <- exec().repeat(Schedule.fixed(500.millis))
    } yield ExitCode.success

}

```

--------------------------------

### Add Example Values to Schema and Fields

Source: https://zio.dev/zio-blocks/reference/schema

Provide example values for a schema or specific fields. Use the `examples` method for the schema or target fields with optics.

```scala
import zio.blocks.schema._

// Add example values
val withExamples: Schema[Person] = 
  Schema[Person].examples(Person("Alice", 30), Person("Bob", 25))

// Get examples
val examples: Seq[Person] = Schema[Person].examples

// Add examples to a specific field
val fieldExamples: Schema[Person] = 
  Schema[Person].examples(Person.name, "Alice", "Bob", "Charlie")
```

--------------------------------

### DynamicSchema#examples

Source: https://zio.dev/zio-blocks/reference/dynamic-schema

Reads or updates the examples associated with the schema.

```APIDOC
## DynamicSchema#examples

### Description
Manages examples stored within the schema. The zero-argument form returns the current examples, and the multi-argument form returns a copy with the provided examples set.

### Methods
- **examples()**: Returns `Seq[DynamicValue]`.
- **examples(value: DynamicValue, values: DynamicValue*)**: Returns a new `DynamicSchema` with the provided examples.
```

--------------------------------

### Run Example Application with sbt

Source: https://zio.dev/zio-metrics-connectors/metrics/prometheus-client

Command to run the sample application from the command line using sbt. Select the option corresponding to `sample.SamplePrometheusStatsDApp`.

```bash
sbt sampleApp/run
```

--------------------------------

### ConcurrentSet Example Usage

Source: https://zio.dev/reference/sync/concurrentset

Illustrative examples of using ConcurrentSet operations.

```APIDOC
## Example Usage

Given:
```scala
import zio.concurrent.ConcurrentSet  

  
for {  
  emptySet  <- ConcurrentSet.empty[Int]   
  setA      <- ConcurrentSet.make[Int](1, 2, 3, 4)  
} yield ()  
```

Operation| Result  
---|---
`emptySet.add(1).toSet`| Set(1)  
`setA.addAll(Chunk(5, 6).toSet)`| Set(1, 2, 3, 4, 5, 6)  
`setA.remove(1).toSet`| Set(2, 3, 4)  
`setA.removeAll(1, 3).toSet`| Set(2, 4)  
`setA.retainAll(List(1, 3, 5, 6)).toSet`| Set(1, 3)  
`setA.clear.isEmpty`| true  
`setA.contains(5)`| false  
`setA.containsAll(Chunk(1, 2, 3))`| true  
`setA.exists(_ > 4)`| false  
`setA.forAll(_ < 5)`| true  
`setA.removeIf(_ % 2 == 0)`| Set(1, 3)  
`setA.retainIf(_ % 2 == 0)`| Set(2, 4)  
`setA.find(_ > 2)`| Set(3, 4)  
`setA.collectFirst { case 3 => "Three" }`| Set(3)  
`setA.size`| 4  
`setA.transform(_ + 10)`| Set(11, 12, 13, 14)  
`setA.fold(0)(_ + _)`| 10  
```

--------------------------------

### Define Ref get signature

Source: https://zio.dev/reference/concurrency/ref

The signature for the Ref get method.

```scala
def get: IO[EB, B]
```

--------------------------------

### Clone and Run ZIO Quickstarts

Source: https://zio.dev/guides/tutorials/encode-and-decode-json-data

Commands to clone the repository and execute the test suite for the JSON encoding/decoding project.

```bash
$ git clone https://github.com/zio/zio-quickstarts.git  

$ cd zio-quickstarts/zio-quickstart-encode-decode-json-data  
```

```bash
$ sbt Test/runMain dev.zio.quickstart.JsonSpec  
```

--------------------------------

### Start Temporal Development Server

Source: https://zio.dev/ecosystem/community/zio-temporal

Use the Temporal CLI to start a local development server instance.

```bash
temporal server start-dev --ip 0.0.0.0 --db-filename /tmp/temporal.db
```

--------------------------------

### Run Legacy Interop Example

Source: https://zio.dev/zio-blocks/reference/resource-management/scope

Command to execute the legacy library interop example via sbt.

```bash
sbt "scope-examples/runMain scope.examples.legacyLibraryInteropExample"
```

--------------------------------

### FiberRef output example

Source: https://zio.dev/reference/state-management/fiberref

Example output for the FiberRef isolated state demonstration.

```text
left1: 1  

right1: 1  

left2: 2  

right2: 4  
```

--------------------------------

### Ref output example

Source: https://zio.dev/reference/state-management/fiberref

Example output for the Ref shared state demonstration.

```text
left1: 1  

right1: 2  

left2: 3  

right2: 6  
```

--------------------------------

### ScopedRef Example Output

Source: https://zio.dev/reference/resource/scopedref

The console output resulting from the resource management example.

```text
acquiring the first resource  

5  

acquiring the second resource  

releasing the first resource  

10  

releasing the second resource  
```

--------------------------------

### Run the Wire Example via SBT

Source: https://zio.dev/zio-blocks/reference/resource-management/wire

Command to execute the wire shared/unique example using the sbt build tool.

```bash
sbt "scope-examples/runMain wire.wireSharedUniqueExample"
```

--------------------------------

### Run ZIO Kubernetes Example

Source: https://zio.dev/ecosystem/community/scala-k8s

A complete ZIO application example that lists nodes in a cluster.

```scala
import dev.hnaderi.k8s.client._  

import zio.http.Client  

import zio._  

  

//NOTE run `kubectl proxy` before running this example  

object ZIOExample extends ZIOAppDefault {  

  private val app = ZIO.scoped {  

    for {  

      n <- ZIOKubernetesClient.send(APIs.nodes.list())  

      _ <- ZIO.foreach(n.items.map(_.metadata.flatMap(_.name)))(Console.printLine(_))  

    } yield ()  

  }  

  

  override def run =  

    app.provide(  

      Client.default,  

      ZIOBackend.make,  

      ZIOKubernetesClient.make("http://localhost:8001")  

    )  

  

}  
```

--------------------------------

### Setup Type Aliases

Source: https://zio.dev/zio-blocks/reference/typeid

Setup code for testing equivalence with type aliases.

```scala
import zio.blocks.typeid._  

  

type UserId = String  

type Username = String  
```

--------------------------------

### Run the application

Source: https://zio.dev/guides/quickstarts/graphql-webservice

Commands to start the application using sbt.

```bash
sbt run  
```

```bash
sbt reStart  
```

--------------------------------

### Start Seq Container

Source: https://zio.dev/zio-telemetry/opentelemetry-example

Starts a Seq instance with a configured admin password.

```bash
PH=$(echo 'admin123' | docker run --rm -i datalust/seq config hash)  
  
docker run \
  -d \
  --restart unless-stopped \
  -e ACCEPT_EULA=Y \
  -e SEQ_FIRSTRUN_ADMINPASSWORDHASH="$PH" \
  -p 80:80 \
  -p 5341:5341 \
  datalust/seq  
```

--------------------------------

### Start Jaeger Container

Source: https://zio.dev/zio-telemetry/opentelemetry-example

Starts a Jaeger all-in-one instance with OTLP enabled.

```bash
docker run --rm -it \
  -d \
  -e COLLECTOR_OTLP_ENABLED=true \
  -p 4317:4317 \
  -p 16686:16686 \
  jaegertracing/all-in-one:1.47  
```
Tokens:
Raw