Redix

https://github.com/whatyouhide/redix
Admin
Redix is a fast, pipelined, and resilient Redis and Valkey client written in pure Elixir with a...
Tokens:31,525
Snippets:413
Trust Score:9.9
License:MIT
Update:2 months ago
Show doc for...
Tokens:
Raw
### Start a PubSub connection

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/pubsub.md

Examples of starting a PubSub connection using default settings, a URI string, or a keyword list of options.

```elixir
{:ok, pubsub} = Redix.PubSub.start_link()
{:ok, pubsub} = Redix.PubSub.start_link("redis://localhost")
{:ok, pubsub} = Redix.PubSub.start_link(host: "example.com", port: 6379, name: :pubsub)
```

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

### PubSub Usage Example

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/pubsub.md

A complete example demonstrating starting a PubSub connection, subscribing to a channel, and receiving a published message.

```elixir
defmodule MyApp.Listener do
  def run do
    {:ok, pubsub} = Redix.PubSub.start_link()
    {:ok, publisher} = Redix.start_link()

    # Subscribe to a channel
    {:ok, ref} = Redix.PubSub.subscribe(pubsub, "notifications", self())

    # Wait for subscription confirmation
    receive do
      {:redix_pubsub, ^pubsub, ^ref, :subscribed, _} ->
        IO.puts("Subscribed to notifications")
    end

    # Publish a message from another connection
    Redix.command!(publisher, ["PUBLISH", "notifications", "Hello!"])

    # Receive the message
    receive do
      {:redix_pubsub, ^pubsub, ^ref, :message, %{payload: payload}} ->
        IO.puts("Received: #{payload}")
    end

    :ok = Redix.PubSub.stop(pubsub)
  end
end
```

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

### Start Redis Cluster Connection

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/cluster.md

Demonstrates starting a cluster using either URI strings or keyword list configurations.

```elixir
{:ok, _cluster} = Redix.Cluster.start_link(
  name: :my_cluster,
  nodes: ["redis://localhost:7000", "redis://localhost:7001"],
  password: "secret"
)

{:ok, _cluster} = Redix.Cluster.start_link(
  name: :my_cluster,
  nodes: [[host: "redis1", port: 6379], [host: "redis2", port: 6379]],
  ssl: true,
  read_from_replicas: true
)
```

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

### Execute noreply_pipeline/3 example

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/redix.md

Usage example for sending multiple commands without expecting replies.

```elixir
:ok = Redix.noreply_pipeline(conn, [["INCR", "mykey"], ["INCR", "mykey"]])
{:ok, "2"} = Redix.command(conn, ["GET", "mykey"])
```

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

### Parse URI and Start Connection

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/uri.md

Demonstrates parsing a URI and using the resulting options to start a Redix connection.

```elixir
opts = Redix.URI.to_start_options("redis://alice:secret@redis.example.com:6380/2")
# => [
#   host: "redis.example.com",
#   port: 6380,
#   username: "alice",
#   password: "secret",
#   database: 2
# ]

{:ok, conn} = Redix.start_link(opts)
```

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

### Start Redix Cluster

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/configuration.md

Examples of starting a Redix Cluster using URI-based seed nodes or explicit host/port configurations.

```elixir
{:ok, _cluster} = Redix.Cluster.start_link(
  name: :my_cluster,
  nodes: ["redis://localhost:7000", "redis://localhost:7001"],
  password: "secret",
  ssl: true,
  read_from_replicas: true,
  topology_refresh_interval: 30_000
)

# With sync connection and custom socket options:
{:ok, _cluster} = Redix.Cluster.start_link(
  name: :my_cluster,
  nodes: [
    [host: "redis1.example.com", port: 6379],
    [host: "redis2.example.com", port: 6379]
  ],
  sync_connect: true,
  password: "secret",
  socket_opts: [nodelay: true],
  timeout: 10_000
)
```

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

### Start a Redix Pub/Sub process

Source: https://github.com/whatyouhide/redix/blob/main/README.md

Initialize a Pub/Sub process using Redix.PubSub.start_link/2.

```elixir
{:ok, pubsub} = Redix.PubSub.start_link()
```

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

### Redix.PubSub.start_link/2

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/pubsub.md

Starts a connection by merging a URI with options.

```APIDOC
## start_link(uri, options)

### Description
Starts a connection by merging a provided URI with a keyword list of options, where options take precedence.

### Parameters
- **uri** (binary()) - Required - Redis URI.
- **options** (keyword()) - Required - Options to merge.
```

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

### Execute noreply_command/3 example

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/redix.md

Usage example for sending a command without expecting a reply.

```elixir
:ok = Redix.noreply_command(conn, ["INCR", "mykey"])
{:ok, "1"} = Redix.command(conn, ["GET", "mykey"])
```

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

### Start Redix Connection with URI and Options

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/redix.md

Starts a connection by merging a URI with specific options, where options take precedence over URI values.

```elixir
{:ok, conn} = Redix.start_link("redis://localhost", port: 6380)
# port 6380 takes precedence over the URI's default 6379
```

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

### Redix.start_link/2

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/redix.md

Starts a connection by merging a URI with additional options, where options take precedence.

```APIDOC
## Redix.start_link(uri, other_options)

### Description
Starts a connection by merging a URI with options (options take precedence).

### Parameters
- **uri** (binary()) - Required - Redis URI string.
- **other_options** (keyword()) - Required - Options to merge with URI options.

### Returns
- {:ok, pid()} on success
- :ignore if ignored
- {:error, term()} on failure

### Example
{:ok, conn} = Redix.start_link("redis://localhost", port: 6380)
```

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

### Redix.PubSub.start_link/1

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/pubsub.md

Starts a pub/sub connection to Redis using a URI or options keyword list.

```APIDOC
## start_link(uri_or_options)

### Description
Starts a pub/sub connection to Redis. Accepts a Redis URI or a keyword list of options.

### Parameters
- **uri_or_options** (binary() | keyword()) - Optional - Redis URI or options keyword list. Defaults to [].

### Returns
- {:ok, pid()} on success, :ignore, or {:error, term()}.

### Example
{:ok, pubsub} = Redix.PubSub.start_link(host: "example.com", port: 6379, name: :pubsub)
```

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

### Attach handler for pipeline start events

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/telemetry.md

Subscribes to the [:redix, :pipeline, :start] event to log the initiation of command pipelines.

```elixir
:telemetry.attach("redix-pipeline-start", [:redix, :pipeline, :start], fn _event, measurements, metadata ->
  Logger.debug("Pipeline start for commands: #{inspect(metadata.commands)}")
end, nil)
```

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

### Start Redis instances with Docker Compose

Source: https://github.com/whatyouhide/redix/blob/main/README.md

Use this command to spin up all necessary Redis instances required for the Redix test suite.

```bash
docker compose up
```

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

### Start and use a Redix Cluster

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/cluster.md

Demonstrates initializing a cluster connection and performing commands, including pipeline transactions and replica routing.

```elixir
defmodule MyApp.Cluster do
  def start do
    {:ok, _cluster} = Redix.Cluster.start_link(
      name: :my_cluster,
      nodes: ["redis://localhost:7000"],
      read_from_replicas: true
    )
    :ok
  end

  def set_user(id, name, email) do
    Redix.Cluster.transaction_pipeline!(:my_cluster, [
      ["SET", "{user:#{id}}.name", name],
      ["SET", "{user:#{id}}.email", email]
    ])
  end

  def get_user_name(id) do
    Redix.Cluster.command!(:my_cluster, ["GET", "{user:#{id}}.name"])
  end

  def get_user_email_from_replica(id) do
    Redix.Cluster.command!(:my_cluster, ["GET", "{user:#{id}}.email"], route: :prefer_replica)
  end
end
```

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

### Redix.start_link/1

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/redix.md

Starts a connection to Redis using a URI string or a keyword list of options.

```APIDOC
## Redix.start_link(uri_or_options)

### Description
Starts a connection to Redis with options or URI.

### Parameters
- **uri_or_options** (binary() | keyword()) - Required - Redis URI string or keyword list of options.

### Returns
- {:ok, pid()} on success
- :ignore if ignored
- {:error, term()} on failure

### Example
{:ok, conn} = Redix.start_link("redis://localhost:6379")
```

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

### [:redix, :pipeline, :start]

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/telemetry.md

Emitted right before a command or pipeline is sent to Redis.

```APIDOC
## [:redix, :pipeline, :start]

### Description
Emitted before a command or pipeline is sent.

### Measurements
- **system_time** (integer()) - System time in :native unit

### Metadata
- **connection** (pid()) - Connection PID
- **commands** ([[String.Chars.t()]]) - Commands being sent
- **extra_metadata** (any()) - User-provided metadata
```

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

### Redix.Cluster.start_link/1

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/cluster.md

Starts a connection to a Redis Cluster using the provided configuration options.

```APIDOC
## start_link(opts)

### Description
Starts a connection to a Redis Cluster. This function initializes the supervision tree and manages connections to cluster nodes.

### Parameters
- **opts** (keyword()) - Required - Cluster options including :name, :nodes, :sync_connect, :topology_refresh_interval, :read_from_replicas, and standard Redix connection options.

### Returns
- {:ok, supervisor_pid} on success
- {:error, reason} on failure (if sync_connect is true and discovery fails)
```

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

### Start a Redix connection

Source: https://github.com/whatyouhide/redix/blob/main/README.md

Establish a connection to a Redis server using start_link with host/port options or a connection string.

```elixir
{:ok, conn} = Redix.start_link(host: "example.com", port: 5000)
{:ok, conn} = Redix.start_link("redis://localhost:6379/3", name: :redix)
```

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

### Start and use a Redis Cluster connection

Source: https://github.com/whatyouhide/redix/blob/main/pages/Cluster.md

Initializes a cluster connection using seed nodes and executes commands across the cluster.

```elixir
# Start a cluster connection with a name and one or more seed nodes.
{:ok, _pid} = Redix.Cluster.start_link(
  name: :my_cluster,
  nodes: ["redis://localhost:7000", "redis://localhost:7001"]
)

# Issue commands across the cluster.
Redix.Cluster.command(:my_cluster, ["SET", "mykey", "myvalue"])
#=> {:ok, "OK"}
Redix.Cluster.command(:my_cluster, ["GET", "mykey"])
#=> {:ok, "myvalue"}
```

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

### Define start_link Specification

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/cluster.md

Specifies the function signature for starting a Redis Cluster connection.

```elixir
@spec start_link(keyword()) :: Supervisor.on_start()
```

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

### Run Redix Tests

Source: https://github.com/whatyouhide/redix/blob/main/AGENTS.md

Commands to start the Docker cluster environment and execute the test suite.

```sh
docker compose up -d          # start all services including cluster
mix test                      # all tests
mix test test/redix/cluster/  # unit tests (hash, command parser)
mix test test/redix/cluster_test.exs  # integration tests (needs Docker cluster)
```

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

### Start a cluster with synchronous connection

Source: https://github.com/whatyouhide/redix/blob/main/pages/Cluster.md

Forces the process to block until the cluster topology is discovered, failing if no seed nodes are reachable.

```elixir
Redix.Cluster.start_link(
  name: :my_cluster,
  nodes: ["redis://localhost:7000"],
  sync_connect: true
)
```

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

### Start a named Redix instance

Source: https://github.com/whatyouhide/redix/blob/main/pages/Real-world usage.md

Add a named Redix process to the application's supervision tree for global access.

```elixir
children = [
  {Redix, name: :redix}
]
```

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

### PubSub Message Types

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/pubsub.md

Examples of specific message types and their associated property maps.

```elixir
{:redix_pubsub, pubsub, ref, :subscribed, %{channel: "channel_name"}}
```

```elixir
{:redix_pubsub, pubsub, ref, :psubscribed, %{pattern: "pattern"}}
```

```elixir
{:redix_pubsub, pubsub, ref, :unsubscribed, %{channel: "channel_name"}}
```

```elixir
{:redix_pubsub, pubsub, ref, :punsubscribed, %{pattern: "pattern"}}
```

```elixir
{:redix_pubsub, pubsub, ref, :message, %{channel: "channel_name", payload: "message_content"}}
```

```elixir
{:redix_pubsub, pubsub, ref, :pmessage, %{
  channel: "actual_channel",
  pattern: "pattern_matched",
  payload: "message_content"
}}
```

```elixir
{:redix_pubsub, pubsub, ref, :disconnected, %{
  error: %Redix.ConnectionError{reason: :closed}
}}
```

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

### Direct URI Usage in Redix

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/uri.md

Examples of passing URIs directly to Redix functions or supervision trees.

```elixir
{:ok, conn} = Redix.start_link("redis://localhost:6379")
```

```elixir
{:ok, conn} = Redix.start_link(
  "redis://localhost:6379",
  port: 6380,  # overrides URI port
  password: "different_password"
)
```

```elixir
children = [
  {Redix, "redis://example.com:6380"}
]

Supervisor.start_link(children, strategy: :one_for_one)
```

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

### RESP Protocol Prefixes

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/protocol-and-data.md

Examples of RESP data types and their corresponding prefixes used in Redis communication.

```text
+OK\r\n                    Simple string
-Error message\r\n         Error
:1000\r\n                  Integer
$6\r\nfoobar\r\n           Bulk string
$-1\r\n                    Null
*2\r\n$3\r\nfoo\r\n$3\r\nbar\r\n  Array
```

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

### Custom Metrics Handler Implementation

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/telemetry.md

Example of a custom module to handle pipeline stop events and export metrics to Prometheus.

```elixir
defmodule MyApp.Metrics do
  def setup do
    :telemetry.attach_many(
      "my-app-metrics",
      [
        [:redix, :pipeline, :stop]
      ],
      &__MODULE__.handle_event/4,
      nil
    )
  end

  def handle_event([:redix, :pipeline, :stop], measurements, metadata, _config) do
    duration_us = System.convert_time_unit(measurements.duration, :native, :microsecond)
    
    tags = [
      connection: inspect(metadata.connection_name || metadata.connection),
      success: metadata[:kind] != :error
    ]
    
    # Send to monitoring system
    :prometheus.histogram([:redix, :request_duration_us], duration_us, labels: tags)
  end
end
```

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

### Redix.URI.to_start_options/1

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/uri.md

Parses a Redis, Valkey, or rediss URI string into a keyword list of connection options.

```APIDOC
## Redix.URI.to_start_options(uri)

### Description
Parses a Redis URI string into connection options suitable for use with Redix.start_link/1.

### Parameters
- **uri** (String.t) - Required - The Redis URI string (e.g., "redis://localhost:6379").

### Returns
- **keyword()** - A list of connection options including :host, :port, :username, :password, :ssl, and :database.

### Example
```elixir
Redix.URI.to_start_options("redis://localhost:6379")
#=> [host: "localhost", port: 6379]
```
```

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

### Display Project File Structure

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/MANIFEST.md

A visual representation of the project's documentation directory tree and file sizes.

```text
/workspace/home/output/
├── 00-START-HERE.txt                          2.7K  Quick orientation guide
├── README.md                                  8.2K  Overview and coverage summary
├── INDEX.md                                   9.1K  Quick reference index
├── MANIFEST.md                                     This file
├── types.md                                   8.5K  Type definitions and exceptions
├── configuration.md                          12.0K  Connection options reference
├── errors.md                                 11.0K  Error handling guide
├── protocol-and-data.md                       8.6K  Data types and RESP protocol
└── api-reference/
    ├── redix.md                              12.0K  Main Redix API reference
    ├── pubsub.md                              9.2K  Pub/Sub API reference
    ├── cluster.md                            11.0K  Cluster API reference
    ├── telemetry.md                           9.9K  Telemetry and observability
    └── uri.md                                 4.6K  URI parsing reference

Total: 11 files, 3,455 lines, ~110K content
```

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

### Connect and Send Commands

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/INDEX.md

Basic connection and command execution pattern.

```elixir
{:ok, conn} = Redix.start_link()
{:ok, "OK"} = Redix.command(conn, ["SET", "key", "value"])
{:ok, "value"} = Redix.command(conn, ["GET", "key"])
```

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

### Execute a pipeline with raising

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/redix.md

Use pipeline!/3 to issue a pipeline that raises on connection failures.

```elixir
@spec pipeline!(connection(), [command()], keyword()) :: [Redix.Protocol.redis_value()]
```

```elixir
[1, 2, 4] = Redix.pipeline!(conn, [["INCR", "foo"], ["INCR", "foo"], ["INCRBY", "foo", "2"]])
```

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

### Execute Pipeline Commands

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/protocol-and-data.md

Demonstrates executing a list of commands in a single pipeline and handling successful results.

```elixir
{:ok, results} = Redix.pipeline(conn, [
  ["SET", "a", "1"],
  ["SET", "b", "2"],
  ["GET", "a"],
  ["INCR", "counter"]
])
# results = ["OK", "OK", "1", 5]
```

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

### Optimizing String Conversions

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/protocol-and-data.md

Pre-building keys avoids repeated string conversions during high-frequency command execution.

```elixir
# Less efficient: converts to string each time
for i <- 1..1000 do
  Redix.command(conn, ["INCR", "counter:#{i}"])
end

# More efficient: pre-build keys
for i <- 1..1000 do
  key = "counter:#{i}"
  Redix.command(conn, ["INCR", key])
end
```

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

### Configure Redix Pub/Sub

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/configuration.md

Initializes a Pub/Sub connection with asynchronous connection behavior.

```elixir
Redix.PubSub.start_link(
  host: "localhost",
  name: :pubsub,
  sync_connect: false
)
```

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

### Configure Sentinel Connections

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/uri.md

Sentinel configurations require a specific keyword structure rather than a direct URI string.

```elixir
{:ok, conn} = Redix.start_link(
  sentinel: [
    sentinels: [
      "redis://sentinel1.example.com:26379",
      "redis://sentinel2.example.com:26379"
    ],
    group: "mymaster"
  ],
  password: "redis_password"
)
```

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

### Configure Basic SSL

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/configuration.md

Enable SSL for the Redix connection.

```elixir
Redix.start_link(ssl: true)
```

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

### Configure Custom Certificates

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/configuration.md

Provide specific certificate files for SSL connections.

```elixir
Redix.start_link(
  ssl: true,
  socket_opts: [
    cacertfile: "/path/to/ca.pem",
    certfile: "/path/to/client.pem",
    keyfile: "/path/to/key.pem"
  ]
)
```

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

### Execute Cluster Commands

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/cluster.md

Demonstrates issuing single commands to a cluster with optional routing strategies.

```elixir
{:ok, "OK"} = Redix.Cluster.command(:my_cluster, ["SET", "mykey", "myvalue"])
{:ok, "myvalue"} = Redix.Cluster.command(:my_cluster, ["GET", "mykey"])
{:ok, "myvalue"} = Redix.Cluster.command(:my_cluster, ["GET", "mykey"], route: :prefer_replica)
```

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

### Execute a single command with raising

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/redix.md

Use command!/3 to issue a command that raises an exception on any error.

```elixir
@spec command!(connection(), command(), keyword()) :: Redix.Protocol.redis_value()
```

```elixir
"foo" = Redix.command!(conn, ["SET", "mykey", "foo"])
# Raises if connection is closed or Redis returns an error
```

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

### Configure Redix for Production

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/configuration.md

Secure configuration using SSL, environment variables for credentials, and custom backoff settings.

```elixir
Redix.start_link(
  host: System.fetch_env!("REDIS_HOST"),
  port: 6380,
  password: {System, :fetch_env!, ["REDIS_PASSWORD"]},
  ssl: true,
  name: :redis,
  backoff_initial: 500,
  backoff_max: 30_000,
  health_check_interval: 10_000
)
```

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

### Sentinel Configuration

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/INDEX.md

Connecting to Redis via Sentinel.

```elixir
{:ok, conn} = Redix.start_link(
  sentinel: [
    sentinels: ["sentinel1:26379", "sentinel2:26379"],
    group: "mymaster"
  ],
  password: "secret"
)
```

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

### Environment Variable Configuration

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/uri.md

Common pattern for fetching Redis connection strings from system environment variables.

```elixir
redis_url = System.fetch_env!("REDIS_URL")
{:ok, conn} = Redix.start_link(redis_url)
```

```elixir
redis_url = System.fetch_env!("REDIS_URL")
{:ok, conn} = Redix.start_link(
  redis_url,
  password: System.fetch_env!("REDIS_PASSWORD")
)
```

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

### Configure Password Authentication

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/configuration.md

Provide a password for authentication, either as a plain string or dynamically via MFA.

```elixir
Redix.start_link(password: "my_secret_password")
```

```elixir
Redix.start_link(password: {System, :fetch_env!, ["REDIS_PASSWORD"]})
```

```elixir
defmodule MySecrets do
  def get_password do
    System.fetch_env!("REDIS_PASSWORD")
  end
end

Redix.start_link(password: {MySecrets, :get_password, []})
```

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

### Define start_link/1 specification

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/pubsub.md

Type specification for the start_link/1 function.

```elixir
@spec start_link(binary() | keyword()) :: {:ok, pid()} | :ignore | {:error, term()}
```

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

### Define start_link/2 specification

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/pubsub.md

Type specification for the start_link/2 function.

```elixir
@spec start_link(binary(), keyword()) :: {:ok, pid()} | :ignore | {:error, term()}
```

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

### Configure Redix for Development

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/configuration.md

Minimal configuration for connecting to a local Redis instance.

```elixir
Redix.start_link(name: :redis)
```

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

### Parse Redis URI to Connection Options

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/uri.md

Converts a URI string into a keyword list of connection options. The returned list is suitable for passing directly to Redix.start_link/1.

```elixir
@spec to_start_options(String.t()) :: keyword()
```

```elixir
Redix.URI.to_start_options("redis://localhost:6379")
#=> [host: "localhost", port: 6379]

Redix.URI.to_start_options("redis://:secret@example.com:6380/2")
#=> [host: "example.com", port: 6380, password: "secret", database: 2]

Redix.URI.to_start_options("rediss://user:pass@redis.example.com/0")
#=> [host: "redis.example.com", port: 6380, username: "user", password: "pass", ssl: true, database: 0]
```

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

### Redix Module and Function Reference

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/INDEX.md

Quick reference for main entry points, Pub/Sub, Cluster, and utility functions.

```elixir
Redix.start_link/1,2        # Connect to Redis
Redix.stop/2                # Close connection
Redix.command/3             # Send single command
Redix.command!/3            # Raise on error
Redix.pipeline/3            # Send multiple commands
Redix.pipeline!/3           # Raise on error
Redix.transaction_pipeline/3    # MULTI/EXEC
Redix.noreply_command/3         # Fire and forget
Redix.noreply_pipeline/3        # Multiple without replies
```

```elixir
Redix.PubSub.start_link/1,2     # Start pub/sub connection
Redix.PubSub.stop/2             # Stop pub/sub
Redix.PubSub.subscribe/3        # Subscribe to channels
Redix.PubSub.unsubscribe/3      # Unsubscribe from channels
Redix.PubSub.psubscribe/3       # Subscribe to patterns
Redix.PubSub.punsubscribe/3     # Unsubscribe from patterns
Redix.PubSub.ping/2             # Health check
```

```elixir
Redix.Cluster.start_link/1      # Start cluster connection
Redix.Cluster.stop/2            # Stop cluster
Redix.Cluster.command/3         # Send command with routing
Redix.Cluster.command!/3        # Raise on error
Redix.Cluster.pipeline/3        # Multi-node pipeline
Redix.Cluster.pipeline!/3       # Raise on error
Redix.Cluster.transaction_pipeline/3    # MULTI/EXEC in cluster
```

```elixir
Redix.URI.to_start_options/1    # Parse Redis URI → options
Redix.Telemetry.attach_default_handler/0    # Default logging
```

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

### Handle Native Integer Responses

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/protocol-and-data.md

Demonstrates commands that return integers directly via the RESP protocol.

```elixir
{:ok, 42} = Redix.command(conn, ["DBSIZE"])  # count is an integer in RESP
{:ok, 10} = Redix.command(conn, ["STRLEN", "key"])  # length is an integer
```

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

### Connect to Redis Sentinel

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/redix.md

Use the :sentinel option in start_link to configure automatic failover with a list of sentinel addresses and a primary group name.

```elixir
{:ok, conn} = Redix.start_link(
  sentinel: [
    sentinels: ["redis://sent1.example.com:26379", "redis://sent2.example.com:26379"],
    group: "mymaster"
  ],
  password: "secret"
)
```

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

### Implement a name-based Redix connection pool

Source: https://github.com/whatyouhide/redix/blob/main/pages/Real-world usage.md

Create a wrapper module that manages a pool of named Redix connections and distributes commands using a random index strategy.

```elixir
defmodule MyApp.Redix do
  @pool_size 5

  def child_spec(_args) do
    # Specs for the Redix connections.
    children =
      for index <- 0..(@pool_size - 1) do
        Supervisor.child_spec({Redix, name: :"redix_#{index}"}, id: {Redix, index})
      end

    # Spec for the supervisor that will supervise the Redix connections.
    %{
      id: RedixSupervisor,
      type: :supervisor,
      start: {Supervisor, :start_link, [children, [strategy: :one_for_one]]}
    }
  end

  def command(command) do
    Redix.command(:"redix_#{random_index()}", command)
  end

  defp random_index do
    Enum.random(0..@pool_size - 1)
  end
end
```

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

### Handle Nil Responses

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/protocol-and-data.md

Matches the nil response returned when a key does not exist.

```elixir
{:ok, nil} = Redix.command(conn, ["GET", "nonexistent"])
```

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

### pipeline_options()

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/types.md

Configuration options for standard Redix commands and pipelines.

```APIDOC
## pipeline_options()

### Description
Configuration options used in `Redix.command/3`, `Redix.pipeline/3`, and `Redix.transaction_pipeline/3`.

### Parameters
- **timeout** (timeout()) - Optional - Request timeout in milliseconds (Default: 5000)
- **telemetry_metadata** (map()) - Optional - Extra metadata for telemetry events (Default: %{})
```

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

### Visualize Redix Cluster Architecture

Source: https://github.com/whatyouhide/redix/blob/main/AGENTS.md

A structural representation of the Redix Cluster supervisor tree and its associated components.

```text
Redix.Cluster (Supervisor, public API)
├── Registry (unique keys, node_id -> Redix pid)
├── DynamicSupervisor (supervises Redix connections)
├── Task.Supervisor (parallel pipeline execution)
└── Redix.Cluster.Manager (gen_statem: topology + connection lifecycle)
    ├── ETS: slot_table (slot 0..16383 -> {primary_id, [replica_id]})
    └── ETS: command_cache (command name -> key spec, for commands outside the table)
```

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

### Handle Redix.Error in commands and pipelines

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/errors.md

Demonstrates pattern matching on Redix.Error when executing commands or processing pipeline results.

```elixir
case Redix.command(conn, command) do
  {:ok, %Redix.Error{message: msg}} ->
    IO.puts("Redis error: #{msg}")
    
  {:ok, value} ->
    IO.puts("Success: #{value}")
    
  {:error, %Redix.ConnectionError{} = error} ->
    IO.puts("Connection error: #{error}")
end

# Or raise it
case result do
  {:error, %Redix.Error{} = error} -> raise error
  {:ok, value} -> value
end

# In pipelines, errors are values in the results list
{:ok, results} = Redix.pipeline(conn, commands)
results
|>
Enum.with_index()
|>
Enum.each(fn {result, idx} ->
  case result do
    %Redix.Error{message: msg} ->
      IO.puts("Command #{idx} error: #{msg}")
    value ->
      IO.puts("Command #{idx} ok: #{value}")
  end
end)
```

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

### Use Cluster in Supervision Tree

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/cluster.md

Shows how to include the cluster as a child within a supervision tree.

```elixir
children = [
  {Redix.Cluster, name: :my_cluster, nodes: ["redis://localhost:7000"]}
]

Supervisor.start_link(children, strategy: :one_for_one)
```

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

### Execute commands using the custom pool wrapper

Source: https://github.com/whatyouhide/redix/blob/main/pages/Real-world usage.md

Invoke the command function on the custom wrapper module to utilize the connection pool.

```elixir
MyApp.Redix.command(["PING"])
#=> {:ok, "PONG"}
```

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

### Transaction Pipeline

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/INDEX.md

Execute commands within a MULTI/EXEC block.

```elixir
{:ok, results} = Redix.transaction_pipeline(conn, [
  ["SET", "a", "1"],
  ["INCR", "a"],
  ["GET", "a"]
])
# results = ["OK", 2, "2"]
```

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

### Execute Commands with Various Data Types

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/protocol-and-data.md

Demonstrates how different Elixir data types are passed to Redix commands and converted to RESP.

```elixir
Redix.command(conn, ["SET", "key", 42])          # integer
Redix.command(conn, ["SET", "key", :atom])       # atom → "atom"
Redix.command(conn, ["SET", "key", "string"])    # string (binary)
Redix.command(conn, ["INCRBY", "counter", 5])    # numeric
```

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

### Configure Custom Hostname Verification

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/configuration.md

Use a custom function for hostname verification during the SSL handshake.

```elixir
Redix.start_link(
  ssl: true,
  socket_opts: [
    customize_hostname_check: [
      match_fun: :public_key.pkix_verify_hostname_match_fun(:https)
    ]
  ]
)
```

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

### Handle OK Responses

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/protocol-and-data.md

Matches the standard success response from Redis commands.

```elixir
{:ok, "OK"} = Redix.command(conn, ["SET", "key", "value"])
```

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

### Integrate Connection Logging with Logger

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/telemetry.md

Uses the built-in log handler to monitor connection lifecycle events.

```elixir
:telemetry.attach_many(
  "my-app-logs",
  [
    [:redix, :connection],
    [:redix, :disconnection],
    [:redix, :failed_connection]
  ],
  &Redix.Telemetry.log_handler/4,
  level: :info
)
```

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

### Execute a transaction with raising

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/redix.md

Use transaction_pipeline!/3 to execute a transaction that raises on errors.

```elixir
@spec transaction_pipeline!(connection(), [command()], keyword()) :: [Redix.Protocol.redis_value()]
```

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

### Attach Default Handler in Application Startup

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/telemetry.md

Registers the default Redix telemetry handler within the application supervisor.

```elixir
# Attach in your application startup
def start(_type, _args) do
  Redix.Telemetry.attach_default_handler()
  
  children = [
    {Redix, host: "localhost", name: :redis}
  ]
  
  Supervisor.start_link(children, strategy: :one_for_one)
end
```

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

### Integrate Redix into Supervision Tree

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/redix.md

Demonstrates how to include Redix connections within an Elixir supervision tree using various configuration formats.

```elixir
children = [
  {Redix, host: "localhost", name: :redix},
  {Redix, "redis://example.com:6380"},
  {Redix, {"redis://localhost", [name: :redix_alt]}}
]

Supervisor.start_link(children, strategy: :one_for_one)
```

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

### Receive subscription confirmation

Source: https://github.com/whatyouhide/redix/blob/main/README.md

Handle the subscription confirmation message sent by the Pub/Sub process.

```elixir
receive do
  {:redix_pubsub, ^pubsub, ^ref, :subscribed, %{channel: "my_channel"}} -> :ok
end
```

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

### Cluster Command and Pipeline Execution

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/protocol-and-data.md

Performing standard commands and pipelines against a Redis cluster, including handling partial failure scenarios.

```elixir
{:ok, "OK"} = Redix.Cluster.command(:cluster, ["SET", "key", "value"])
{:ok, ["val1", "val2"]} = Redix.Cluster.pipeline(:cluster, [["GET", "k1"], ["GET", "k2"]])
```

```elixir
{:ok, results} = Redix.Cluster.pipeline(:cluster, commands)
# results = [success_value, %Redix.ConnectionError{...}, success_value]
```

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

### Subscribe to a channel

Source: https://github.com/whatyouhide/redix/blob/main/README.md

Subscribe to a specific channel using the Pub/Sub process.

```elixir
{:ok, pubsub} = Redix.PubSub.start_link()

Redix.PubSub.subscribe(pubsub, "my_channel", self())
#=> {:ok, ref}
```

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

### noreply_pipeline!/3

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/redix.md

Issues multiple Redis commands in a pipeline without expecting replies, raising an exception on error.

```APIDOC
## Redix.noreply_pipeline!/3

### Description
Issues a pipeline without replies, raising an error if the operation fails.

### Signature
`noreply_pipeline!(connection(), [command()], keyword()) :: :ok`
```

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

### noreply_pipeline/3

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/redix.md

Issues multiple Redis commands in a pipeline without expecting replies.

```APIDOC
## Redix.noreply_pipeline/3

### Description
Issues multiple commands in a single pipeline without expecting replies.

### Signature
`noreply_pipeline(connection(), [command()], keyword()) :: :ok | {:error, atom() | Redix.Error.t() | Redix.ConnectionError.t()}`

### Example
```elixir
:ok = Redix.noreply_pipeline(conn, [["INCR", "mykey"], ["INCR", "mykey"]])
```
```

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

### subscribe/3

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/pubsub.md

Subscribes a process to one or more channels.

```APIDOC
## subscribe(connection(), String.t() | [String.t()], subscriber())

### Description
Subscribes a process to one or more channels.

### Parameters
- **conn** (connection()) - Required - PubSub connection PID or name
- **channels** (String.t() | [String.t()]) - Required - Single channel or list of channels
- **subscriber** (subscriber()) - Optional (default: self()) - Process to receive messages

### Returns
`{:ok, subscription_ref}` where `subscription_ref` is used to match messages for this subscription.
```

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

### Handle Binary Data

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/protocol-and-data.md

Retrieves binary or bit data which is returned as a string.

```elixir
{:ok, bits} = Redix.command(conn, ["GETRANGE", "key", "0", "10"])
# bits = binary() representing bytes 0-10
```

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

### Define Cluster Command Options

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/types.md

Specifies the structure for cluster command options including timeout and routing strategy.

```elixir
@type cluster_command_options() :: [
  timeout: timeout(),
  route: :primary | :replica | :prefer_replica
]
```

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

### Add Redix dependency to mix.exs

Source: https://github.com/whatyouhide/redix/blob/main/README.md

Include the Redix package and optional castore dependency for SSL support in your project's dependency list.

```elixir
defp deps do
  [
    {:redix, "~> 1.1"},
    {:castore, ">= 0.0.0"}
  ]
end
```

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

### Handle Redix.ConnectionError results

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/types.md

Demonstrates pattern matching on specific connection error reasons and explicit raising.

```elixir
case Redix.command(conn, ["PING"]) do
  {:error, %Redix.ConnectionError{reason: :closed}} ->
    IO.puts("Connection closed; Redix is reconnecting...")
  {:error, %Redix.ConnectionError{reason: :timeout}} ->
    IO.puts("Command timed out")
  {:error, %Redix.ConnectionError{} = error} ->
    IO.puts("Connection error: #{Exception.message(error)}")
  {:ok, value} ->
    IO.puts("Success: #{value}")
end

# Raise it
case result do
  {:error, %Redix.ConnectionError{} = error} -> raise error
  {:ok, value} -> value
end
```

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

### Handle Redix.Error results

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/types.md

Demonstrates pattern matching on Redix.Error and explicit raising of the error.

```elixir
case Redix.command(conn, ["INCR", "string_key"]) do
  {:ok, %Redix.Error{message: msg}} -> IO.puts("Error: #{msg}")
  {:ok, value} -> IO.puts("Success: #{value}")
  {:error, error} -> IO.puts("Connection error: #{error}")
end

# Raise it explicitly if needed
case result do
  {:error, %Redix.Error{} = error} -> raise error
  {:ok, value} -> value
end
```

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

### noreply_command/3

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/redix.md

Issues a single Redis command without expecting a reply.

```APIDOC
## Redix.noreply_command/3

### Description
Issues a command to the Redis server without waiting for a reply, saving bandwidth.

### Signature
`noreply_command(connection(), command(), keyword()) :: :ok | {:error, atom() | Redix.Error.t() | Redix.ConnectionError.t()}`

### Example
```elixir
:ok = Redix.noreply_command(conn, ["INCR", "mykey"])
```
```

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

### Configure Redix with sync_connect and exit_on_disconnection

Source: https://github.com/whatyouhide/redix/blob/main/pages/Reconnections.md

Use this configuration to ensure a Redix process is treated as a vital dependency, causing the supervisor to restart dependent processes if the connection fails or drops.

```elixir
isolated_children = [
  {Redix, sync_connect: true, exit_on_disconnection: true},
  MyApp.MyGenServer
]

isolated_supervisor = %{
  id: MyChildSupervisor,
  type: :supervisor,
  start: {Supervisor, :start_link, [isolated_children, [strategy: :rest_for_one]]},
}

children = [
  MyApp.Child1,
  isolated_supervisor,
  MyApp.Child2
]

Supervisor.start_link(children, strategy: :one_for_one)
```

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

### noreply_command!/3

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/redix.md

Issues a single Redis command without expecting a reply, raising an exception on error.

```APIDOC
## Redix.noreply_command!/3

### Description
Issues a command without reply, raising an error if the operation fails.

### Signature
`noreply_command!(connection(), command(), keyword()) :: :ok`
```

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

### Execute multiple commands via pipeline

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/redix.md

Use pipeline/3 to send multiple commands in a single request. Connection errors return {:error, reason}, while individual Redis errors are included in the results list.

```elixir
@spec pipeline(connection(), [command()], keyword()) ::
  {:ok, [Redix.Protocol.redis_value()]} |
  {:error, atom() | Redix.Error.t() | Redix.ConnectionError.t()}
```

```elixir
{:ok, [1, 2, 4]} = Redix.pipeline(conn, [
  ["INCR", "foo"],
  ["INCR", "foo"],
  ["INCRBY", "foo", "2"]
])

{:ok, ["OK", %Redix.Error{message: "..."}, "foo"]} = Redix.pipeline(conn, [
  ["SET", "k", "foo"],
  ["INCR", "k"],
  ["GET", "k"]
])
```

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

### Handle :too_many_redirections error in Elixir

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/errors.md

Demonstrates handling a :too_many_redirections error when the cluster hop limit is exceeded.

```elixir
{:error, %Redix.ConnectionError{reason: :too_many_redirections}} = Redix.Cluster.command(
  :my_cluster,
  ["GET", "key"]
)
```

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

### Handle POSIX/OS connection errors in Elixir

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/errors.md

Shows how to catch network-level errors like :econnrefused.

```elixir
{:ok, conn} = Redix.start_link(host: "unreachable.example.com", sync_connect: true)
# Returns {:error, %Redix.ConnectionError{reason: :econnrefused}}
```

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

### Telemetry Logging

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/INDEX.md

Attaching default or custom telemetry handlers for monitoring.

```elixir
Redix.Telemetry.attach_default_handler()

# Or custom:
:telemetry.attach("my-redis", [:redix, :pipeline, :stop], fn _event, measurements, metadata ->
  duration_ms = System.convert_time_unit(measurements.duration, :native, :millisecond)
  IO.inspect({metadata.commands, duration_ms})
end, nil)
```

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

### Execute Redis pipelines

Source: https://github.com/whatyouhide/redix/blob/main/README.md

Send multiple commands at once using Redix.pipeline/2,3 to receive a list of responses.

```elixir
Redix.pipeline(conn, [["INCR", "foo"], ["INCR", "foo"], ["INCRBY", "foo", "2"]])
#=> {:ok, [1, 2, 4]}
```

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

### Pipeline Multiple Commands

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/INDEX.md

Execute multiple commands in a single network round-trip.

```elixir
{:ok, results} = Redix.pipeline(conn, [
  ["SET", "a", "1"],
  ["SET", "b", "2"],
  ["GET", "a"]
])
# results = ["OK", "OK", "1"]
```

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

### Subscribe to channels in Elixir

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/pubsub.md

Subscribes a process to one or more channels. Returns a reference used to match confirmation messages.

```elixir
@spec subscribe(connection(), String.t() | [String.t()], subscriber()) :: {:ok, reference()}
```

```elixir
{:redix_pubsub, ^pubsub, ^subscription_ref, :subscribed, %{channel: "channel_name"}}
```

```elixir
{:ok, ref} = Redix.PubSub.subscribe(pubsub, "my_channel", self())

receive do
  {:redix_pubsub, ^pubsub, ^ref, :subscribed, %{channel: "my_channel"}} ->
    IO.puts("Subscribed!")
end
```

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

### cluster_command_options()

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/types.md

Configuration options for Redix Cluster commands and pipelines.

```APIDOC
## cluster_command_options()

### Description
Configuration options used in `Redix.Cluster.command/3` and `Redix.Cluster.pipeline/3`.

### Parameters
- **timeout** (timeout()) - Optional - Request timeout in milliseconds (Default: 5000)
- **route** (atom) - Optional - Routing strategy, options are :primary, :replica, or :prefer_replica (Default: :primary)
```

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

### Attach a Telemetry handler

Source: https://github.com/whatyouhide/redix/blob/main/pages/Telemetry.md

Register the custom handler module with the Telemetry library during application startup to begin receiving events.

```elixir
events = [
  [:redix, :disconnection],
  [:redix, :failed_connection],
  [:redix, :connection]
]

:telemetry.attach_many(
  "my-redix-log-handler",
  events,
  &MyApp.RedixTelemetryHandler.handle_event/4,
  :config_not_needed_here
)
```

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

### Execute Cluster Command Raising Errors

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/cluster.md

Issues a command and raises an exception on failure.

```elixir
"OK" = Redix.Cluster.command!(:my_cluster, ["SET", "mykey", "myvalue"])
```

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

### Handle :closed connection error in Elixir

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/errors.md

Demonstrates handling a :closed error when the connection is not yet established or is reconnecting.

```elixir
{:ok, conn} = Redix.start_link()
# If Redis is not running yet and sync_connect: false (default):
{:error, %Redix.ConnectionError{reason: :closed}} = Redix.command(conn, ["PING"])
# After Redis starts and Redix reconnects:
{:ok, "PONG"} = Redix.command(conn, ["PING"])
```

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

### Execute commands on a named Redix instance

Source: https://github.com/whatyouhide/redix/blob/main/pages/Real-world usage.md

Use the registered name to send commands to the specific Redix process.

```elixir
Redix.command(:redix, ["PING"])
#=> {:ok, "PONG"}
```

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

### Redix.pipeline/3

Source: https://github.com/whatyouhide/redix/blob/main/_autodocs/api-reference/redix.md

Issues multiple commands in a single request.

```APIDOC
## Redix.pipeline(conn, commands, options)

### Description
Issues multiple commands in a single request. Returns `{:ok, results}` where results is a list parallel to commands.

### Parameters
- **conn** (connection()) - Required - Connection PID or name
- **commands** ([command()]) - Required - List of commands
- **options** (keyword()) - Optional - Options: `:timeout` or `:telemetry_metadata`

### Example
```elixir
{:ok, [1, 2, 4]} = Redix.pipeline(conn, [["INCR", "foo"], ["INCR", "foo"], ["INCRBY", "foo", "2"]])
```
```
Tokens:
Raw