Using Cachex in Phoenix - working example?

I solved the above by using “extra_applications” instead of “applications” (but not both), but still, I haven’t actually gotten a working example. E.g. in my context, I have something like this:

def get_cached_result!(slug) do

    Cachex.fetch(:my_cache, "key", fn(slug) ->
      Repo.get_by!(MyRecord, slug: slug, parent_id: 0)
    end)

  end

But that generates an error:

function Cachex.fetch/3 is undefined or private

Your primary problem is outdated information for cachex. Elixir used to require you to manage the applications key yourself but starting around 1.4 (I think) it manages it for you. When you choose to manage that key explicitly, then you need to manage it for all deps. The first thing I’d recommend is to try without cachex in any of the application keys, and just put it in deps.

Thanks! I got that one figured out after some trial and error, but I’m still at a loss as to how to make it actually work. I’m hoping that if I can get something working I can at least make a pull request to submit some examples or clarifications to the docs…

try with Cachex.get - not sure a fetch exists - Cachex — Cachex v4.1.1

so maybe:

def get_cached_result!(slug) do

    Cachex.get(:my_cache, "key_#{slug}", fn(slug) ->
      Repo.get_by!(MyRecord, slug: slug, parent_id: 0)
    end)

end

fwiw I have this from some old code (untested recently):

{ _status, post } = Cachex.get(:my_cache, "post_#{id}", fallback: fn(_params) ->
  Post
  |> Repo.get!(id)
  |> Repo.preload([:comments])
end)

EDIT: from a quick look: fetch is being added in Cachex 3.0 - so thats probably why you find it on the github examples:/

Ah, ok, I stumbled into the v3 docs without knowing it. Treacherous docs!

I’ve refactored to use the get function to something like this

  def get_cached_menu!(slug) do
    Cachex.get(:my_cache, slug, fallback: fn(slug) ->
        Repo.get_by!(MyThing, slug: slug)
    end)
  end

That compiles but it throws an exception at run-time:

** (exit) an exception was raised:
    ** (UndefinedFunctionError) function :loaded.slug/1 is undefined (module :loaded is not available)

Why is “slug” being seen as a function? Is my Ecto Repo module not in scope in the callback?

Because the return from Cachex.get(...) is not the raw value, but rather a tuple of success status.

As I recall it returns either {:ok, value} for a value in the cache, or it returns {:loaded, value} for a value that was not in the cache but is not in the cache via a fallback and thus returned that, or it returns {:missing, nil} if it failed to acquire it from cache or a fallback.

As you can see, it is accessing :loaded.slug, which matches the {:loaded, slug} return tuple.

Ah, ok, that makes sense. I think I should submit a PR for the docs on that.

I ended up with something like this:

  def get_cached_thing!(slug) do
    {status, thing} = Cachex.get(:my_cache, slug, fallback: fn(slug) ->
        Repo.get_by!(Mything, slug: slug)
    end)
    case status do
      :loaded -> thing
      :error -> "That thing does not exist"
    end
  end

That works, but I’m open to any comments/improvements/suggestions. Not sure how idiomatic that solution is. Thanks!

It’s already documented at:

It works fine but not very idiomatic, I’d personally do it like (well I generally have the fallback built into the cache rather than on each call, but ignoring that part):

  def get_cached_thing!(slug) do
    Cachex.get(:my_cache, slug, fallback: fn(slug) ->
        Repo.get_by!(Mything, slug: slug)
    end)
    |> case do
      {:error, _} -> nil # It's not common to return error strings, rather you'd probably want an error tuple
      {success, value} when success in [:ok, :loaded] -> value
    end
  end

Or maybe using ok/error tuples, whichever.

Honestly, I didn’t see that page – note that the links from GitHub - whitfin/cachex: A powerful caching library for Elixir with support for transactions, fallbacks and expirations · GitHub do not point to that page, and starting from https://hexdocs.pm/ did not lead me there in any sort of purposeful way (i.e. if you didn’t know what you were looking for already, it’s unlikely you’d end up there), so I hopefully can be forgiven for not finding it. Also, the examples there do not include code for handling the tuples. Yes, of course, if you know what you’re doing that’s a trivial omission, but for noobs, that’s one more snare that might get you. I hope I’m not just speaking for myself by wanting the example to include just a bit more context.

Thank you for the suggestions re idiomatic code! Very helpful and much appreciated!

I found that doc by going to Cachex’s dependency hex page (the first page I go to for any library):

Then I clicked the link that stated Online documentation, which took me to:

Which I then switched to night mode because Ow My Eyes… o.O
It shows two modules, they are:

• Cachex

  • Cachex provides a straightforward interface for in-memory key/value storage

• Cachex.Disk

  • This module contains interaction with disk for serializing terms directly to a given file path. This is mainly used for backing up a cache to disk in order to be able to export a cache to another instance. Writes can have a compression attached and will add basic compression by default

I then clicked on the top one as it’s the main interface for it, which took me to:

In the functions section I clicked the get function and it took me to the link I linked.

‘Almost’ every hex library has their docs on hexdocs at a path of https://hexdocs.pm/<library_name> for note, which is linked from Hex as well (specific versions if you want too).

But yep, it’s linked on the front-most hex page of the library itself.