Monitorizar aplicaciones en producción

Mix.install([
  {:kino_db, "~> 0.2.3"},
  {:kino_vega_lite, "~> 0.1.10"},
  {:kino_maplibre, "~> 0.1.10"},
  {:kino_explorer, "~> 0.1.10"},
  {:httpoison, "~> 2.2"}
])

Monitorizar aplicaciones en producción

Donde tengamos desplegado el livebook podemos ver los procesos de la máquina, en este caso estamos con un livebook deesplegado en hugginfaces y podemos ver los procesos que tiene el servidor.

for pid <- Process.list() do
  Process.info(pid)
end

Los procesos nos los proporciona la maquina virtual de erlang. Y aqui podemos ver que si obtenemos el head de la lista de procesos obtenemos el proceso init, padre de todo (en linux).

processes = Process.list()
[head | _] = processes
info = Process.info(head, [:memory, :status, :registered_name])

Podemos crear un proceso y administrarlo.

defmodule MyThread do
  def start_link do
    Task.start_link(&loop/0)
  end

  def ping(), do: "pong"

  defp loop do
    Process.flag(:trap_exit, true)

    receive do
      {:EXIT, _pid, :normal} ->
        IO.puts("Hilo terminado normalmente")

      other ->
        IO.puts("Hilo terminado con mensaje inesperado: #{inspect(other)}")
    end
  end
end

# Iniciar el hilo
{:ok, t_pid} = hilo = MyThread.start_link()

Este nuevo proceso podemos registrarlo en el sistema para darle un nombre.

Process.register(t_pid, :receiver)
data = [{:pid, t_pid} | Process.info(t_pid, [:memory, :status, :registered_name])]

Podemos mandar señales al hilo, lo que nos permite incluso mandar la señal para que el hilo muera.

Process.exit(t_pid, :normal)

Process.info(t_pid, [:memory, :status, :registered_name])

Aparte de poder comunicarnos con procesos, podemos realizar peticiones web e incluso llamadas rpc a procesos de elixir externos.

{:ok, %{body: img}} = HTTPoison.get("http://localhost:4000/identicon?word=ggggggg")
img

Para la llamada rpc tenemos que proporcionar el nombre del nodo al que queremos acceder. (La cookie configurada para ambos nodos es la misma)

node =
  Kino.Input.text("Node", [{:default, "app@RNTDELL000826"}])
  |> Kino.render()
  |> Kino.Input.read()
  |> String.to_atom()

:rpc.call(node, LiveIdenticon.Identicon.Generator, :generate, ["hla"])

Como vemos, el nombre del nodo de este livebook es diferente al de cualquier otro que tengamos en la máquina, pero si lo proporcionamos, podemos realizar llamas a código desarrollado en otro livebook.

node()

node =
  Kino.Input.text("Node")
  |> Kino.render()
  |> Kino.Input.read()
  |> String.to_atom()

:erpc.call(node, SomeCoolCode, :status, [])

:erpc.call(node, SomeCoolCode, :mem_usage, [])