Honeydew

https://hexdocs.pm/honeydew
Admin
Honeydew is a pluggable job queue and worker pool for Elixir focused on at-least-once execution with...
Tokens:29,858
Snippets:354
Trust Score:9
Update:5 months ago
Show doc for...
Tokens:
Raw
### Start a basic Honeydew queue

Source: https://hexdocs.pm/honeydew/Honeydew-function-start_queue.html

Use this to start a queue with default settings. The queue will use `Honeydew.Queue.Mnesia` as its backend.

```elixir
Honeydew.start_queue("my_awesome_queue")
```

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

### start_queue/2

Source: https://hexdocs.pm/honeydew/Honeydew.html

Starts a queue under Honeydew's supervision tree.

```APIDOC
## start_queue/2

### Description
Starts a queue under Honeydew's supervision tree.

### Function Signature
`start_queue(name, opts \\ [])`

### Parameters
- `name`: The name of the queue to start.
- `opts`: Optional configuration for the queue.
```

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

### start_link/1 (Function)

Source: https://hexdocs.pm/honeydew/Honeydew.Queue.html

Starts the queue process with the given options.

```APIDOC
## start_link(opts)

### Description
Starts the queue process with the given options.

### Function Signature
```elixir
start_link(opts :: list()) :: {:ok, pid()} | {:error, any()}
```
```

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

### Start EctoPollQueue with Required Arguments

Source: https://hexdocs.pm/honeydew/Honeydew.EctoPollQueue.html

Use this to start the EctoPollQueue, providing the Ecto repository and schema modules.

```elixir
Honeydew.start_queue(:classify_photos, {
  Honeydew.EctoPollQueue,
  repo: MyApp.Repo,
  schema: MyApp.Photo
})
```

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

### start_link/1

Source: https://hexdocs.pm/honeydew/Honeydew.Queue-function-start_link.html

Starts a new Honeydew queue process with the given options.

```APIDOC
## start_link/1

### Description
Starts a new Honeydew queue process.

### Function Signature
`start_link(opts)`

### Parameters
#### Path Parameters
- **opts** (list) - Required - Options to configure the queue.
```

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

### Start Basic Workers with Honeydew

Source: https://hexdocs.pm/honeydew/Honeydew-function-start_workers.html

Initiates workers for a queue using a specified job module. This is the simplest way to start workers.

```elixir
Honeydew.start_workers("my_awesome_queue", MyJobModule)
```

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

### Start a Honeydew Queue

Source: https://hexdocs.pm/honeydew/Honeydew.html

Starts a new queue under Honeydew's supervision tree. You can configure the queue module, dispatcher, failure mode, and success mode. The queue will start in a suspended state if the `suspended` option is set to true.

```elixir
start_queue(queue_name(), [queue_spec_opt()]) :: :ok | {:error, term()}
```

```elixir
Honeydew.start_queue("my_awesome_queue")
```

```elixir
Honeydew.start_queue("my_awesome_queue", queue: {MyQueueModule, [ip: "localhost"]}, dispatcher: {Honeydew.Dispatcher.MRU, []})
```

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

### Start Honeydew Queue and Workers

Source: https://hexdocs.pm/honeydew/index.html

This snippet demonstrates how to start a Honeydew queue and associate workers with it. Ensure the worker module defines the required functions.

```elixir
defmodule MyWorker do
  def do_a_thing do
    IO.puts "doing a thing!"
  end
end

:ok = Honeydew.start_queue(:my_queue)
:ok = Honeydew.start_workers(:my_queue, MyWorker)

:do_a_thing |> Honeydew.async(:my_queue)

# => "doing a thing!"
```

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

### start_workers/3

Source: https://hexdocs.pm/honeydew/Honeydew.html

Starts workers under Honeydew's supervision tree.

```APIDOC
## start_workers/3

### Description
Starts workers under Honeydew's supervision tree.

### Function Signature
`start_workers(name, module_and_args, opts \\ [])`

### Parameters
- `name`: The name of the queue the workers are associated with.
- `module_and_args`: The module and arguments for the workers.
- `opts`: Optional configuration for the workers.
```

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

### init/1

Source: https://hexdocs.pm/honeydew/Honeydew.Worker.html

Invoked when the worker starts up for the first time. It should return {:ok, state} to indicate successful initialization.

```APIDOC
## init/1

### Description
Invoked when the worker starts up for the first time.

### Specs
```elixir
init(args :: term()) :: {:ok, state :: private()}
```

### Parameters
* **args** (term()) - The arguments passed to the worker upon initialization.

### Response
#### Success Response
* **{:ok, state}** - Returns a tuple containing :ok and the initial state of the worker.
```

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

### Start Honeydew Workers

Source: https://hexdocs.pm/honeydew/Honeydew.html

Starts workers for a given queue. Specify the module and optional arguments for the workers. Defaults to 10 workers.

```elixir
Honeydew.start_workers("my_awesome_queue", MyJobModule)

```

```elixir
Honeydew.start_workers("my_awesome_queue", {MyJobModule, [key: "secret key"]}, num: 3)

```

```elixir
Honeydew.start_workers({:global, "my_awesome_queue"}, MyJobModule, nodes: [:clientfacing@dax, :queue@dax])

```

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

### start_queue/2

Source: https://hexdocs.pm/honeydew/Honeydew.html

Starts a new queue under Honeydew's supervision tree, allowing it to process jobs. Various options can be configured for queue behavior.

```APIDOC
## start_queue/2

### Description
Starts a queue under Honeydew's supervision tree. `name` is how you'll refer to the queue to add a task.

### Method
`start_queue(name, opts \\ [])`

### Parameters
#### Path Parameters
- **name** (queue_name()) - Required - The name for the queue.
- **opts** (list()) - Optional - Configuration options for the queue.
  * `queue`: The module for the queue implementation (defaults to `Honeydew.Queue.Mnesia`). Can be `{module, args}`.
  * `dispatcher`: The job dispatching strategy, `{module, init_args}`.
  * `failure_mode`: The failure handling strategy, must implement `Honeydew.FailureMode` behavior. Can be a module or `{module, args}`. Defaults to `{Honeydew.FailureMode.Abandon, []}`.
  * `success_mode`: A callback for successful job completion, must implement `Honeydew.SuccessMode` behavior. Can be a module or `{module, args}`. Defaults to `nil`.
  * `suspended`: Start the queue in a suspended state (defaults to `false`).

### Return Value
- `:ok` - The queue was started successfully.
- `{:error, term()}` - An error occurred during queue startup.
```

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

### init(args)

Source: https://hexdocs.pm/honeydew/Honeydew.Worker-callback-init.html

The init callback is invoked when the worker starts up for the first time. It accepts a single argument 'args' and returns {:ok, state :: private()}.

```APIDOC
## init(args)

### Description
Invoked when the worker starts up for the first time.

### Function Signature
`init(args :: term()) :: {:ok, state :: private()}`

### Parameters
#### Arguments
- **args** (term()) - The arguments passed to the init function.

### Returns
- **{:ok, state :: private()}** - Returns an ok tuple with the private state of the worker.
```

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

### Start a Honeydew queue with custom options

Source: https://hexdocs.pm/honeydew/Honeydew-function-start_queue.html

Configure a queue with a custom queue module, arguments, and a specific dispatcher. This allows for more advanced queue management.

```elixir
Honeydew.start_queue("my_awesome_queue", queue: {MyQueueModule, [ip: "localhost"]}, dispatcher: {Honeydew.Dispatcher.MRU, []})
```

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

### Start Workers with Custom Arguments and Count

Source: https://hexdocs.pm/honeydew/Honeydew-function-start_workers.html

Starts workers for a queue, passing custom arguments to the job module and specifying the number of workers. Useful for stateful workers or when specific configurations are needed.

```elixir
Honeydew.start_workers("my_awesome_queue", {MyJobModule, [key: "secret key"]}, num: 3)
```

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

### Worker Initialization Callback

Source: https://hexdocs.pm/honeydew/Honeydew.Worker.html

Callback invoked when the worker starts for the first time. It should return `{:ok, state}` on success.

```elixir
init(args :: term()) :: {:ok, state :: private()}
```

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

### Start Queue with Log Success Mode

Source: https://hexdocs.pm/honeydew/Honeydew.SuccessMode.Log.html

Use this to configure Honeydew to log job successes. This mode can be verbose and is mainly for demonstration.

```elixir
Honeydew.start_queue(:my_queue, success_mode: Honeydew.SuccessMode.Log)
```

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

### start_queue/2

Source: https://hexdocs.pm/honeydew/Honeydew-function-start_queue.html

Starts a queue under Honeydew's supervision tree. The `name` parameter is used to refer to the queue for adding tasks. Various options can be provided to customize queue behavior, dispatcher, and failure/success modes.

```APIDOC
## start_queue/2

### Description
Starts a queue under Honeydew's supervision tree.

### Function Signature
```elixir
start_queue(name, opts \\ []) :: :ok | {:error, term()}
```

### Parameters
#### Path Parameters
- **name** (string) - The name of the queue, used to refer to it when adding tasks.
- **opts** (list) - A list of options to configure the queue. Supported options include:
  * `queue`: The module the queue will use. Defaults to `Honeydew.Queue.Mnesia`. Can also be `{module, args}` to provide arguments to `Honeydew.Queue.init/2`.
  * `dispatcher`: The job dispatching strategy, specified as `{module, init_args}`.
  * `failure_mode`: How failed jobs are handled. Can be a module or `{module, args}`. The module must implement `Honeydew.FailureMode`. Defaults to `{Honeydew.FailureMode.Abandon, []}`.
  * `success_mode`: A callback that runs on job completion. Can be a module or `{module, args}`. The module must implement `Honeydew.SuccessMode`. Defaults to `nil`.
  * `suspended`: A boolean indicating whether to start the queue in a suspended state. Defaults to `false`.

### Examples
```elixir
# Start a basic queue
Honeydew.start_queue("my_awesome_queue")

# Start a queue with custom queue module and dispatcher
Honeydew.start_queue("my_awesome_queue", queue: {MyQueueModule, [ip: "localhost"]}, dispatcher: {Honeydew.Dispatcher.MRU, []})
```

### Notes
The `failure_mode` or `success_mode` handler runs in the job's dedicated monitor process, allowing for concurrent handling but also the possibility of process crashes.
```

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

### child_spec(init_arg)

Source: https://hexdocs.pm/honeydew/Honeydew.Queue-function-child_spec.html

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

```elixir
child_spec(init_arg)
```

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

### Get List of Queues

Source: https://hexdocs.pm/honeydew/Honeydew-function-queues.html

Returns a list of all queue names currently running on the node. No setup or imports are required to use this function.

```elixir
queues() :: [queue_name()]
```

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

### child_spec/1

Source: https://hexdocs.pm/honeydew/Honeydew.Queue-function-child_spec.html

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

```APIDOC
## child_spec(init_arg)

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

### Parameters
#### Path Parameters
- **init_arg** (any()) - Description not available in source
```

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

### Start Queue with Exponential Retry

Source: https://hexdocs.pm/honeydew/Honeydew.FailureMode.ExponentialRetry.html

Use this to configure a queue to retry jobs exponentially with a base delay of 2. This is useful for transient failures where you want to give the system time to recover.

```elixir
Honeydew.start_queue(:my_queue, failure_mode: {Honeydew.FailureMode.ExponentialRetry,
                                               times: 3,
                                               base: 2})
```

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

### child_spec(name, args)

Source: https://hexdocs.pm/honeydew/Honeydew.Queue-function-child_spec.html

Returns a specification to start this module under a supervisor with a given name and arguments.

```elixir
child_spec(name, args)
```

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

### async/3

Source: https://hexdocs.pm/honeydew/Honeydew.html

Runs a task asynchronously. You can provide options like `reply` to get the result or `delay_secs` to schedule execution.

```APIDOC
## async/3

### Description
Runs a task asynchronously.

### Function Signature
`async(task(), queue_name(), [async_opt()]) :: Honeydew.Job.t() | no_return()`

### Parameters
- `task`: The task to run, typically a tuple like `{:module, [args]}`.
- `queue`: The name of the queue to send the task to.
- `opts`: A list of options, such as `{:reply, true}` or `{:delay_secs, pos_integer()}`.

### Returns
- `Honeydew.Job.t()`: The job identifier if successful.
- `no_return()`: If an error occurs.

### Examples
```elixir
# Run a task asynchronously
Honeydew.async({:ping, ["127.0.0.1"]}, :my_queue)

# Run a task and wait for the result
job = Honeydew.async({:ping, ["127.0.0.1"]}, :my_queue, reply: true)
Honeydew.yield(job)

# Run a task an hour later
Honeydew.async({:ping, ["127.0.0.1"]}, :my_queue, delay_secs: 60*60)
```
```

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

### start_workers

Source: https://hexdocs.pm/honeydew/Honeydew-function-start_workers.html

Starts workers under Honeydew's supervision tree. This function allows you to configure the number of workers, retry mechanisms for stateful workers, and shutdown behavior.

```APIDOC
## start_workers(name, module_and_args, opts \\ [])

### Description
Starts workers under Honeydew's supervision tree.

`name` is the name of the queue that the workers pull jobs from.
`module` is the module that the workers in your queue will use. You may also provide `Honeydew.Worker.init/1` args with `{module, args}`.

You can provide any of the following `opts`:
  * `num`: the number of workers to start. Defaults to `10`.
  * `init_retry_secs`: the amount of time, in seconds, a stateful worker waits before trying to re-initialize after its `Honeydew.Worker.init/1` function fails. You can also override this behavior by implementing the `Honeydew.Worker.init_failed/0` callback, see `README/workers.md`.
  * `shutdown`: if a worker is in the middle of a job, the amount of time, in milliseconds, to wait before brutally killing it. Defaults to `10_000`.
  * `nodes`: for :global queues, you can provide a list of nodes to stay connected to (your queue node and enqueuing nodes). Defaults to `[]`.

### Parameters
#### Path Parameters
- **name** (string | tuple) - Required - The name of the queue or a tuple for global queues like `{:global, queue_name}`.
- **module_and_args** (module | tuple) - Required - The module for workers or a tuple `{module, args}`.
- **opts** (keyword) - Optional - Options to configure worker behavior.
  * **num** (integer) - Optional - The number of workers to start. Defaults to `10`.
  * **init_retry_secs** (integer) - Optional - Time in seconds for stateful workers to retry initialization.
  * **shutdown** (integer) - Optional - Time in milliseconds to wait before brutally killing a worker during shutdown. Defaults to `10_000`.
  * **nodes** (list) - Optional - List of nodes to stay connected to for global queues. Defaults to `[]`.

### Examples

* `Honeydew.start_workers("my_awesome_queue", MyJobModule)`
* `Honeydew.start_workers("my_awesome_queue", {MyJobModule, [key: "secret key"]}, num: 3)`
* `Honeydew.start_workers({:global, "my_awesome_queue"}, MyJobModule, nodes: [:clientfacing@dax, :queue@dax])`
```

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

### Honeydew.yield Example with Different Timeouts

Source: https://hexdocs.pm/honeydew/Honeydew-function-yield.html

Demonstrates calling `yield/2` with varying timeout values. Use `nil` for timeouts less than or equal to the message arrival time, and the result when the timeout is sufficient.

```elixir
iex> job = Honeydew.async({:ping, ["127.0.0.1"]}, :my_queue, reply: true)
iex> Honeydew.yield(job, 500) # Wait half a second
nil
# Result comes in at 1 second
iex> Honeydew.yield(job, 1000) # Wait up to a second
{:ok, :pong}
iex> Honeydew.yield(job, 0)
nil # <- because the message has already arrived and been handled
```

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

### status/2 (Function)

Source: https://hexdocs.pm/honeydew/Honeydew.Queue.html

Gets the status of the queue.

```APIDOC
## status(queue_process, opts)

### Description
Gets the status of the queue.

### Function Signature
```elixir
status(queue_process :: any(), opts :: list()) :: any()
```
```

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

### Honeydew Queue Child Specification

Source: https://hexdocs.pm/honeydew/Honeydew.Queue.html

Provides a specification to start the Honeydew.Queue module under a supervisor. This is useful for integrating the queue into an existing supervision tree.

```elixir
child_spec(init_arg) :: Supervisor.child_spec()
```

```elixir
child_spec(name(), [any()]) :: Supervisor.child_spec()
```

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

### Get Job Configuration

Source: https://hexdocs.pm/honeydew_ecto_notify_queue/HoneydewEctoNotifyQueue.Config.html

Fetches a single job configuration record by its key from the database.

```Elixir
get_config(Ecto.Repo.t(), String.t()) ::
  {:ok, HoneydewEctoNotifyQueue.JobConfig.t()} | {:error, :not_found}
```

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

### status/2 (Callback)

Source: https://hexdocs.pm/honeydew/Honeydew.Queue.html

Callback function to get the status of the queue.

```APIDOC
## status(private)

### Description
Callback function to get the status of the queue.

### Callback Signature
```elixir
status(private :: Honeydew.private()) :: any()
```
```

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

### Start Queue with Abandon Failure Mode

Source: https://hexdocs.pm/honeydew/Honeydew.FailureMode.Abandon.html

Use this to configure a new queue to abandon jobs upon failure. This prevents Honeydew from retrying failed jobs.

```elixir
Honeydew.start_queue(:my_queue, failure_mode: Honeydew.FailureMode.Abandon)
```

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

### Start Queue with Exponential Retry and Move

Source: https://hexdocs.pm/honeydew/Honeydew.FailureMode.ExponentialRetry.html

Configure a queue to retry jobs exponentially and then move them to a 'dead_letters' queue upon final failure. This is useful for isolating problematic jobs after exhausting retry attempts.

```elixir
Honeydew.start_queue(:my_queue,
                     failure_mode: {Honeydew.FailureMode.ExponentialRetry,
                                    times: 3,
                                    base: 2,
                                    finally: {Honeydew.FailureMode.Move,
                                              queue: :dead_letters}})
```

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

### Start EctoPollQueue with Failure Mode

Source: https://hexdocs.pm/honeydew/Honeydew.EctoPollQueue.html

Configure the EctoPollQueue with a failure mode, such as retrying jobs a specified number of times.

```elixir
Honeydew.start_queue(:classify_photos, {
  Honeydew.EctoPollQueue,
  repo: MyApp.Repo,
  schema: MyApp.Photo
},
failure_mode: {Honeydew.Retry, times: 3})
```

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

### Configure Move Failure Mode

Source: https://hexdocs.pm/honeydew/Honeydew.FailureMode.Move.html

Use this configuration when starting a queue to automatically move failed jobs to the `:failed` queue. Ensure the queue name is correctly specified.

```elixir
Honeydew.start_queue(:my_queue, failure_mode: {Honeydew.FailureMode.Move,
                                               queue: :failed})
```

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

### Honeydew.async

Source: https://hexdocs.pm/honeydew/Honeydew-function-async.html

Runs a task asynchronously. It can raise a RuntimeError if the queue process is not available. Options include 'reply' to get the job result via yield/1 and 'delay_secs' to postpone execution.

```APIDOC
## async(task, queue, opts \\ [])

### Description
Runs a task asynchronously. Raises a `RuntimeError` if `queue` process is not available. You can provide any of the following `opts`:
  * `reply`: returns the result of the job via `yield/1`, see below.
  * `delay_secs`: delays the execution of the job by the provided number of seconds.

### Parameters
#### Path Parameters
- **task** (any()) - Required - The task to run.
- **queue** (atom()) - Required - The name of the queue.
- **opts** (list()) - Optional - A list of options, such as `reply` or `delay_secs`.

### Examples
#### Run a task asynchronously
```elixir
Honeydew.async({:ping, ["127.0.0.1"]}, :my_queue)
```

#### Run a task asynchronously and wait for result (without pipes)
```elixir
job = Honeydew.async({:ping, ["127.0.0.1"]}, :my_queue, reply: true)
Honeydew.yield(job)
```

#### Run a task asynchronously and wait for result (with pipes)
```elixir
:pong = 
  {:ping, ["127.0.0.1"]}
  |> Honeydew.async(:my_queue, reply: true)
  |> Honeydew.yield()
```

#### Run a task an hour later
```elixir
Honeydew.async({:ping, ["127.0.0.1"]}, :my_queue, delay_secs: 60*60)
```
```

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

### Start Global Workers on Specific Nodes

Source: https://hexdocs.pm/honeydew/Honeydew-function-start_workers.html

Initiates workers for a global queue, specifying the nodes where workers should connect. This is used for distributed job processing across multiple nodes.

```elixir
Honeydew.start_workers({:global, "my_awesome_queue"}, MyJobModule, nodes: [:clientfacing@dax, :queue@dax])
```

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

### Filter Jobs by Task (ErlangQueue/Mnesia)

Source: https://hexdocs.pm/honeydew/Honeydew-function-filter.html

Use a function to filter jobs based on their task, suitable for ErlangQueue or Mnesia. This example filters for jobs with a :ping task targeting '127.0.0.1'.

```elixir
Honeydew.filter(:my_queue, &match?(%Honeydew.Job{task: {:ping, _}}, &1))
```

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

### Filter Jobs by Task (Mnesia)

Source: https://hexdocs.pm/honeydew/Honeydew-function-filter.html

Filter jobs in Mnesia queues using a map to specify the task criteria. This example filters for jobs with a :ping task targeting '127.0.0.1'.

```elixir
Honeydew.filter(:my_queue, %{task: {:ping, ["127.0.0.1"]}})
```

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

### init/2 (Callback)

Source: https://hexdocs.pm/honeydew/Honeydew.Queue.html

Initializes the GenServer process.

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

### Description
Initializes the GenServer process.

### Callback Signature
```elixir
init(name :: Honeydew.name(), args :: list()) :: {:ok, Honeydew.private()} | {:stop, reason :: term()}
```
```

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

### init

Source: https://hexdocs.pm/honeydew/Honeydew.Queue.html

Initializes the Honeydew queue with a given name and arguments.

```APIDOC
## init

### Description
Initializes the Honeydew queue.

### Specs
```elixir
init(name(), args()) :: {:ok, private()}
```
```

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

### Run Ecto Migrations and Tests

Source: https://hexdocs.pm/honeydew_ecto_notify_queue/index.html

Execute Ecto create and migrate commands, followed by running your tests. Ensure your environment is set to 'test'.

```bash
$ MIX_ENV=test mix do ecto.create, ecto.migrate
$ mix test
```

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

### init(name, args)

Source: https://hexdocs.pm/honeydew/Honeydew.Queue-callback-init.html

Initializes a queue with a given name and arguments. This is a callback function within the Honeydew.Queue module.

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

### Description
Initializes a queue with a given name and arguments.

### Signature
`init(name(), args()) :: {:ok, private()}`

### Parameters
- **name** (any) - The name of the queue.
- **args** (any) - Arguments for initializing the queue.

### Returns
- `{:ok, private()}` - Indicates successful initialization. The second element is a private internal representation.
```

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

### Running Tests

Source: https://hexdocs.pm/honeydew_ecto_notify_queue/readme.html

Execute Ecto migrations and run tests for the HoneydewEctoNotifyQueue. Ensure your environment is set to 'test'.

```bash
$MIX_ENV=test mix do ecto.create, ecto.migrate
$mix test
```

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

### Honeydew.Queue.init Callback Specification

Source: https://hexdocs.pm/honeydew/Honeydew.Queue-callback-init.html

This is the specification for the init callback in Honeydew.Queue. It takes a name and arguments and returns an :ok tuple with a private value.

```elixir
init(name(), args()) :: {:ok, private()}
```

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

### Get Running Queues

Source: https://hexdocs.pm/honeydew/Honeydew.html

Returns a list of all queue names that have active workers running on the current node.

```elixir
workers() :: [queue_name()]

```

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

### Honeydew Queue Callback Specification: init

Source: https://hexdocs.pm/honeydew/Honeydew.Queue.html

Callback function to initialize the GenServer. It takes the name and arguments for initialization.

```elixir
init(name, args)
```

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

### immediate(job, reason, args)

Source: https://hexdocs.pm/honeydew/Honeydew.FailureMode.Retry-function-immediate.html

The `immediate` function is used to retry a job immediately. It takes the job, the reason for the retry, and any additional arguments.

```APIDOC
## immediate(job, reason, args)

### Description
Retries a job immediately.

### Parameters
- **job**: The job to retry.
- **reason**: The reason for the retry.
- **args**: Additional arguments for the retry.
```

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

### Get Queue Status

Source: https://hexdocs.pm/honeydew/Honeydew.html

Retrieves the current status of a queue and its workers. An optional timeout can be specified for the status callback.

```elixir
status(queue_name(), [status_opt()]) :: map()

```

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

### init_failed/0

Source: https://hexdocs.pm/honeydew/Honeydew.Worker.html

Invoked when the `init/1` callback returns anything other than `{:ok, state}` or raises an error during worker startup.

```APIDOC
## init_failed/0

### Description
Invoked when `init/1` returns anything other than `{:ok, state}` or raises an error.

### Specs
```elixir
init_failed() :: any()
```

### Response
#### Success Response
* **any()** - Can return any value, typically used for logging or cleanup.
```

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

### Configure Mnesia Application Inclusion (Default)

Source: https://hexdocs.pm/honeydew/index.html

If Honeydew is the only user of Mnesia, use `:included_applications` to let Honeydew manage it.

```elixir
def application do
  [
    included_applications: [:mnesia]
  ]
end
```

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

### create_config

Source: https://hexdocs.pm/honeydew_ecto_notify_queue/HoneydewEctoNotifyQueue.Config.html

Creates a job config using the given repo. The value must be a string.

```APIDOC
## create_config(repo, key, value)

### Description
Creates a job config using the given repo.

### Parameters
#### Path Parameters
- **repo** (Ecto.Repo.t()) - Required - The Ecto repository to use.
- **key** (String.t()) - Required - The key for the configuration.
- **value** (String.t()) - Required - The value for the configuration. Must be a string.

### Returns
- `{:ok, HoneydewEctoNotifyQueue.JobConfig.t()}` on success.
- `{:error, any()}` on failure.
```

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

### init_failed()

Source: https://hexdocs.pm/honeydew/Honeydew.Worker-callback-init_failed.html

This callback is invoked when the `init/1` function returns anything other than `{:ok, state}` or raises an error. It is part of the Honeydew.Worker module.

```APIDOC
## init_failed()

### Description
Invoked when `init/1` returns anything other than `{:ok, state}` or raises an error.

### Specs
```elixir
init_failed() :: any()
```
```

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

### List All Job Configurations

Source: https://hexdocs.pm/honeydew_ecto_notify_queue/HoneydewEctoNotifyQueue.Config.html

Fetches all job configuration records from the database.

```Elixir
list_configs(Ecto.Repo.t()) :: {:ok, [HoneydewEctoNotifyQueue.JobConfig.t()]}
```

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

### cancel(job)

Source: https://hexdocs.pm/honeydew/Honeydew-function-cancel.html

Cancels a job using its Honeydew.Job.t() representation. Returns :ok if the job was successfully cancelled before starting, or an error tuple if the job was in progress or not found.

```APIDOC
## cancel(job)

### Description
Cancels a job using its Honeydew.Job.t() representation. The return value depends on the status of the job.

### Method
(Function Call)

### Parameters
#### Path Parameters
- **job** (Honeydew.Job.t()) - Required - The job to cancel.

### Response
#### Success Response (:ok)
- Returns `:ok` if the job had not been started and was able to be cancelled.

#### Error Response
- `{:error, :in_progress}` - Job was in progress and unable to be cancelled.
- `{:error, :not_found}` - Job was not found on the queue (or already processed) and was unable to be cancelled.
```

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

### Get list of queues with running workers

Source: https://hexdocs.pm/honeydew/Honeydew-function-workers.html

Call the workers() function to retrieve a list of all queues that have active workers on the current node. This function requires no arguments.

```Honeydew
workers() :: [queue_name()]
```

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

### node_up/2 (Function)

Source: https://hexdocs.pm/honeydew/Honeydew.Queue.html

Handles a node coming up.

```APIDOC
## node_up(queue, node)

### Description
Handles a node coming up.

### Function Signature
```elixir
node_up(queue :: Honeydew.queue_name(), node :: atom()) :: :ok
```
```

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

### list_configs

Source: https://hexdocs.pm/honeydew_ecto_notify_queue/HoneydewEctoNotifyQueue.Config.html

Fetches all job configuration records using the given repo.

```APIDOC
## list_configs(repo)

### Description
Fetches all job configuration records using the given repo.

### Parameters
#### Path Parameters
- **repo** (Ecto.Repo.t()) - Required - The Ecto repository to use.

### Returns
- `{:ok, [HoneydewEctoNotifyQueue.JobConfig.t()]}` on success.
```

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

### Configure Mnesia Application Inclusion (External Use)

Source: https://hexdocs.pm/honeydew/index.html

If Mnesia is used outside of Honeydew, specify it in `:extra_applications` and manually create the Mnesia schema.

```elixir
def application do
  [
    extra_applications: [:mnesia]
  ]
end
```

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

### worker_ready/1 (Function)

Source: https://hexdocs.pm/honeydew/Honeydew.Queue.html

Marks a worker as ready.

```APIDOC
## worker_ready(queue_process)

### Description
Marks a worker as ready.

### Function Signature
```elixir
worker_ready(queue_process :: any()) :: :ok
```
```

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

### resume/1

Source: https://hexdocs.pm/honeydew/Honeydew.html

Resumes job processing for a queue.

```APIDOC
## resume/1

### Description
Resumes job processing for a queue.

### Function Signature
`resume(queue)`

### Parameters
- `queue`: The name of the queue to resume.
```

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

### Cancel a Job in Elixir

Source: https://hexdocs.pm/honeydew/Honeydew.html

Use `Honeydew.cancel/1` to cancel a job. The outcome depends on the job's current status: `:ok` if not started, `{:error, :in_progress}` if running, or `{:error, :not_found}` if already processed or not found.

```elixir
Honeydew.cancel(job)
```

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

### Create Job Configuration

Source: https://hexdocs.pm/honeydew_ecto_notify_queue/HoneydewEctoNotifyQueue.Config.html

Creates a new job configuration record in the database. The value must be a string.

```Elixir
create_config(Ecto.Repo.t(), String.t(), String.t()) ::
  {:ok, HoneydewEctoNotifyQueue.JobConfig.t()} | {:error, any()}
```

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

### resume(queue)

Source: https://hexdocs.pm/honeydew/Honeydew-function-resume.html

Resumes job processing for a queue. It takes a queue name as an argument and returns :ok on success.

```APIDOC
## resume(queue)

### Description
Resumes job processing for a queue.

### Parameters
#### Path Parameters
- **queue** (string) - Required - The name of the queue to resume.
```

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

### handle_call/3 (Callback)

Source: https://hexdocs.pm/honeydew/Honeydew.Queue.html

Handles synchronous calls to the GenServer.

```APIDOC
## handle_call(request, arg2, state)

### Description
Handles synchronous calls to the GenServer.

### Callback Signature
```elixir
handle_call(request :: term(), arg2 :: GenServer.from(), state :: Honeydew.private()) :: {:reply, reply, new_state} | {:reply, reply, new_state, timeout() | :hibernate} | {:noreply, new_state} | {:noreply, new_state, timeout() | :hibernate} | {:stop, reason, reply, new_state} | {:stop, reason, new_state} when reply: term(), new_state: Honeydew.private(), reason: term()
```
```

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

### resume(queue_process)

Source: https://hexdocs.pm/honeydew/Honeydew.Queue-function-resume.html

Resumes a specified queue process. This function is part of the Honeydew.Queue module.

```APIDOC
## resume(queue_process)

### Description
Resumes a queue process.

### Parameters
#### Path Parameters
- **queue_process** (any) - Required - The queue process to resume.
```

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

### Add Honeydew Dependency

Source: https://hexdocs.pm/honeydew/index.html

Add the Honeydew dependency to your `mix.exs` file to include it in your project.

```elixir
defp deps do
  [{:honeydew, "~> 1.5.0"}]
end
```

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

### resume/1 (Function)

Source: https://hexdocs.pm/honeydew/Honeydew.Queue.html

Resumes the queue process.

```APIDOC
## resume(queue_process)

### Description
Resumes the queue process.

### Function Signature
```elixir
resume(queue_process :: any()) :: :ok
```
```

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

### handle_info/2 (Callback)

Source: https://hexdocs.pm/honeydew/Honeydew.Queue.html

Handles other messages received by the GenServer.

```APIDOC
## handle_info(msg, state)

### Description
Handles other messages received by the GenServer.

### Callback Signature
```elixir
handle_info(msg :: :timeout | term(), state :: Honeydew.private()) :: {:noreply, new_state} | {:noreply, new_state, timeout() | :hibernate} | {:stop, reason :: term(), new_state} when new_state: Honeydew.private()
```
```

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

### do_worker_ready/2 (Function)

Source: https://hexdocs.pm/honeydew/Honeydew.Queue.html

Internal function to mark a worker as ready.

```APIDOC
## do_worker_ready(worker, state)

### Description
Internal function to mark a worker as ready.

### Function Signature
```elixir
do_worker_ready(worker :: any(), state :: Honeydew.private()) :: Honeydew.private()
```
```

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

### Honeydew Queue Type: args

Source: https://hexdocs.pm/honeydew/Honeydew.Queue.html

Represents the arguments for a queue process.

```elixir
args() :: list()
```

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

### get_config

Source: https://hexdocs.pm/honeydew_ecto_notify_queue/HoneydewEctoNotifyQueue.Config.html

Fetches a single job config using the given repo for the specified key.

```APIDOC
## get_config(repo, key)

### Description
Fetches a single job config using the given repo for the specified key.

### Parameters
#### Path Parameters
- **repo** (Ecto.Repo.t()) - Required - The Ecto repository to use.
- **key** (String.t()) - Required - The key of the configuration to fetch.

### Returns
- `{:ok, HoneydewEctoNotifyQueue.JobConfig.t()}` if the config is found.
- `{:error, :not_found}` if the config is not found.
```

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

### key/1

Source: https://hexdocs.pm/honeydew/Honeydew.Queue.Mnesia.WrappedJob.html

Generates a Mnesia key for a WrappedJob.

```APIDOC
## key/1

### Description
Generates a Mnesia key for a WrappedJob.

### Function Signature
key(arg)

### Parameters
- **arg** (WrappedJob) - The WrappedJob for which to generate a key.
```

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

### queues()

Source: https://hexdocs.pm/honeydew/Honeydew-function-queues.html

Retrieves a list of all queues currently running on the Honeydew node.

```APIDOC
## queues()

### Description
Returns a list of queues running on this node.

### Method
N/A (Function call)

### Parameters
None

### Response
#### Success Response
- `[queue_name()]` (list): A list of queue names.
```

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

### new/1

Source: https://hexdocs.pm/honeydew/Honeydew.Queue.Mnesia.WrappedJob-function-new.html

Creates a new wrapped job. This function is used internally to wrap a job before it is enqueued.

```APIDOC
## new(job)

### Description
Creates a new wrapped job.

### Parameters
#### Path Parameters
- **job** (any()) - Required - The job to be wrapped.
```

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

### enqueue/2 (Callback)

Source: https://hexdocs.pm/honeydew/Honeydew.Queue.html

Callback function to enqueue a job.

```APIDOC
## enqueue(job, private)

### Description
Callback function to enqueue a job.

### Callback Signature
```elixir
enqueue(job :: Honeydew.job(), private :: Honeydew.private()) :: {Honeydew.private(), Honeydew.job()}
```
```

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

### key/2

Source: https://hexdocs.pm/honeydew/Honeydew.Queue.Mnesia.WrappedJob-function-key.html

Retrieves the key for a WrappedJob using run_at and id.

```APIDOC
## key(run_at, id)

### Description
Retrieves the key for a WrappedJob using the run_at timestamp and the job id.

### Function Signature
key(run_at, id)

### Parameters
- **run_at**: The timestamp when the job is scheduled to run.
- **id**: The unique identifier for the job.
```

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

### enqueue(job, private)

Source: https://hexdocs.pm/honeydew/Honeydew.Queue-callback-enqueue.html

The `enqueue` callback function is used to add a job to the Honeydew queue. It takes a job and a private flag as arguments.

```APIDOC
## enqueue(job, private)

### Description
Adds a job to the Honeydew queue.

### Parameters
- **job** (job()) - Required - The job to be enqueued.
- **private** (private()) - Required - A flag indicating if the job is private.

### Return Value
- **{private(), job()}** - Returns a tuple containing the private flag and the enqueued job.
```

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

### handle_info(msg, state)

Source: https://hexdocs.pm/honeydew/Honeydew.Queue-callback-handle_info.html

Processes incoming messages and updates the queue state. It can return a new state, a new state with a timeout or hibernate instruction, or stop the process with a reason and a new state.

```APIDOC
## handle_info(msg, state)

### Description
Processes incoming messages and updates the queue state. It can return a new state, a new state with a timeout or hibernate instruction, or stop the process with a reason and a new state.

### Function Signature
```elixir
handle_info(msg :: :timeout | term(), state :: private()) ::
  {:noreply, new_state}
  | {:noreply, new_state, timeout() | :hibernate}
  | {:stop, reason :: term(), new_state}
when new_state: private()
```

### Parameters
- **msg**: The incoming message. Can be `:timeout` or any other term.
- **state**: The current private state of the queue.

### Return Value
- `{:noreply, new_state}`: Continues processing with the new state.
- `{:noreply, new_state, timeout() | :hibernate}`: Continues processing with the new state, specifying a timeout or hibernation.
- `{:stop, reason :: term(), new_state}`: Stops the process with a given reason and the new state.
```

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

### init_failed() Callback Specification

Source: https://hexdocs.pm/honeydew/Honeydew.Worker-callback-init_failed.html

This defines the specification for the init_failed callback. It is invoked when init/1 fails.

```elixir
init_failed() :: any()
```

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

### handle_success(job, args)

Source: https://hexdocs.pm/honeydew/Honeydew.SuccessMode-callback-handle_success.html

The `handle_success` callback is invoked when a job completes successfully. It receives the job details and any associated arguments.

```APIDOC
## handle_success(job, args)

### Description
This callback function is executed upon successful completion of a job. It receives the job object and a list of arguments.

### Parameters
#### Path Parameters
- **job** (%Honeydew.Job) - Required - Represents the completed job with details like `by`, `completed_at`, `delay_secs`, `enqueued_at`, `failure_private`, `from`, `job_monitor`, `private`, `queue`, `result`, `started_at`, and `task`.
- **args** (list()) - Required - A list of arguments passed to the job.

### Response
#### Success Response (any())
- Returns any() - The result of the callback execution.
```

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

### do_worker_ready(worker, state)

Source: https://hexdocs.pm/honeydew/Honeydew.Queue-function-do_worker_ready.html

Marks a worker as ready within the queue system, potentially updating its state.

```APIDOC
## do_worker_ready(worker, state)

### Description
This function is used to signal that a specific worker is ready to process tasks. It takes the worker identifier and its current state as arguments.

### Parameters
#### Path Parameters
- **worker** (any) - Required - Identifier for the worker.
- **state** (any) - Required - The current state of the worker.
```

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

### move(job, to_queue)

Source: https://hexdocs.pm/honeydew/Honeydew-function-move.html

Moves a job to another queue. Raises a `RuntimeError` if `to_queue` is not available. This function first enqueues the job on `to_queue`, and then tries to cancel it on its current queue. This means there's a possibility a job could be processed on both queues. This behavior is consistent with Honeydew's at-least-once execution goal. This function is most helpful on a queue where there are no workers (like a dead letter queue), because the job won't be processed out from under the queue.

```APIDOC
## move(job, to_queue)

### Description
Moves a job to another queue.

### Function Signature
```elixir
move(Honeydew.Job.t(), to_queue :: queue_name()) :: Honeydew.Job.t() | no_return()
```

### Behavior
- Raises a `RuntimeError` if `to_queue` is not available.
- Enqueues the job on `to_queue` and then attempts to cancel it on its current queue.
- There is a possibility a job could be processed on both queues, consistent with Honeydew's at-least-once execution goal.
- Most helpful on queues with no workers (e.g., dead letter queues) to prevent race conditions.
```

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

### worker_ready(queue_process)

Source: https://hexdocs.pm/honeydew/Honeydew.Queue-function-worker_ready.html

Signals that a worker process is ready to accept tasks from the queue.

```APIDOC
## worker_ready(queue_process)

### Description
This function is called to indicate that a worker process associated with a queue is ready.

### Function Signature
`worker_ready(queue_process)`

### Parameters
#### Path Parameters
- **queue_process** (any) - Required - The identifier or object representing the queue process.
```

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

### Configure HoneydewEctoNotifyQueue in Supervision Tree

Source: https://hexdocs.pm/honeydew_ecto_notify_queue/index.html

Configure the HoneydewEctoNotifyQueue within your application's supervision tree. Specify the repository, maximum job processing time, retry intervals, and the notifier process name.

```elixir
import Supervisor.Spec

def background_job_processes do
  [
    notifier_process(),
    Honeydew.queue_spec(:process, # queue_name
      queue: {HoneydewEctoNotifyQueue, [
                  repo: YourApp.Repo, # your app's Repo module
                  max_job_time: 3_600, # seconds
                  retry_seconds: 15, # seconds,
                  notifier: YourApp.Notifier # this should match the `name:` in `notifier_process` below
                ]},
      failure_mode: {Honeydew.FailureMode.Retry, times: 3}
    ),
    Honeydew.worker_spec(:process, YourApp.Worker, num: 1)
  ]
end

def notifier_process do
  worker(Postgrex.Notifications, [YourApp.Repo.config() ++ [name: YourApp.Notifier]])
end

def start(_type, _args) do
  children = [
    # ... The rest of your app's supervision tree
  ] ++ background_job_processes
  
  Supervisor.start_link(children, opts)
end
```

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

### handle_success/2 Callback Specification

Source: https://hexdocs.pm/honeydew/Honeydew.SuccessMode.html

Defines the expected structure for the `job` and `args` parameters when handling a successful job. Use this callback to define custom success logic.

```elixir
handle_success(
  job :: %Honeydew.Job{
    by: term(),
    completed_at: term(),
    delay_secs: term(),
    enqueued_at: term(),
    failure_private: term(),
    from: term(),
    job_monitor: term(),
    private: term(),
    queue: term(),
    result: term(),
    started_at: term(),
    task: term()
  },
  args :: list()
) :: any()
```

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

### Run Task Asynchronously and Wait for Result

Source: https://hexdocs.pm/honeydew/Honeydew-function-async.html

Execute a task asynchronously and retrieve its result using `Honeydew.yield/1`. This can be done with or without pipes. The `reply: true` option is required to enable result retrieval.

```elixir
# Without pipes
job = Honeydew.async({:ping, ["127.0.0.1"]}, :my_queue, reply: true)
Honeydew.yield(job)
```

```elixir
# With pipes
:pong =
  {:ping, ["127.0.0.1"]}
  |> Honeydew.async(:my_queue, reply: true)
  |> Honeydew.yield()
```

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

### from_record/1

Source: https://hexdocs.pm/honeydew/Honeydew.Queue.Mnesia.WrappedJob-function-from_record.html

Converts a Mnesia record into a WrappedJob.

```APIDOC
## from_record/1

### Description
Converts a Mnesia record into a WrappedJob.

### Function Signature
`from_record(record)`

### Parameters
#### Path Parameters
- **record** (Mnesia Record) - The Mnesia record to convert.
```

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

### enqueue/2

Source: https://hexdocs.pm/honeydew_ecto_notify_queue/HoneydewEctoNotifyQueue.html

Adds a job to the jobs table.

```APIDOC
## enqueue/2

### Description
Adds a job to the jobs table.

### Parameters
#### Path Parameters
- **job** (any) - Required - The job to enqueue.
- **state** (any) - Required - The queue state.

### Response
#### Success Response (200)
- **:ok** - Indicates successful enqueuing.
```

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

### handle_call Callback Specification

Source: https://hexdocs.pm/honeydew/Honeydew.Queue-callback-handle_call.html

This is the type specification for the `handle_call` callback. It defines the expected arguments and the various possible return tuples, indicating how the GenServer should respond to a call and manage its state.

```Elixir
handle_call(request :: term(), GenServer.from(), state :: private()) ::
  {:reply, reply, new_state}
  | {:reply, reply, new_state, timeout() | :hibernate}
  | {:noreply, new_state}
  | {:noreply, new_state, timeout() | :hibernate}
  | {:stop, reason, reply, new_state}
  | {:stop, reason, new_state}
when reply: term(), new_state: private(), reason: term()
```
Tokens:
Raw