henriquesati

Mnesia Memento being update through iex and files except for oban jos

I have the given Mnesia domain

defmodule MnesiaPendingContracts do
  require Logger
  use Memento.Table,
    attributes: [:pubkey, :last_attempt, :attempts, :time_limit, :ok_trys, :failed_retrys],
    type: :ordered_set

end

defmodule Testespay.DataLayer.MnesiaPendingContractsDomain do
  require Logger
  alias Memento.Query
  @time_limit Application.get_env(:testespay, :transaction_seconds_time_limit)
  def insert_record(pk) do
    Memento.transaction(fn ->
      record = %MnesiaPendingContracts{
        pubkey: pk,
        last_attempt: 0,
        attempts: 0,
        time_limit: @time_limit,
        ok_trys: 0,
        failed_retrys: 0
      }

      Query.write(record)
    end)
  end
  def att_ok_trys(pk) do
    Memento.transaction!(fn ->
      case Memento.Query.read(MnesiaPendingContracts, pk) do
        nil ->
          Logger.debug("Registro não encontrado para: #{pk}")
          :not_found

          record ->
            Logger.debug("enter ------------------------------------------------------------------------------------------------------------")
          updated = %{record |
            ok_trys: record.ok_trys + 1,
            last_attempt: DateTime.utc_now()
          }
          Logger.debug("------------------------------------------------------------------------------------------------------------")
          Logger.debug(updated)
          Memento.Query.write(updated)
      end
    end)
  end

  def att_failed_retrys(pk) do
    Memento.transaction!(fn ->
      case Memento.Query.read(MnesiaPendingContracts, pk) do
        nil ->
          Logger.debug("Registro não encontrado para: #{pk}")
          :not_found

          record ->
          updated = %{record |
            failed_retrys: record.failed_retrys + 1,
            last_attempt: DateTime.utc_now()
          }
          Memento.Query.write(updated)
      end
    end)
  end

I can call att_ok_trys from iex

iex(1)> Testespay.DataLayer.MnesiaPendingContractsDomain.insert_record("A")
{:ok,
 %MnesiaPendingContracts{
   __meta__: Memento.Table,
   pubkey: "A",
   last_attempt: 0,
   attempts: 0,
   time_limit: 100,
   ok_trys: 0,
   failed_retrys: 0
 }}

[debug] enter ------------------------------------------------------------------------------------------------------------
[debug] ------------------------------------------------------------------------------------------------------------
[debug] [__struct__: MnesiaPendingContracts, __meta__: Memento.Table, pubkey: "A", last_attempt: ~U[2025-02-26 01:15:21.442310Z], attempts: 0, time_limit: 100, ok_trys: 1, failed_retrys: 0]
%MnesiaPendingContracts{
  __meta__: Memento.Table,
  pubkey: "A",
  last_attempt: ~U[2025-02-26 01:15:21.442310Z],
  attempts: 0,
  time_limit: 100,
  ok_trys: 1,
  failed_retrys: 0
}

and it works
I can call from a gen server init callback

defmodule Testespay.Backgroundjobs.FetchAwaitingContracts do
  alias Testespay.Oban.PubkeyCheckWorker
  use GenServer
  require Logger
  alias Testespay.DataLayer.MnesiaDomain
  alias Oban
  alias Testespay.DataLayer.MnesiaPendingContractsDomain
  @interval 5_000 # 5 segundos

  def start_link(_) do
    GenServer.start_link(__MODULE__, %{}, name: __MODULE__)
  end

  @impl true
  def init(state) do
    MnesiaPendingContractsDomain.insert_record("address")
    MnesiaPendingContractsDomain.att_ok_trys("address")
    schedule_work()
    {:ok, state}
  end

[debug] enter ------------------------------------------------------------------------------------------------------------
[debug] ------------------------------------------------------------------------------------------------------------
[debug] [struct: MnesiaPendingContracts, pubkey: “address”, meta: Memento.Table, last_attempt: ~U[2025-02-26 01:31:20.746365Z], attempts: 0, time_limit: 100, ok_trys: 1, failed_retrys: 0]
Interactive Elixir (1.17.0) - press Ctrl+C to exit (type h() ENTER for help)
[info] Starting background task to fetch recent contracts
[debug] {:ok, [%MnesiaPendingContracts{meta: Memento.Table, pubkey: “address”, last_attempt: ~U[2025-02-26 01:31:20.746365Z], attempts: 0, time_limit: 100, ok_trys: 1, failed_retrys: 0}]}
[debug] Resultado fetching: [%MnesiaPendingContracts{meta: Memento.Table, pubkey: “address”, last_attempt: ~U[2025-02-26 01:31:20.746365Z], attempts: 0, time_limit: 100, ok_trys: 1, failed_retrys: 0}]
[debug] {:ok, }
[info] No unexpired contracts found in Mnesia.

on a handle info

def handle_info(:work, state) do
    Logger.info("on handle info callback")
    MnesiaPendingContractsDomain.insert_record("address")
    MnesiaPendingContractsDomain.att_ok_trys("address")

[info] on handle info callback
[debug] enter ------------------------------------------------------------------------------------------------------------
[debug] ------------------------------------------------------------------------------------------------------------
[debug] [struct: MnesiaPendingContracts, pubkey: “address”, meta: Memento.Table, last_attempt: ~U[2025-02-26 01:36:58.362964Z], attempts: 0, time_limit: 100, ok_trys: 1, failed_retrys: 0]

but when I try to run it from an oban job, doesn’t work

 def perform(%Oban.Job{attempt: attempt, meta: meta} = job) do

    Logger.configure(level: :debug)
    Logger.debug("initing job....")
    contract_data = job.args["contract"]
    address = contract_data["pubkey"]
    target_value = contract_data["amount"]

    case perform_request(address) do
      {:ok, response_value}->
        MnesiaPendingContractsDomain.insert_record(address)
        MnesiaPendingContractsDomain.att_ok_trys(address)

        case handle_check_balance(response_value, target_value) do
            :paid -> :ok
            {:snooze, @snooze_time} -> {:snooze, @snooze_time}
          end

      {:error, :rate_limit} ->
        MnesiaPendingContractsDomain.att_failed_retrys(address)
      {:error, reason} -> {:snooze, @snooze_time}
    end
  end

[debug] initing job…
[debug] init request…
[debug] 35XeuP2xcB4KQ6EU3NVMenNMnVYQet84knezSoE2zzRY
[debug] https://rpc.ankr.com/solana_devnet/ae321adefbcd42cb37d0790c522ce876c7e9f19dbfece1d44b9e90845e855100
[debug] Resposta recebida: %Finch.Response{status: 200, body: “{"id":1,"jsonrpc":"2.0","result":{"context":{"apiVersion":"2.1.14","slot":363622841},"value":0}}”, headers: [{“date”, “Wed, 26 Feb 2025 01:39:45 GMT”}, {“content-type”, “application/json”}, {“content-length”, “96”}, {“connection”, “keep-alive”}, {“strict-transport-security”, “max-age=15724800; includeSubDomains”}, {“access-control-allow-origin”, “*”}, {“access-control-allow-credentials”, “true”}, {“access-control-allow-methods”, “GET, PUT, POST, DELETE, PATCH, OPTIONS”}, {“access-control-allow-headers”, “DNT,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Range,Authorization,solana-client”}, {“access-control-max-age”, “1728000”}], trailers: }
[debug] Resposta HTTP 200: {“id”:1,“jsonrpc”:“2.0”,“result”:{“context”:{“apiVersion”:“2.1.14”,“slot”:363622841},“value”:0}}
[debug] Saldo extraído: 0

5 comments

/oban #mnesia #memento

1 84 5

2025-02-26 17:43:14 UTC

Marked As Solved

sorentwo

Oban Core Team

It turns out this was related to an issue in the code. Oban rescues and records all exceptions and it wasn’t apparent that an error was happening.

github.com/oban-bg/oban

Oban silent crashing even with strict type assets

opened 03:32PM - 26 Feb 25 UTC

closed 03:44PM - 26 Feb 25 UTC

henriquesati

kind:bug area:oss closed:invalid

### Precheck - Do a quick search and make sure the bug has not yet been reporte…d - For support, favor using the Elixir Forum, Slack, IRC, etc. - Be friendly and polite! ### Environment - Oban Version 2.10 - PostgreSQL 11 - Elixir 1.17 OTP 26.3 ### Current Behavior I have crossed a issue before using Oban and **case pattern matching**, this doesnt important now (I dont even remember what it was properly), my functions wasnt being called and I couldnt find why, after debugging a bit I found the problem (it was in another module return), so I changed to strict using with pattern matching to avoid the same issue, explicity treating piece by piece of the job code so if fails a gain, I will know where. Today I crossed something familiar even with **WITH** CLAUSES My Oban Job ``` defmodule Testespay.Oban.PubkeyCheckWorker do use Oban.Worker, queue: :pending_keys alias Testespay.Genservers.ApiLoadBalancerBlockchain alias Testespay.Resources.CompareRealm alias Testespay.Oban.RequestBalanceFileSolana alias Testespay.DataLayer.MnesiaPendingContractsDomain require Logger @snooze_time 3 @target_max_retrys 15 @allowed_retrys 30 ## retrys que incluem quando a request não foi feita corretamente @impl Oban.Worker def perform(%Oban.Job{attempt: _attempt, meta: _meta} = job) do Logger.debug("initing job....") contract_data = job.args["contract"] addres = contract_data["pubkey"] target_value = contract_data["amount"] job_should_continue(address) end def main_function(address, target_value) do case perform_request(address) do {:ok, response_value}-> MnesiaPendingContractsDomain.att_ok_trys(address) case handle_check_balance(response_value, target_value) do :paid -> :ok {:snooze, @snooze_time} -> {:snooze, @snooze_time} end {:error, :rate_limit} -> MnesiaPendingContractsDomain.att_failed_retrys(address) {:error, _reason} -> {:snooze, @snooze_time} end end def handle_check_balance(response_value, target_value) when response_value > 0 do Logger.debug("-----into handle check balance") result = CompareRealm.compare_2_numbers(response_value, target_value) case result do {:ok, :eq} -> :paid {:ok, :lt} -> {:snooze, @snooze_time} {:ok, :gt} -> {:snooze, @snooze_time} end end def handle_check_balance(_response_value, _target_value, _) do Logger.debug("-----into handle check balance") {:snooze, 10} end defp perform_request(address) do Logger.debug("-----into perform_request") with {:ok, api_url} <- ApiLoadBalancerBlockchain.pick_api(), {:ok, response} <- RequestBalanceFileSolana.get_balance(address, api_url) do MnesiaPendingContractsDomain.att_ok_trys(address) {:ok, response} else {:error, :rate_limit} -> Logger.warning("Rate limit atingido") {:error, :rate_limit} {:error, reason} -> Logger.error("Erro na requisição: #{inspect(reason)}") {:error, reason} end end def job_should_continue(pubkey) do Logger.debug("hiii [job_should_continue]") Logger.debug(pubkey) with {:ok, _mnesia_data} <- MnesiaPendingContractsDomain.get_record_by_pk(pubkey) do Logger.debug("job still ongoing") :ok else {:error, reason} -> Logger.debug("coudlt fetch job record #{reason}") :ok end end end ``` the piece in question of code in question: ``` def job_should_continue(pubkey) do Logger.debug("hiii [job_should_continue]") Logger.debug(pubkey) with {:ok, _mnesia_data} <- MnesiaPendingContractsDomain.get_record_by_pk(pubkey) do Logger.debug("job still ongoing") :ok else {:error, reason} -> Logger.debug("coudlt fetch job record #{reason}") :ok end end ``` and the mnesia module function ``` def get_record_by_pk(pk) do result = Memento.transaction(fn -> Memento.Query.read(MnesiaPendingContracts, pk) end) Logger.debug("resultado dessa porra de banco #{result}") case result do {:ok, _} -> {:ok, :up} {:error, _} -> {:error, :down} _ -> System.stop(1) end end ``` this is my code after all the work, but on the very beginning it was exatcly like that ``` def job_sho2uld_continue(pubkey) do with {:ok, _mnesia_data} <- MnesiaPendingContractsDomain.get_record_by_pk(pubkey) do #CALL some function #return this funtion else {:error, reason} -> :ok end end ``` that was calling this ``` def get_record_by_pk(pk) do result = Memento.transaction(fn -> Memento.Query.read(MnesiaPendingContracts, pk) end) do {:ok, nil} -> Logger.debug("record mnesia not found") {:error, :not_found} {:ok, record} -> Logger.debug("Extracted record: #{inspect(record)}") {:ok, record} {:error, reason} -> Logger.debug("unknow reason #{reason}" ) {:error,:not_found} end end ``` it was weird because this mnesia module it was tested and fully working in another section of the code, and had little capacity to cause problems (minimal output possibilites) so I reached iEx and found out the problem was: I was trying to debug a struct without calling inspect() to it ``` iex(13)> Testespay.DataLayer.MnesiaPendingContractsDomain.get_record_by_pk(pubkey1) ** (Protocol.UndefinedError) protocol String.Chars not implemented for {:ok, %MnesiaPendingContracts{__meta__: Memento.Table, pubkey: "abc123", last_attempt: 0, attempts: 0, time_limit: 100, job_id: 1, ok_trys: 0, failed_retrys: 0}} of type Tuple. This protocol is implemented for the following type(s): Atom, BitString, Date, DateTime, Decimal, Float, Integer, List, NaiveDateTime, Phoenix.LiveComponent.CID, Postgrex.Copy, Postgrex.Query, Time, URI, Version, Version.Requirement (elixir 1.17.0) lib/string/chars.ex:3: String.Chars.impl_for!/1 (elixir 1.17.0) lib/string/chars.ex:22: String.Chars.to_string/1 (testespay 0.1.0) lib/testespay/data_layer/mnesia_pending_contracts.ex:18: Testespay.DataLayer.MnesiaPendingContractsDomain.get_record_by_pk/1 iex:13: (file) ``` when I added the inspect(), the job worked properly ```result = Memento.transaction(fn -> Memento.Query.read(MnesiaPendingContracts, pk) end) Logger.debug("resultado dessa porra de banco #{inspect(result)}") ``` Is the desired behavior that something crashes or doesnt work properly even with this strict pattern matching with with clauses? I have come to apoint where I added _ -> System.stop(1) to really check if the return of the domain was something different if is, it is possible to change some internal configurations to avoid it? its painfull not being able to rely on nothing beside my eyes to see what isnt going on ### Expected Behavior more safety with **with** clauses

Post #3