Consulta un proceso de Erlang para su estado?

Question

Un patrón común en Erlang es el bucle recursivo que mantiene el estado:

loop(State) -> 
    receive 
    Msg -> 
     NewState = whatever(Msg), 
     loop(NewState) 
    end. 

¿Hay alguna forma de consultar el estado de un proceso en ejecución con un bif o rastreo o algo? Dado que los mensajes de error dicen "... cuando el estado era ..." y muestran el estado del proceso estrellado, pensé que esto sería fácil, pero me decepcionó que no haya podido encontrar un bif para hacer esto.

Entonces, pensé que utilizar el rastreo del módulo dbg lo haría. Desafortunadamente, creo que debido a que estos bucles están optimizados para llamadas de cola, dbg solo capturará la primera llamada a la función.

¿Alguna solución?

Answer 1

Si su proceso utiliza OTP, es suficiente hacer sys:get_status(Pid).

El mensaje de error que menciona se muestra en SASL. SASL es un error que informa daemon en OTP.

El estado al que se refiere en su código de ejemplo es solo un argumento de la función recursiva de cola. No hay forma de extraerlo utilizando nada excepto para rastrear BIF. Supongo que esta no sería una solución adecuada en el código de producción, ya que el seguimiento está destinado a ser utilizado solo con fines de depuración.

La solución adecuada, y probada en la industria, haría un uso extensivo de OTP en su proyecto. A continuación, puede sacar el máximo provecho de los informes de errores SASL, rb módulo para recoger estos informes, sys - para inspeccionar el estado del proceso en ejecución OTP-compatibles, proc_lib - para que los procesos de corta duración OTP-compatible, etc.

Answer 2

Parece que estás solucionando el problema de la nada. erlang: process_info/1 proporciona suficiente información para la depuración. Si realmente necesita argumentos de función de bucle, ¿por qué no se los devuelve a la persona que llama en respuesta a uno de los mensajes especiales que usted mismo define?

ACTUALIZACIÓN: Solo para aclarar la terminología. Lo más parecido al "estado del proceso" en el nivel de idioma es el diccionario de proceso, cuyo uso es altamente desaconsejado. Puede ser consultado por erlang: process_info/1 o erlang: process/2. Lo que realmente necesita es rastrear las funciones locales de procesar las llamadas junto con sus argumentos:

-module(ping). 
-export([start/0, send/1, loop/1]).               

start() ->                     
    spawn(?MODULE, loop, [0]).                

send(Pid) ->                     
    Pid ! {self(), ping},                  
    receive                     
    pong ->                     
     pong                     
    end.                      

loop(S) ->                     
    receive                     
    {Pid, ping} ->                   
     Pid ! pong,                   
     loop(S + 1)                   
    end.                      

Consola:

Erlang (BEAM) emulator version 5.6.5 [source] [smp:2] [async-threads:0] [kernel-poll:false] 

Eshell V5.6.5 (abort with ^G)                
1> l(ping).                     
{module,ping}                     
2> erlang:trace(all, true, [call]).               
23                       
3> erlang:trace_pattern({ping, '_', '_'}, true, [local]).          
5                        
4> Pid = ping:start().                  
<0.36.0>                      
5> ping:send(Pid).                   
pong                       
6> flush().                     
Shell got {trace,<0.36.0>,call,{ping,loop,[0]}}            
Shell got {trace,<0.36.0>,call,{ping,loop,[1]}}            
ok                       
7>                       

Answer 3

Por lo que yo sé que usted no puede obtener los argumentos pasados ​​a una función llamada localmente. Me encantaría que alguien me probara mal.

-module(loop). 
-export([start/0, loop/1]). 
start() -> 
    spawn_link(fun() -> loop([]) end). 
loop(State) -> 
    receive 
    Msg -> 
     loop([Msg|State]) 
    end. 

Si queremos rastrear este módulo, haga lo siguiente en el shell.

dbg:tracer(). 
dbg:p(new,[c]).     
dbg:tpl(loop, []). 

uso de este ajuste se llega a ver el rastreo de llamadas locales (la 'L' en tpl significa que se pueden rastrear las llamadas locales, así, no sólo a los globales).

5> Pid = loop:start(). 
(<0.39.0>) call loop:'-start/0-fun-0-'/0 
(<0.39.0>) call loop:loop/1 
<0.39.0> 
6> Pid ! foo. 
(<0.39.0>) call loop:loop/1 
foo 

Como ves, solo las llamadas están incluidas. Sin argumentos a la vista.

Mi recomendación es basar la corrección en la eliminación de fallas y las pruebas en los mensajes enviados en lugar de mantener el estado en los procesos. Es decir. si envía un montón de mensajes al proceso, afirme que hace lo correcto, no que tenga un cierto conjunto de valores.

Pero, por supuesto, también puede rociar algunas llamadas erlang:display(State) temporalmente en su código. Pobre hombre está depurando.

Answer 4

{status,Pid,_,[_,_,_,_,[_,_,{data,[{_,State}]}]]} = sys:get_status(Pid). 

Eso es lo que uso para obtener el estado de un gen_server. (Intenté agregarlo como un comentario a la respuesta anterior, pero no pude obtener el formato correcto).

Answer 5

Este es un "delineador" que se puede usar en el caparazón.

sys:get_status(list_to_pid("<0.1012.0>")). 

Le ayuda a convertir una cadena pid en un Pid.

Answer 6

Resulta que hay una respuesta mejor que todos ellos, si está usando OTP:

sys:get_state/1

Probablemente no existía en el momento.