Behaviour for computing measurements on samples.

Measurements are computations performed on batches of samples to extract metrics, statistics, or derived values. They can be synchronous (blocking) or asynchronous (non-blocking).

Callbacks

• compute/1 - Calculate measurements from a list of samples (required)
• key/0 - Unique identifier for this measurement (required)
• version/0 - Version number for this measurement (required)
• async?/0 - Whether to run asynchronously (optional, default: false)
• batch_capable?/0 - Whether measurement supports batch processing (optional, default: false)
• batch_size/0 - Preferred batch size (optional, required if batch_capable?)
• compute_batch/1 - Compute measurements for a batch of samples (optional)
• dependencies/0 - List of measurement modules this depends on (optional, default: [])
• timeout/0 - Timeout for computation in milliseconds (optional, default: 60_000)

Examples

defmodule MyMeasurement do
  @behaviour Forge.Measurement

  def key do
    config = %{model: "v1"}
    hash = :crypto.hash(:sha256, :erlang.term_to_binary(config)) |> Base.encode16()
    "my_measurement:#{hash}"
  end

  def version, do: 1

  def compute(samples) do
    values = Enum.map(samples, & &1.data.value)
    mean = Enum.sum(values) / length(values)
    {:ok, %{mean: mean}}
  end
end

defmodule BatchMeasurement do
  @behaviour Forge.Measurement

  def key, do: "batch_measurement:v1"
  def version, do: 1
  def batch_capable?, do: true
  def batch_size, do: 50

  def compute_batch(samples) do
    # Vectorized computation
    Enum.map(samples, fn sample ->
      {sample.id, %{result: compute_for_sample(sample)}}
    end)
  end

  def compute(samples) do
    {:ok, [result]} = compute_batch(samples)
    {:ok, elem(result, 1)}
  end
end