ElixirCache

https://hexdocs.pm/elixir_cache
Admin
ElixirCache is a standardized and testable caching library for Elixir applications. It provides a...
Tokens:47,720
Snippets:498
Trust Score:9
Update:3 months ago
Show doc for...
Tokens:
Raw
### Setup StatsD Metrics

Source: https://hexdocs.pm/elixir_cache/using_metrics.html

Integrate ElixirCache metrics with StatsD for reporting. This example shows how to start the Telemetry supervisor with StatsD reporters.

```elixir
defmodule MyApp.Application do
  use Application

  def start(_type, _args) do
    children = [
      # Start the Telemetry supervisor
      {TelemetryMetricsStatsd, metrics: MyApp.Metrics.metrics()},
      
      # ... other children
      MyApp.Cache
    ]

    opts = [strategy: :one_for_one, name: MyApp.Supervisor]
    Supervisor.start_link(children, opts)
  end
end
```

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

### Initialize Cache Sandbox Registry in Test Setup

Source: https://hexdocs.pm/elixir_cache/using_strategies.html

This setup function must be called in your test environment to start the `Cache.SandboxRegistry` for the configured cache. This ensures proper isolation for tests using sandboxed strategies.

```elixir
setup do
  Cache.SandboxRegistry.start(MyApp.Cache)
  :ok
end
```

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

### Start Sandbox Registry Link

Source: https://hexdocs.pm/elixir_cache/Cache.SandboxRegistry.html

Starts the sandbox registry process. Use this function to initiate the registry in a linked manner.

```elixir
@spec start_link() :: {:error, any()} | {:ok, pid()}
```

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

### Start Telemetry Handlers in Supervision Tree

Source: https://hexdocs.pm/elixir_cache/using_metrics.html

Integrate the ElixirCache telemetry setup into your application's supervision tree to ensure handlers are active on startup. This involves calling the setup function and including the cache module as a child.

```elixir
def start(_type, _args) do
  # Set up telemetry handlers
  MyApp.CacheMetrics.setup()

  children = [
    # ... other children
    MyApp.Cache
  ]

  opts = [strategy: :one_for_one, name: MyApp.Supervisor]
  Supervisor.start_link(children, opts)
end
```

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

### Cache.ETS Configuration Example

Source: https://hexdocs.pm/elixir_cache/Cache.ETS.html

Example of how to configure the Cache.ETS adapter in your application.

```APIDOC
## Cache.ETS Configuration Example

### Description
This example demonstrates how to use the `Cache` module with the `Cache.ETS` adapter, specifying a cache name and custom options.

### Usage
```elixir
defmodule MyApp.Cache do
  use Cache,
    adapter: Cache.ETS,
    name: :my_app_cache,
    opts: [
      read_concurrency: true,
      write_concurrency: true
    ]
end
```
```

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

### Verify ElixirCache Installation

Source: https://hexdocs.pm/elixir_cache/installation.html

Test your cache by storing and retrieving a value using `put` and `get` functions.

```elixir
# Store a value
MyApp.Cache.put("my_key", "Hello, ElixirCache!")

# Retrieve a value
{:ok, value} = MyApp.Cache.get("my_key")
IO.puts(value) # Outputs: Hello, ElixirCache!
```

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

### Use Sandbox in Tests

Source: https://hexdocs.pm/elixir_cache/testing_with_cache.html

Register your cache in each test's `setup` block using `Cache.SandboxRegistry.start/1`. This starts the cache supervisor and registers the current test process for isolation, ensuring tests do not interfere with each other.

```elixir
defmodule MyApp.CacheTest do
  use ExUnit.Case, async: true

  setup do
    Cache.SandboxRegistry.start(MyApp.Cache)
    :ok
  end

  test "stores and retrieves values" do
    assert :ok === MyApp.Cache.put("key", "value")
    assert {:ok, "value"} === MyApp.Cache.get("key")
  end

  test "each test is isolated" do
    assert {:ok, nil} === MyApp.Cache.get("key")
  end
end
```

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

### start_link

Source: https://hexdocs.pm/elixir_cache/Cache.html

Starts the cache module under a supervisor with options.

```APIDOC
## start_link(cache_children, opts)

### Description
Starts the cache module under a supervisor with the given children and options.

### Parameters
#### Path Parameters
- **cache_children** (any()) - The children to start.
- **opts** (Keyword.t()) - Options for starting the cache.

### Response
#### Success Response (200)
- **result** (any()) - The result of starting the cache.
```

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

### start_link

Source: https://hexdocs.pm/elixir_cache/Cache.html

Starts the cache module under a supervisor.

```APIDOC
## start_link(cache_opts)

### Description
Starts the cache module with the given options under a supervisor.

### Parameters
#### Path Parameters
- **cache_opts** (Keyword.t()) - Options for starting the cache.

### Response
#### Success Response (200)
- **result** (any()) - The result of starting the cache.
```

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

### Cache.Redis Configuration Example

Source: https://hexdocs.pm/elixir_cache/Cache.Redis.html

Example of how to configure the Cache.Redis adapter in your Elixir application.

```APIDOC
## Example
```elixir
defmodule MyApp.RedisCache do
  use Cache,
    adapter: Cache.Redis,
    name: :my_app_redis_cache,
    opts: [
      uri: "redis://localhost:6379",
      size: 10,
      max_overflow: 5
    ]
end
```
```

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

### start_link/1

Source: https://hexdocs.pm/elixir_cache/Cache.html

Starts the cache process as a child of a supervisor.

```APIDOC
## start_link/1

### Description
Starts the cache process, typically used when integrating with a supervisor.

### Function Signature
```elixir
start_link(cache_opts :: Keyword.t()) :: {:ok, pid()} | {:error, {:already_started, pid()} | {:shutdown, term()} | term()} | :ignore
```

### Parameters
* `cache_opts` - A keyword list of options for starting the cache process.
```

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

### Create a CacheCase Module with Supervisors

Source: https://hexdocs.pm/elixir_cache/testing_with_cache.html

Define a `CacheCase` module using `Cache.CaseTemplate` with `:supervisors`. This allows `Cache.CaseTemplate` to discover and start `Cache` children from the specified supervisors at runtime, keeping test setup synchronized with production.

```elixir
defmodule MyApp.CacheCase do
  use Cache.CaseTemplate, supervisors: [MyApp.Supervisor]
end
```

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

### Example of using get_or_create to fetch or create a user

Source: https://hexdocs.pm/elixir_cache/Cache.html

Demonstrates how to use `get_or_create/3` to retrieve a user from the cache or create it by calling `UserRepo.get/1` if it doesn't exist. Handles potential 'not found' errors.

```elixir
Cache.get_or_create(MyApp.Cache, "user:123", fn ->
  case UserRepo.get(123) do
    nil -> {:error, ErrorMessage.not_found("User not found")}
    user -> {:ok, user}
  end
end)
```

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

### Starting Cache Sandbox Registry

Source: https://hexdocs.pm/elixir_cache/Cache.html

Ensure the Cache.SandboxRegistry is started in your test_helper.exs to enable sandboxed caches for test isolation. This is crucial for running asynchronous tests safely.

```elixir
Cache.SandboxRegistry.start_link()
ExUnit.start()
```

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

### child_spec/1

Source: https://hexdocs.pm/elixir_cache/Cache.DETS.html

Returns a specification to start this module under a supervisor. The argument `arg` is passed to `Task.start_link/1`.

```APIDOC
## child_spec(arg)

### Description
Returns a specification to start this module under a supervisor.
`arg` is passed as the argument to `Task.start_link/1` in the `:start` field of the spec.
For more information, see the `Supervisor` module, the `Supervisor.child_spec/2` function and the `Supervisor.child_spec/0` type.

### Function Signature
child_spec(arg)
```

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

### Start Additional Caches in a Test File

Source: https://hexdocs.pm/elixir_cache/testing_with_cache.html

To start additional caches for a specific test file, pass them via the `:caches` option when using your custom `CacheCase` module (e.g., `use MyApp.CacheCase, caches: [MyApp.AdminCache]`).

```elixir
defmodule MyApp.AdminTest do
  use ExUnit.Case, async: true
  use MyApp.CacheCase, caches: [MyApp.AdminCache]

  test "admin cache is also started" do
    assert {:ok, nil} = MyApp.AdminCache.get("key")
  end
end
```

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

### Cache.Strategy Callback: get

Source: https://hexdocs.pm/elixir_cache/Cache.Strategy.html

Defines the callback signature for `get`. It fetches a value from the cache using the strategy's routing or layering logic.

```elixir
@callback get(
  cache_name :: atom(),
  key :: atom() | String.t(),
  strategy_config :: term(),
  adapter_opts :: Keyword.t()
) :: ErrorMessage.t_res(any())
```

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

### Basic Cache Operations

Source: https://hexdocs.pm/elixir_cache/Cache.html

Perform basic cache operations like getting, putting, and retrieving values using the defined cache module. `get` returns `{:ok, nil}` if the key does not exist.

```elixir
MyModule.get("key") #> {:ok, nil}
MyModule.put("key", "value") #> :ok
MyModule.get("key") #> {:ok, "value"}
```

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

### child_spec/1

Source: https://hexdocs.pm/elixir_cache/Cache.Counter.html

Returns a specification to start this module under a supervisor.

```APIDOC
## child_spec/1

### Description
Returns a specification to start this module under a supervisor.

### Method
`child_spec(arg)`

### Parameters
#### Path Parameters
- `arg` - Argument passed to `Task.start_link/1`.
```

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

### Create a CacheCase Module with Default Caches

Source: https://hexdocs.pm/elixir_cache/testing_with_cache.html

Define a `CacheCase` module using `Cache.CaseTemplate` with `:default_caches` to automatically start specified cache modules for all tests using this `CacheCase`.

```elixir
# test/support/cache_case.ex
defmodule MyApp.CacheCase do
  use Cache.CaseTemplate, default_caches: [MyApp.UserCache, MyApp.SessionCache]
end
```

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

### get

Source: https://hexdocs.pm/elixir_cache/Cache.html

Retrieves an item from the cache.

```APIDOC
## get(cache_name, key)

### Description
Retrieves an item from the specified cache.

### Parameters
#### Path Parameters
- **cache_name** (atom()) - The name of the cache.
- **key** (atom() | String.t()) - The key of the item to retrieve.

### Response
#### Success Response (200)
- **value** (any()) - The retrieved value from the cache.
```

```APIDOC
## get(cache_name, key, t)

### Description
Retrieves an item from the specified cache with a timeout.

### Parameters
#### Path Parameters
- **cache_name** (atom()) - The name of the cache.
- **key** (atom() | String.t()) - The key of the item to retrieve.
- **t** (Keyword.t()) - Timeout options.

### Response
#### Success Response (200)
- **value** (any()) - The retrieved value from the cache.
```

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

### Redis Adapter - hash_get_all/1

Source: https://hexdocs.pm/elixir_cache/api.html

Gets all fields and values from a hash in Redis.

```APIDOC
## hash_get_all/1

### Description
Get all fields in a hash from Redis.

### Parameters
#### Path Parameters
- **key** (string) - Required - The key of the hash.

### Returns
All fields and values in the hash.
```

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

### Define CacheCase discovering caches at runtime

Source: https://hexdocs.pm/elixir_cache/Cache.CaseTemplate.html

Use this to define a `CacheCase` module that discovers and starts cache modules by inspecting running supervisors at runtime.

```elixir
defmodule MyApp.CacheCase do
  use Cache.CacheTemplate, supervisors: [MyApp.Supervisor]
end
```

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

### Redis Adapter - json_get/1

Source: https://hexdocs.pm/elixir_cache/api.html

Gets the entire JSON object from Redis.

```APIDOC
## json_get/1

### Description
Get the entire JSON from Redis.

### Parameters
#### Path Parameters
- **key** (string) - Required - The key of the JSON document.

### Returns
The JSON document.
```

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

### Get or Create Pattern

Source: https://hexdocs.pm/elixir_cache/basic_operations.html

Implement the get_or_create pattern to retrieve a value or create it if it doesn't exist. The provided function is only executed if the key is not found.

```elixir
{:ok, user} = MyApp.Cache.get_or_create("user:1", fn ->
  # This function will only run if the key doesn't exist in the cache
  {:ok, %{name: "John", role: "admin"}}
end)
```

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

### Setup Prometheus Metrics

Source: https://hexdocs.pm/elixir_cache/using_metrics.html

Configure Prometheus to collect ElixirCache metrics. This involves defining the metrics and setting up the Prometheus telemetry reporters and HTTP endpoint.

```elixir
defmodule MyApp.PrometheusMetrics do
  def setup do
    # Define metrics that Prometheus will collect
    metrics = MyApp.Metrics.metrics()
    
    # Attach Prometheus reporters to these metrics
    :prometheus_telemetry.setup(metrics)
    
    # Start the Prometheus metrics HTTP endpoint
    Plug.Cowboy.http(PrometheusTelemetry.Plug, [], port: 9568)
  end
end
```

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

### child_spec

Source: https://hexdocs.pm/elixir_cache/Cache.html

Provides a child specification for starting the cache module under a supervisor.

```APIDOC
## child_spec

### Description
Returns a specification to start this module under a supervisor.

### Parameters
#### Path Parameters
- **init_arg** (any()) - Description not provided in source.

### Response
#### Success Response (200)
- **child_spec** (Supervisor.child_spec() | :supervisor.child_spec()) - Description not provided in source.
```

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

### Cache.Counter Adapter Usage

Source: https://hexdocs.pm/elixir_cache/Cache.html

Utilize the `Cache.Counter` adapter for atomic integer operations. This example defines a counter cache and demonstrates incrementing, decrementing, and retrieving counts.

```elixir
defmodule MyApp.CounterCache do
  use Cache,
    adapter: Cache.Counter,
    name: :my_app_counter_cache,
    opts: []
end

MyApp.CounterCache.increment(:page_views)
MysApp.CounterCache.decrement(:active_users)
{:ok, count} = MyApp.CounterCache.get(:page_views)
```

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

### Cache start_link function signature

Source: https://hexdocs.pm/elixir_cache/Cache.html

Defines the signature for the `start_link/1` function in the Cache behavior. It outlines the possible return values, including success, already started, or error states.

```elixir
@callback start_link(cache_opts :: Keyword.t()) ::
  {:ok, pid()}
  | {:error, {:already_started, pid()} | {:shutdown, term()} | term()}
  | :ignore
```

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

### Define CacheCase with explicit default caches

Source: https://hexdocs.pm/elixir_cache/Cache.CaseTemplate.html

Use this to define a `CacheCase` module that automatically starts a predefined list of cache modules for every test.

```elixir
defmodule MyApp.CacheCase do
  use Cache.CaseTemplate, default_caches: [MyApp.UserCache, MyApp.SessionCache]
end
```

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

### Cache Database Query Results

Source: https://hexdocs.pm/elixir_cache/advanced_techniques.html

Illustrates a common pattern for caching database query results to improve performance. The example caches featured posts for 15 minutes.

```elixir
defmodule MyApp.PostRepository do
  def get_featured_posts do
    cache_key = "featured_posts"
    
    case MyApp.Cache.get(cache_key) do
      {:ok, posts} when is_list(posts) ->
        {:ok, posts}
        
      _ ->
        # Query from database if not in cache
        with {:ok, posts} <- fetch_featured_posts_from_db() do
          # Cache for 15 minutes
          :ok = MyApp.Cache.put(cache_key, :timer.minutes(15), posts)
          {:ok, posts}
        end
    end
  end
  
  defp fetch_featured_posts_from_db do
    # Database query logic here
    # ...
  end
end
```

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

### Cache.HashRing Usage Example

Source: https://hexdocs.pm/elixir_cache/using_strategies.html

Define a distributed cache using Cache.HashRing with Cache.ETS as the underlying adapter. Ensure this module is included in your application's supervision tree.

```elixir
defmodule MyApp.DistributedCache do
  use Cache,
    adapter: {Cache.HashRing, Cache.ETS},
    name: :distributed_cache,
    opts: [read_concurrency: true]
end
```

```elixir
children = [MyApp.DistributedCache]
Supervisor.start_link(children, strategy: :one_for_one)
```

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

### Retrieve Values from Cache

Source: https://hexdocs.pm/elixir_cache/basic_operations.html

Use the `get` function to retrieve values. Handle the possible {:ok, value}, {:ok, nil}, or {:error, reason} return tuples.

```elixir
case MyApp.Cache.get("user:1") do
  {:ok, user} ->
    IO.puts("Found user: #{user.name}")
    
  {:ok, nil} ->
    IO.puts("User not found in cache")
    
  {:error, reason} ->
    IO.puts("Error retrieving from cache: #{reason}")
end
```

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

### init

Source: https://hexdocs.pm/elixir_cache/Cache.html

Callback implementation for Supervisor.init/1.

```APIDOC
## init(cache_children)

### Description
Callback implementation for `Supervisor.init/1`.

### Parameters
#### Path Parameters
- **cache_children** (any()) - The children to initialize.

### Response
#### Success Response (200)
- **result** (any()) - The result of the initialization.
```

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

### Get or Store with Local Locking

Source: https://hexdocs.pm/elixir_cache/Cache.ConCache.html

Implements a get_or_store mechanism that uses local process locking. Only one process will execute the `store_fun` at a time. Other processes will wait for the result and then read from the cache.

```elixir
get_or_store(cache_name, key, ttl, store_fun)
```

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

### Registering Caches with Sandbox Registry

Source: https://hexdocs.pm/elixir_cache/Cache.html

Register specific cache modules with the Cache.SandboxRegistry within a setup block in your tests. This ensures each test process gets a unique sandbox instance.

```elixir
Cache.SandboxRegistry.start([MyCache, CacheItem])
```

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

### Set Up Cache Sandbox Registry

Source: https://hexdocs.pm/elixir_cache/testing_with_cache.html

Add `Cache.SandboxRegistry.start_link()` to your `test/test_helper.exs` to initialize the sandbox registry for test isolation.

```elixir
# In test/test_helper.exs
Cache.SandboxRegistry.start_link()
ExUnit.start()
```

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

### Set Up ElixirCache Telemetry Handlers

Source: https://hexdocs.pm/elixir_cache/using_metrics.html

Attach handlers to ElixirCache telemetry events to capture metrics for cache operations. This includes handlers for GET, MISS, PUT, DELETE, and error events.

```elixir
defmodule MyApp.CacheMetrics do
  def setup do
    # Attach handlers for cache operations
    :telemetry.attach(
      "cache-get-handler",
      [:elixir_cache, :cache, :get],
      &handle_cache_get/4,
      nil
    )

    :telemetry.attach(
      "cache-miss-handler",
      [:elixir_cache, :cache, :get, :miss],
      &handle_cache_miss/4,
      nil
    )

    :telemetry.attach(
      "cache-put-handler",
      [:elixir_cache, :cache, :put],
      &handle_cache_put/4,
      nil
    )

    :telemetry.attach(
      "cache-delete-handler",
      [:elixir_cache, :cache, :delete],
      &handle_cache_delete/4,
      nil
    )

    # Attach handlers for error events
    :telemetry.attach(
      "cache-get-error-handler",
      [:elixir_cache, :cache, :get, :error],
      &handle_cache_error/4,
      nil
    )

    :telemetry.attach(
      "cache-put-error-handler",
      [:elixir_cache, :cache, :put, :error],
      &handle_cache_error/4,
      nil
    )

    :telemetry.attach(
      "cache-delete-error-handler",
      [:elixir_cache, :cache, :delete, :error],
      &handle_cache_error/4,
      nil
    )
  end

  def handle_cache_get(_event, _measurements, metadata, _config) do
    IO.puts("Cache GET operation for cache: #{metadata.cache_name}")
  end

  def handle_cache_miss(_event, measurements, metadata, _config) do
    IO.puts("Cache MISS for cache: #{metadata.cache_name}, count: #{measurements.count}")
  end

  def handle_cache_put(_event, _measurements, metadata, _config) do
    IO.puts("Cache PUT operation for cache: #{metadata.cache_name}")
  end

  def handle_cache_delete(_event, _measurements, metadata, _config) do
    IO.puts("Cache DELETE operation for cache: #{metadata.cache_name}")
  end

  def handle_cache_error(event, measurements, metadata, _config) do
    [_, _, operation, _] = event
    IO.puts("Cache #{operation} ERROR for cache: #{metadata.cache_name}: #{inspect(metadata.error)}")
  end
end
```

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

### Using Cache with Strategy Adapters

Source: https://hexdocs.pm/elixir_cache/Cache.Strategy.html

Demonstrates how to specify strategy adapters using the tuple format with `use Cache`. The first element is the strategy module, and the second is the underlying adapter or strategy-specific configuration.

```elixir
use Cache,
  adapter: {Cache.HashRing, Cache.ETS},
  name: :my_cache,
  opts: [read_concurrency: true]
```

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

### Dirty Get or Store

Source: https://hexdocs.pm/elixir_cache/Cache.ConCache.html

Provides a way to get a value from the cache or store it if it's not present, using dirty_put for efficiency. This method bypasses locking for puts, which is enabled by default.

```elixir
dirty_get_or_store(cache_name, key, store_fun)
```

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

### Basic Strategy Adapter Configuration

Source: https://hexdocs.pm/elixir_cache/using_strategies.html

Configure a cache adapter with a strategy module and an underlying adapter or configuration. The `opts` keyword list is shared between the strategy and the underlying adapter.

```elixir
use Cache,
  adapter: {StrategyModule, UnderlyingAdapterOrConfig},
  name: :my_cache,
  opts: [strategy_opt: value, underlying_adapter_opt: value]
```

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

### Redis Adapter - command/1

Source: https://hexdocs.pm/elixir_cache/api.html

Runs a raw Redis command.

```APIDOC
## command/1

### Description
Run a raw Redis command.

### Parameters
#### Path Parameters
- **command_args** (list) - Required - A list of arguments for the Redis command.

### Returns
The result of the Redis command.
```

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

### Configure Cache Fetching from Application Config (Tuple)

Source: https://hexdocs.pm/elixir_cache/Cache.html

Configures the cache adapter by fetching options from the application's environment using a tuple specifying the application name and a specific key. This assumes a configuration like `config :elixir_cache, :cache_opts, []`.

```elixir
defmodule Cache.Example do
  use Cache,
    adapter: Cache.Redis,
    name: :test_cache_redis,
    opts: {:elixir_cache, :cache_opts}
end
```

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

### Configure Cache Fetching from Application Config (Atom)

Source: https://hexdocs.pm/elixir_cache/Cache.html

Configures the cache adapter by fetching options directly from the application's environment using an atom as the key. This assumes a configuration like `config :elixir_cache, Cache.Example, []`.

```elixir
defmodule Cache.Example do
  use Cache,
    adapter: Cache.Redis,
    name: :test_cache_redis,
    opts: :elixir_cache
end
```

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

### command(cache_name, command, opts)

Source: https://hexdocs.pm/elixir_cache/Cache.Sandbox.html

Executes a command on the cache with options.

```APIDOC
## command(cache_name, command, opts)

### Description
Executes a generic command on the cache with specified options. This command may return a value or perform an action.

### Method
POST (assumed)

### Endpoint
/cache/{cache_name}/command

### Parameters
#### Path Parameters
- **cache_name** (string) - Required - The name of the cache.

#### Request Body
- **command** (string) - Required - The command to execute.
- **opts** (object) - Optional - Additional options for the command.
```

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

### json_get

Source: https://hexdocs.pm/elixir_cache/Cache.Redis.html

Gets a JSON value at path. See Cache.Redis.JSON.get/4 for more details.

```APIDOC
## json_get pool_name, key, path, opts \\ []

### Description
Gets a JSON value at path.

### See Also
`Cache.Redis.JSON.get/4`
```

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

### Cache Prefixing for Namespaces

Source: https://hexdocs.pm/elixir_cache/advanced_techniques.html

Demonstrates using prefixes to organize cache keys into namespaces, improving cache management. Includes methods for storing, retrieving, and invalidating user-specific data. Also shows bulk invalidation for ETS cache.

```elixir
defmodule MyApp.UserCache do
  @prefix "user:"
  
  def store_user(user_id, user_data) do
    MyApp.Cache.put("#{@prefix}#{user_id}", user_data)
  end
  
  def get_user(user_id) do
    MyApp.Cache.get("#{@prefix}#{user_id}")
  end
  
  def invalidate_user(user_id) do
    MyApp.Cache.delete("#{@prefix}#{user_id}")
  end
  
  # Bulk invalidation in ETS cache
  def invalidate_all_users() do
    if MyApp.Cache.cache_adapter() === Cache.ETS do
      MyApp.Cache.match_delete({:"#{@prefix}_", :_})
    else
      # Fallback for other adapters without pattern matching
      {:error, :not_supported}
    end
  end
end
```

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

### Configure Cache with RefreshAhead Strategy

Source: https://hexdocs.pm/elixir_cache/Cache.RefreshAhead.html

Use this configuration to set up a cache module with the RefreshAhead strategy, specifying the adapter, cache name, and refresh options like the refresh window duration.

```elixir
defmodule MyApp.Cache do
  use Cache,
    adapter: {Cache.RefreshAhead, Cache.Redis},
    name: :my_cache,
    opts: [
      uri: "redis://localhost:6379",
      refresh_before: :timer.seconds(30)
    ]

  def refresh(key) do
    {:ok, fetch_fresh_value(key)}
  end
end
```

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

### Redis Adapter - hash_get/2

Source: https://hexdocs.pm/elixir_cache/api.html

Gets a specific field from a hash in Redis.

```APIDOC
## hash_get/2

### Description
Get a hash field from Redis.

### Parameters
#### Path Parameters
- **key** (string) - Required - The key of the hash.
- **field** (string) - Required - The field to retrieve.

### Returns
The value of the hash field.
```

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

### take

Source: https://hexdocs.pm/elixir_cache/Cache.Sandbox.html

Retrieves a value from a cache by its key.

```APIDOC
## take(cache_name, key)

### Description
Retrieves the value associated with the specified key from the cache. This operation may also remove the key-value pair from the cache depending on the implementation.

### Parameters
- **cache_name** (string) - Required - The name of the cache.
- **key** (any) - Required - The key of the entry to retrieve.
```

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

### hash_values

Source: https://hexdocs.pm/elixir_cache/Cache.Redis.html

Gets all values from a hash stored at key. See Cache.Redis.Hash.hash_values/3 for more details.

```APIDOC
## hash_values pool_name, key, opts \\ []

### Description
Gets all values from a hash stored at key.

### See Also
`Cache.Redis.Hash.hash_values/3`
```

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

### hash_get

Source: https://hexdocs.pm/elixir_cache/Cache.Redis.html

Gets a field from a hash stored at key. See Cache.Redis.Hash.hash_get/4 for more details.

```APIDOC
## hash_get pool_name, key, field, opts \\ []

### Description
Gets a field from a hash stored at key.

### See Also
`Cache.Redis.Hash.hash_get/4`
```

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

### init_table(cache_name, init_fun)

Source: https://hexdocs.pm/elixir_cache/Cache.Sandbox.html

Initializes or re-initializes the cache table using a provided function.

```APIDOC
## init_table(cache_name, init_fun)

### Description
Initializes or re-initializes the cache table. The `init_fun` is used to populate the table with initial data or set up its structure.

### Method
POST (assumed)

### Endpoint
/cache/{cache_name}/init_table

### Parameters
#### Path Parameters
- **cache_name** (string) - Required - The name of the cache.

#### Request Body
- **init_fun** (function) - Required - The function to use for initializing the table.
```

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

### hash_get_many

Source: https://hexdocs.pm/elixir_cache/Cache.Redis.html

Gets multiple fields from a hash stored at key. See Cache.Redis.Hash.hash_get_many/3 for more details.

```APIDOC
## hash_get_many pool_name, key_fields, opts \\ []

### Description
Gets multiple fields from a hash stored at key.

### See Also
`Cache.Redis.Hash.hash_get_many/3`
```

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

### hash_get_all

Source: https://hexdocs.pm/elixir_cache/Cache.Redis.html

Gets all fields and values from a hash stored at key. See Cache.Redis.Hash.hash_get_all/3 for more details.

```APIDOC
## hash_get_all pool_name, key, opts \\ []

### Description
Gets all fields and values from a hash stored at key.

### See Also
`Cache.Redis.Hash.hash_get_all/3`
```

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

### Define a Cache Module

Source: https://hexdocs.pm/elixir_cache/basic_operations.html

Set up a cache module using the Cache.ETS adapter. Ensure the adapter and a unique name are specified.

```elixir
defmodule MyApp.Cache do
  use Cache,
    adapter: Cache.ETS,
    name: :my_app_cache
end
```

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

### Set Cache TTL (Time To Live)

Source: https://hexdocs.pm/elixir_cache/advanced_techniques.html

Demonstrates setting different Time To Live (TTL) values for cache entries, from seconds to indefinite.

```elixir
# Cache for 10 seconds
MyApp.Cache.put("short-lived-key", :timer.seconds(10), %{data: "expires quickly"})

# Cache for 1 hour
MyApp.Cache.put("hourly-key", :timer.hours(1), %{data: "expires in an hour"})

# Cache for 1 day
MyApp.Cache.put("daily-key", :timer.hours(24), %{data: "expires in a day"})

# Cache indefinitely (no TTL)
MyApp.Cache.put("permanent-key", %{data: "never expires"})
```

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

### Add elixir_cache to Dependencies

Source: https://hexdocs.pm/elixir_cache/Cache.html

Add `elixir_cache` to your project's dependencies in `mix.exs` to install the package.

```elixir
def deps do
  [
    {:elixir_cache, ">~> 0.1.0"}
  ]
end
```

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

### Hash Operations

Source: https://hexdocs.pm/elixir_cache/Cache.Redis.html

Perform operations on Redis hash data structures, including getting, setting, deleting, and scanning fields.

```APIDOC
## Hash Operations

`hash_delete(pool_name, key, field, opts \\ [])`
See `Cache.Redis.Hash.hash_delete/4`.

`hash_get(pool_name, key, field, opts \\ [])`
See `Cache.Redis.Hash.hash_get/4`.

`hash_get_all(pool_name, key, opts \\ [])`
See `Cache.Redis.Hash.hash_get_all/3`.

`hash_get_many(pool_name, key_fields, opts \\ [])`
See `Cache.Redis.Hash.hash_get_many/3`.

`hash_scan(pool_name, key, scan_opts, opts \\ [])`
See `Cache.Redis.Hash.hash_scan/4`.

`hash_set(pool_name, key, field, value, ttl, opts \\ [])`
See `Cache.Redis.Hash.hash_set/6`.

`hash_set_many(pool_name, keys_fields_values, ttl, opts \\ [])`
See `Cache.Redis.Hash.hash_set_many/4`.

`hash_values(pool_name, key, opts \\ [])`
See `Cache.Redis.Hash.hash_values/3`.
```

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

### Redis Adapter - pipeline/1

Source: https://hexdocs.pm/elixir_cache/api.html

Runs multiple Redis commands in a pipeline.

```APIDOC
## pipeline/1

### Description
Run commands in a pipeline in Redis.

### Parameters
#### Path Parameters
- **commands** (list) - Required - A list of commands to execute in the pipeline.

### Returns
A list of results from the pipeline commands.
```

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

### open_file_with_args

Source: https://hexdocs.pm/elixir_cache/Cache.Sandbox.html

Opens a file with specified arguments for cache operations.

```APIDOC
## open_file(name, args)

### Description
Opens a file identified by its name, with additional arguments provided to configure the file opening process for cache operations.

### Parameters
#### Path Parameters
- **name** (string) - Required - The name of the file to open.
- **args** (map) - Required - A map of arguments to configure the file opening.
```

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

### Get Counter Value

Source: https://hexdocs.pm/elixir_cache/Cache.Counter.html

Retrieve the current integer value of a counter slot. Returns 0 if the slot has never been incremented.

```elixir
{:ok, count} = MyApp.Cache.get(:page_views)
```

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

### Redis Hash Operations

Source: https://hexdocs.pm/elixir_cache/redis_setup.html

Perform hash-specific operations on Redis, such as setting and getting fields, retrieving all fields, and deleting fields from a hash.

```elixir
# Set hash field
MyApp.RedisCache.hash_set("user:1", "name", "John")
MyApp.RedisCache.hash_set("user:1", "email", "john@example.com")

# Get hash field
{:ok, name} = MyApp.RedisCache.hash_get("user:1", "name")

# Get all hash fields
{:ok, user_data} = MyApp.RedisCache.hash_get_all("user:1")

# Delete hash field
MyApp.RedisCache.hash_delete("user:1", "email")
```

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

### pipeline!(cache_name, commands, opts)

Source: https://hexdocs.pm/elixir_cache/Cache.Sandbox.html

Executes a series of commands on the cache as a pipeline, raising an error on failure.

```APIDOC
## pipeline!(cache_name, commands, opts)

### Description
Executes a list of `commands` on the specified cache as a pipeline. This version will raise an error if any command in the pipeline fails. Options can be provided.

### Method
POST (assumed)

### Endpoint
/cache/{cache_name}/pipeline!

### Parameters
#### Path Parameters
- **cache_name** (string) - Required - The name of the cache.

#### Request Body
- **commands** (list) - Required - A list of commands to execute in the pipeline.
- **opts** (object) - Optional - Additional options for the pipeline.
```

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

### setopts

Source: https://hexdocs.pm/elixir_cache/Cache.Sandbox.html

Sets options for a cache.

```APIDOC
## setopts(cache_name, opts)

### Description
Sets configuration options for the specified cache.

### Parameters
- **cache_name** (string) - Required - The name of the cache to configure.
- **opts** (list) - Required - A list of options to set for the cache.
```

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

### Get Supervisor Child Specification

Source: https://hexdocs.pm/elixir_cache/Cache.PersistentTerm.html

This function returns a supervisor child specification for the Cache.PersistentTerm module. The `arg` parameter is passed to `Task.start_link/1`.

```elixir
child_spec(arg)
```

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

### command

Source: https://hexdocs.pm/elixir_cache/Cache.Redis.html

Executes a raw Redis command. See Cache.Redis.Global.command/3 for more details.

```APIDOC
## command pool_name, command, opts \\ []

### Description
Executes a raw Redis command.

### See Also
`Cache.Redis.Global.command/3`
```

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

### Configure MultiLayer Cache with Fetch Callback

Source: https://hexdocs.pm/elixir_cache/Cache.MultiLayer.html

Define an optional fetch callback using `on_fetch` to supply a value when all cache layers miss. The fetched value is then backfilled into all layers.

```elixir
defmodule MyApp.LayeredCache do
  use Cache,
    adapter: {Cache.MultiLayer, [Cache.ETS, MyApp.RedisCache]},
    name: :layered_cache,
    opts: [on_fetch: &__MODULE__.fetch/1]

def fetch(key) do
  {:ok, "value_for_#{key}"}
end
end
```

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

### open_file(filename, args)

Source: https://hexdocs.pm/elixir_cache/Cache.Sandbox.html

Opens a file for cache operations, potentially with arguments.

```APIDOC
## open_file(filename, args)

### Description
Opens a file, preparing it for cache operations. The `args` parameter can specify options for opening the file.

### Method
POST (assumed)

### Endpoint
/cache/open_file

### Parameters
#### Request Body
- **filename** (string) - Required - The name or path of the file to open.
- **args** (object) - Optional - Arguments or options for opening the file.
```

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

### MultiLayer Cache with Fetch Callback

Source: https://hexdocs.pm/elixir_cache/using_strategies.html

Implement an `on_fetch` callback to provide a value on total cache miss, which then backfills all cache layers.

```elixir
defmodule MyApp.LayeredCache do
  use Cache,
    adapter: {Cache.MultiLayer, [MyApp.LocalCache, MyApp.RedisCache]},
    name: :layered_cache,
    opts: [on_fetch: &__MODULE__.fetch/1]

  def fetch(key) do
    {:ok, MyApp.Repo.get_value(key)}
  end
end
```

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

### child_spec/1

Source: https://hexdocs.pm/elixir_cache/Cache.Agent.html

Returns a supervisor child specification for starting the Cache.Agent module. This is useful for integrating the cache agent into an Elixir application's supervision tree.

```APIDOC
## child_spec/1

### Description
Returns a specification to start this module under a supervisor. See `Supervisor`.

### Function Signature
child_spec(arg)

### Parameters
#### Path Parameters
- **arg** (any) - Required - The argument for the child specification.

### Response
#### Success Response
- **child_spec** (Supervisor.Spec.t()) - A supervisor child specification.
```

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

### JSON Operations

Source: https://hexdocs.pm/elixir_cache/Cache.Redis.html

Manipulate JSON data stored in Redis, including appending to arrays, clearing paths, getting, incrementing, and setting JSON values.

```APIDOC
## JSON Operations

`json_array_append(pool_name, key, path, value_or_values, opts \\ [])`
See `Cache.Redis.JSON.array_append/5`.

`json_clear(pool_name, key, path, opts \\ [])`
See `Cache.Redis.JSON.clear/4`.

`json_delete(pool_name, key, path, opts \\ [])`
See `Cache.Redis.JSON.delete/4`.

`json_get(pool_name, key, path, opts \\ [])`
See `Cache.Redis.JSON.get/4`.

`json_incr(pool_name, key, path, value \\ 1, opts \\ [])`
See `Cache.Redis.JSON.incr/5`.

`json_set(pool_name, key, path, value, opts \\ [])`
See `Cache.Redis.JSON.set/5`.
```

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

### pipeline(cache_name, commands, opts)

Source: https://hexdocs.pm/elixir_cache/Cache.Sandbox.html

Executes a series of commands on the cache as a pipeline.

```APIDOC
## pipeline(cache_name, commands, opts)

### Description
Executes a list of `commands` on the specified cache as a pipeline, returning the results. Options can be provided.

### Method
POST (assumed)

### Endpoint
/cache/{cache_name}/pipeline

### Parameters
#### Path Parameters
- **cache_name** (string) - Required - The name of the cache.

#### Request Body
- **commands** (list) - Required - A list of commands to execute in the pipeline.
- **opts** (object) - Optional - Additional options for the pipeline.
```

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

### Configure Cache.Sandbox Adapter for Testing

Source: https://hexdocs.pm/elixir_cache/choosing_adapter.html

Use Cache.Sandbox for testing environments to create isolated caches that do not interfere with each other during tests.

```elixir
defmodule MyApp.TestCache do
  use Cache,
    adapter: Cache.ETS,
    name: :my_app_test_cache,
    sandbox?: true
end
```

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

### Dynamically Select Cache Adapter

Source: https://hexdocs.pm/elixir_cache/choosing_adapter.html

Configure your cache module to use different adapters (e.g., ETS for test, Redis for production) based on the current environment. Ensure the chosen adapter and its options are correctly defined.

```elixir
defmodule MyApp.Cache do
  use Cache,
    adapter: get_adapter(),
    name: :my_app_cache,
    opts: get_opts()

  if Mix.env() === :test do
    defp get_adapter, do: Cache.ETS
    defp get_opts, do: []
  else
    defp get_adapter, do: Cache.Redis
    defp get_opts, do: [uri: "redis://localhost:6379", size: 10]
  end
end
```

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

### command!(cache_name, command, opts)

Source: https://hexdocs.pm/elixir_cache/Cache.Sandbox.html

Executes a command on the cache, raising an error on failure.

```APIDOC
## command!(cache_name, command, opts)

### Description
Executes a generic command on the cache with specified options. This command will raise an error if the command execution fails.

### Method
POST (assumed)

### Endpoint
/cache/{cache_name}/command!

### Parameters
#### Path Parameters
- **cache_name** (string) - Required - The name of the cache.

#### Request Body
- **command** (string) - Required - The command to execute.
- **opts** (object) - Optional - Additional options for the command.
```

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

### Implement Function Memoization with ElixirCache

Source: https://hexdocs.pm/elixir_cache/advanced_techniques.html

Shows how to implement function memoization using ElixirCache to store and retrieve computed results, reducing redundant calculations. Cache entries are set to expire after 1 hour.

```elixir
defmodule MyApp.MemoizedCalculator do
  def factorial(n, cache \ MyApp.Cache) do
    cache_key = "factorial:#{n}"
    
    case cache.get(cache_key) do
      {:ok, result} when not is_nil(result) ->
        result
        
      _ ->
        # Calculate the result if not in cache
        result = calculate_factorial(n)
        
        # Store in cache for future use (cache for 1 hour)
        cache.put(cache_key, 3600, result)
        
        result
    end
  end
  
  defp calculate_factorial(0), do: 1
  defp calculate_factorial(1), do: 1
  defp calculate_factorial(n) when n > 1, do: n * factorial(n - 1)
end
```

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

### command!

Source: https://hexdocs.pm/elixir_cache/Cache.Redis.html

Executes a raw Redis command and raises an error on failure. See Cache.Redis.Global.command!/3 for more details.

```APIDOC
## command! pool_name, command, opts \\ []

### Description
Executes a raw Redis command and raises an error on failure.

### See Also
`Cache.Redis.Global.command!/3`
```

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

### pipeline!

Source: https://hexdocs.pm/elixir_cache/Cache.Sandbox.html

Executes a series of commands as a pipeline on the specified cache, with potential side effects or different error handling.

```APIDOC
## pipeline!(cache_name, commands, opts)

### Description
Executes a list of commands atomically as a pipeline against the specified cache. The '!' suffix may indicate a variant with different behavior, such as stricter error handling or immediate execution.

### Parameters
#### Path Parameters
- **cache_name** (string) - Required - The name of the cache to operate on.
- **commands** (list) - Required - A list of commands to execute in the pipeline.
- **opts** (map) - Optional - Additional options to control the pipeline execution.
```

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

### Cache Behaviour Callbacks

Source: https://hexdocs.pm/elixir_cache/Cache.html

Defines the callbacks required for implementing a custom cache adapter. These functions handle cache operations like putting, getting, and deleting data.

```elixir
put(cache_name, key, ttl, value, opts \ [])
get(cache_name, key, opts \ [])
delete(cache_name, key, opts \ [])
opts_definition() # NimbleOptions definition map
child_spec({cache_name, cache_opts})
```

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

### Implement Telemetry for Cache Monitoring

Source: https://hexdocs.pm/elixir_cache/advanced_techniques.html

Shows how to set up telemetry handlers to monitor cache performance, specifically tracking cache hit rates and misses. The hit rate is reported every 100 requests.

```elixir
defmodule MyApp.CacheMonitor do
  def setup do
    :telemetry.attach(
      "cache-hit-rate-tracker",
      [:elixir_cache, :cache, :get],
      &handle_get_event/4,
      %{hits: 0, total: 0}
    )
    
    :telemetry.attach(
      "cache-miss-tracker",
      [:elixir_cache, :cache, :get, :miss],
      &handle_miss_event/4,
      %{misses: 0}
    )
  end
  
  def handle_get_event(_event, _measurements, _metadata, state) do
    total = state.total + 1
    
    if rem(total, 100) == 0 do
      hit_rate = state.hits / total
      IO.puts("Cache hit rate: #{hit_rate * 100}%")
    end
    
    %{state | total: total}
  end
  
  def handle_miss_event(_event, _measurements, _metadata, state) do
    misses = state.misses + 1
    %{state | misses: misses}
  end
end
```

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

### all()

Source: https://hexdocs.pm/elixir_cache/Cache.Sandbox.html

Retrieves all entries from the cache.

```APIDOC
## all()

### Description
Retrieves all entries from the cache.

### Method
GET (assumed)

### Endpoint
/cache/all

### Response
#### Success Response (200)
- **entries** (list) - A list of all key-value pairs in the cache.
```

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

### Define ElixirCache Metrics

Source: https://hexdocs.pm/elixir_cache/using_metrics.html

Define various counter and distribution metrics for ElixirCache operations using Telemetry.Metrics. This includes metrics for cache gets, puts, deletes, misses, errors, and durations.

```elixir
defmodule MyApp.Metrics do
  import Telemetry.Metrics

  def metrics do
    [
      # Counter metrics
      counter("elixir_cache.cache.get.count", tags: [:cache_name]),
      counter("elixir_cache.cache.get.miss.count", tags: [:cache_name]),
      counter("elixir_cache.cache.put.count", tags: [:cache_name]),
      counter("elixir_cache.cache.delete.count", tags: [:cache_name]),
      
      # Error metrics
      counter("elixir_cache.cache.get.error.count", tags: [:cache_name, :error]),
      counter("elixir_cache.cache.put.error.count", tags: [:cache_name, :error]),
      counter("elixir_cache.cache.delete.error.count", tags: [:cache_name, :error]),
      
      # Duration metrics (for span events)
      distribution("elixir_cache.cache.get.duration", unit: {:native, :millisecond}, tags: [:cache_name]),
      distribution("elixir_cache.cache.put.duration", unit: {:native, :millisecond}, tags: [:cache_name]),
      distribution("elixir_cache.cache.delete.duration", unit: {:native, :millisecond}, tags: [:cache_name])
    ]
  end
end
```

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

### Configure Cache with Module Function

Source: https://hexdocs.pm/elixir_cache/Cache.html

Configures the cache adapter using a module function that returns a keyword list of options. Ensure the module and function are correctly specified.

```elixir
defmodule Cache.Example do
  use Cache,
    adapter: Cache.Redis,
    name: :test_cache_redis,
    opts: {Cache.Example, :opts, []}

  def opts, do: [host: "localhost", port: 6379]
end
```

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

### Configure Cache with Callback Function

Source: https://hexdocs.pm/elixir_cache/Cache.html

Configures the cache adapter by referencing a zero-arity callback function within the module. This function should return the desired configuration options.

```elixir
defmodule Cache.Example do
  use Cache,
    adapter: Cache.Redis,
    name: :test_cache_redis,
    opts: &Cache.Example.opts/0

  def opts, do: [host: "localhost", port: 6379]
end
```

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

### Use CacheCase in Test Files

Source: https://hexdocs.pm/elixir_cache/testing_with_cache.html

In your test files, use the custom `CacheCase` module (e.g., `use MyApp.CacheCase`). This automatically handles the setup of default caches, ensuring isolation per test.

```elixir
defmodule MyApp.UserTest do
  use ExUnit.Case, async: true
  use MyApp.CacheCase

  test "caches are isolated per test" do
    assert {:ok, nil} = MyApp.UserCache.get("key")
    assert :ok = MyApp.UserCache.put("key", "value")
    assert {:ok, "value"} = MyApp.UserCache.get("key")
  end
end
```

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

### select

Source: https://hexdocs.pm/elixir_cache/Cache.Sandbox.html

Selects entries from the cache based on a match specification.

```APIDOC
## select(cache_name, match_spec)

### Description
Selects entries from the specified cache that match the provided match specification. This allows for complex querying of cache data.

### Parameters
#### Path Parameters
- **cache_name** (string) - Required - The name of the cache to query.
- **match_spec** (any) - Required - The match specification used to filter entries.
```

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

### Use CacheCase in a test file

Source: https://hexdocs.pm/elixir_cache/Cache.CaseTemplate.html

Include this in your test files to leverage the `CacheCase` for setting up caches. Additional caches can be specified for the file.

```elixir
defmodule MyApp.SomeTest do
  use ExUnit.Case, async: true
  use MyApp.CacheCase

  # or with additional caches just for this file:
  use MyApp.CacheCase, caches: [MyApp.ExtraCache]
end
```
Tokens:
Raw