Elixir GenServer正常退出引发未捕获退出错误，影响GraphQL请求

问题原因分析 #

错误的核心是调用GenServer.call的GraphQL进程未捕获目标进程退出的Exit异常：当GenServer处理完Task后正常退出时，若此时有call请求正在等待（或刚发起），GenServer.call会因目标进程不存在抛出{:normal, {GenServer, :call, [...]}}的Exit异常，而GraphQL进程未捕获该异常，最终导致崩溃并返回500状态码。

解决方案 #

方案1：用GenServer.cast替代call（推荐）

你的业务逻辑中，call仅用于触发验证并返回:ok，无需等待验证结果，完全可以用cast替代——cast无需等待回复，不会因目标进程退出抛出异常，从根源避免问题。

修改调用代码

将start_fingerprint_fraud_check中的两处GenServer.call替换为GenServer.cast：

def start_fingerprint_fraud_check(customer_identity) do
  id = process_name("customer_identity-" <> "#{customer_identity.id}")

  General.Supervisor.start_child(NectarineCredit.Risk.IdentityCheck, %{
    id: id,
    ref: nil,
    type: :worker
  })
  |> case do
    {:ok, _pid} ->
      GenServer.cast(id, {:validate_customer_identity_fraud, customer_identity})

    {:error, {:already_started, _pid}} ->
      Logger.debug(
        "Identity fraud check is already running for this customer: #{customer_identity.customer_id}"
      )
      GenServer.cast(id, {:validate_customer_identity_fraud, customer_identity})
  end
end

修改GenServer代码

新增handle_cast函数替代原handle_call（保留原逻辑，仅调整回调类型）：

defmodule NectarineCredit.Risk.IdentityCheck do
  @moduledoc false

  use GenServer, restart: :temporary

  require Logger

  def start_link(opts) do
    GenServer.start_link(__MODULE__, opts, name: opts.id)
  end

  def init(opts) do
    {:ok, opts}
  end

  def handle_cast(
        {:validate_customer_identity_fraud, _customer_identity},
        %{ref: ref} = state
      )
      when is_reference(ref) do
    {:noreply, state}
  end

  def handle_cast(
        {:validate_customer_identity_fraud, customer_identity},
        %{ref: nil} = state
      ) do
    task =
      Task.Supervisor.async_nolink(NectarineCredit.TaskSupervisor, fn ->
        # 原验证逻辑
      end)

    {:noreply, %{state | ref: task.ref}}
  end

  # 原handle_info和terminate逻辑保持不变
  def handle_info({ref, answer}, %{ref: ref} = state) do
    Process.demonitor(ref, [:flush])
    {:stop, :normal, %{state | ref: nil}}
  end

  def handle_info({:DOWN, ref, :process, _pid, reason}, %{ref: ref} = state) do
    {:stop, :shutdown, %{state | ref: nil}}
  end

  def terminate(exit_state, _state) do
    Logger.debug("Process went down as #{exit_state}")
  end
end

方案2：捕获GenServer.call的Exit异常

如果必须保留call逻辑，可以在调用时捕获Exit异常，确保GraphQL进程不会崩溃：

修改调用代码

新增私有函数封装call逻辑并捕获异常：

def start_fingerprint_fraud_check(customer_identity) do
  id = process_name("customer_identity-" <> "#{customer_identity.id}")

  General.Supervisor.start_child(NectarineCredit.Risk.IdentityCheck, %{
    id: id,
    ref: nil,
    type: :worker
  })
  |> case do
    {:ok, _pid} ->
      call_fraud_check(id, customer_identity)

    {:error, {:already_started, _pid}} ->
      Logger.debug(
        "Identity fraud check is already running for this customer: #{customer_identity.customer_id}"
      )
      call_fraud_check(id, customer_identity)
  end
end

defp call_fraud_check(id, customer_identity) do
  try do
    GenServer.call(id, {:validate_customer_identity_fraud, customer_identity})
  rescue
    Exit ->
      Logger.debug("Identity check process exited before completing call for customer: #{customer_identity.customer_id}")
      :ok # 返回业务期望的默认结果
  end
end

方案3：调整GenServer退出时机（可选）

若希望减少进程退出导致的call失败概率，可以让GenServer在Task完成后保持一段时间再退出，避免频繁启停：

修改GenServer代码

新增定时器逻辑，在idle状态超时后再退出：

defmodule NectarineCredit.Risk.IdentityCheck do
  @moduledoc false
  @idle_timeout 5 * 60 * 1000 # 5分钟超时

  use GenServer, restart: :temporary

  require Logger

  def start_link(opts) do
    GenServer.start_link(__MODULE__, opts, name: opts.id)
  end

  def init(opts) do
    {:ok, %{opts | timeout_ref: nil}}
  end

  def handle_call(
        {:validate_customer_identity_fraud, _customer_identity},
        _from,
        %{ref: ref} = state
      )
      when is_reference(ref) do
    {:reply, :ok, state}
  end

  def handle_call(
        {:validate_customer_identity_fraud, customer_identity},
        _from,
        %{ref: nil, timeout_ref: timeout_ref} = state
      ) do
    # 取消之前的超时定时器
    if timeout_ref, do: Process.cancel_timer(timeout_ref)

    task =
      Task.Supervisor.async_nolink(NectarineCredit.TaskSupervisor, fn ->
        # 原验证逻辑
      end)

    {:reply, :ok, %{state | ref: task.ref, timeout_ref: nil}}
  end

  def handle_info({ref, answer}, %{ref: ref} = state) do
    Process.demonitor(ref, [:flush])
    # 启动超时定时器，idle超时后退出
    new_timeout_ref = Process.send_after(self(), :idle_timeout, @idle_timeout)
    {:noreply, %{state | ref: nil, timeout_ref: new_timeout_ref}}
  end

  def handle_info({:DOWN, ref, :process, _pid, reason}, %{ref: ref} = state) do
    Process.demonitor(ref, [:flush])
    new_timeout_ref = Process.send_after(self(), :idle_timeout, @idle_timeout)
    {:noreply, %{state | ref: nil, timeout_ref: new_timeout_ref}}
  end

  def handle_info(:idle_timeout, %{ref: nil} = state) do
    # 超时后退出
    {:stop, :normal, state}
  end

  def terminate(exit_state, _state) do
    Logger.debug("Process went down as #{exit_state}")
  end
end

内容的提问来源于stack exchange，提问作者Junaid Farooq