debug é o depurador padrão do Ruby. O Rails a coloca nos grupos development e test do Gemfile de toda nova aplicação. Se você ainda depura com puts, ela já está instalada.
O que ela faz e as instruções de impressão não conseguem fazer é deixar você manter sua posição. Você para uma vez e então explora: lê o código-fonte, adiciona mais pontos de interrupção, executa até eles e sobe de volta pela pilha de chamadas. Tudo isso sem editar um arquivo ou reiniciar.
O que este artigo cobre
- Três formas de entrar em uma sessão de depuração.
- Navegar pelo código com
step,nextecontinue. - Adicionar pontos de interrupção durante a sessão, inclusive em outros arquivos.
- Percorrer a pilha de chamadas com
backtrace,up,downeframe.
Requisitos
Para um projeto que não a tem:
Entrando em uma sessão
Três pontos de entrada, todos colocados na linha onde você quer parar.
O prompt informa onde você está:
irb para o IRB, rdbg para o depurador.
O terceiro importa porque binding.irb é um hábito difícil de abandonar. Se a gem debug estiver presente, você pode executar qualquer comando do depurador a partir de uma sessão do IRB. Isso leva você para o depurador e executa o comando. Você nunca precisa voltar e mudar a linha.
Recuperando a orientação
Dois comandos para executar quando você perder a noção de onde parou:whereamiimprime as 10 linhas em torno do ponto de interrupção.list(oul) imprime o código-fonte e aceita um intervalo:list 22-28.
help lista todos os comandos, agrupados pelo que fazem. help backtrace explica um deles.
Entrar pelo binding.irb também dá acesso ao show_source do próprio IRB, que imprime o código-fonte de uma constante ou método sem que você saia da sessão:
Navegando pelo código
Três comandos, e a diferença entre os dois primeiros é o ponto principal.
Em uma linha que chama um método,
step leva você para dentro desse método. Continue avançando passo a passo e, eventualmente, você estará dentro do próprio Rails, lendo o código-fonte do Active Record na mesma sessão. next executa a linha inteira e para na linha seguinte.
Use step quando suspeitar da chamada. Use next quando já a tiver descartado.
Adicionando pontos de interrupção sem saltar da sessão
break sozinho lista os pontos de interrupção que você já definiu. Com um argumento, ele adiciona um.
continue executa até chegar lá. A alternativa é parar, editar um arquivo, reiniciar e avançar passo a passo de volta até onde você estava. Isso custa o estado que você tinha construído, e a linha de raciocínio junto com ele.
Percorrendo a pilha de chamadas
backtrace (ou bt) lista os frames, cada um com um índice.
upmove para o frame que fez a chamada.downmove de volta em direção a onde você parou.frame 12(ouf 12) salta direto para um frame específico.
up se move para números de índice maiores, o que se lê ao contrário em relação à lista impressa, até que você tenha feito isso uma vez.
Em qualquer frame, list mostra o código-fonte daquele frame, e info mostra suas variáveis. info locals restringe isso às variáveis locais. Ficar no frame de quem fez a chamada costuma ser mais rápido do que avançar passo a passo para ver o que um método recebeu. A partir dali, leia os argumentos que ele passou.
Depurando o que você não consegue reproduzir
Tudo o que foi visto até aqui precisa de um ponto de interrupção, que precisa que o problema aconteça enquanto você observa. Falhas em produção não cooperam. O AppSignal preenche essa lacuna, e os dois fluxos de trabalho se complementam:- O rastreamento de erros captura a exceção, seu backtrace e a requisição que a causou, esteja alguém observando ou não.
- Os traces de performance mostram a chamada como ela aconteceu, com os tempos. Um trace é o mais próximo de um
backtracepara uma requisição que já terminou. - O Time Detective mostra o que o resto da aplicação estava fazendo enquanto o trace acontecia. Um ponto de interrupção não pode dar isso a você depois do fato.
- Os parâmetros de requisição e os dados personalizados colocam os valores na issue. É isso que
info localsdá a você localmente, e costuma ser a peça que falta para reproduzir algo. - Uma exceção capturada por um
rescuesimples nunca chega ao Rails, então nada a reporta automaticamente. Reporte-a você mesmo com o tratamento de exceções, ou capture-a comRails.error.handle, que o AppSignal reporta por padrão.
Transcrição
Transcrito do vídeo e levemente editado. A legendagem automática entendeu errado vários nomes de produtos e de APIs, e esses foram corrigidos.Ler a transcrição
Ler a transcrição
0:02 - Olá a todos, bem-vindos de volta a mais um episódio aqui do GoRails. No episódio desta semana, vamos ver como depurar melhor usando a gem debug do Ruby. Então essa é uma gem que você vai precisar instalar, ou pode adicionar ao seu Gemfile se estiver trabalhando com um projeto que tenha um Gemfile. E uma coisa boa é que, com uma nova aplicação Rails, se você criar uma, como acabei de fazer aqui, criei uma nova aplicação Rails chamada Blah. Se eu abrir isso e formos ver o Gemfile, vamos ver, se procurarmos por debug aqui, vamos ver que a gem debug é adicionada ao seu Gemfile por padrão no Rails, nos grupos development e test, o que é ótimo.0:50 Isso vai nos dar a possibilidade de entrar em uma sessão de depuração usando essa gem e percorrer nosso código e fazer algumas coisas bem interessantes para depurar nossas aplicações. Certo, então eu tenho aqui nossa aplicação do hackathon, e vamos brincar um pouco com a gem debug aqui e ter uma noção de alguns dos comandos que temos acesso e como usá-los e como eles podem afetar a forma como rastreamos nosso código aqui. Então, para entrar em uma sessão de depuração, temos algumas opções de como chegar lá. A primeira coisa que podemos fazer, vamos descer até esse método current, ou esse método latest aqui nessa classe Event. Se eu simplesmente entrar na primeira linha, esse método aqui, uma coisa que podemos fazer é digitar
binding.irb, talvez você já conheça binding.irb.1:43 E isso, quando atingirmos esse ponto de interrupção, vamos entrar em uma sessão do IRB, mas então, uma vez nessa sessão, podemos então executar o comando debug ou qualquer um dos outros comandos que estão na gem debug, e isso vai nos fazer cair em uma sessão ou prompt de console do Ruby debug aqui. Então vamos olhar isso primeiro. Vou salvar isso e ir para outra aba do terminal aqui, e vou apenas entrar na console em modo sandbox. Perdoem-me por usar um alias aqui. Se vocês virem ali em cima, eu sei que provavelmente está pequeno para ler, mas aqui em cima vocês podem ver o que RCS significa aqui.2:21 Ele apenas executa bin rails console dash S. Então você entra em modo sandbox ali, é o meu pequeno alias do shell. De qualquer forma, aqui eu vou apenas digitar event e então chamar esse método de classe latest aqui. Se apertarmos enter aqui, vemos que atingimos esse ponto de interrupção do binding.irb, mas o prompt aqui reflete que estamos no IRB, certo? Então o que podemos fazer aqui, para entrar no prompt do Ruby debug, é simplesmente digitar debug, certo?2:52 Se fizermos isso, vemos que nosso prompt agora muda para RDBG. E isso agora indica para nós que estamos aqui na console do Ruby debug. Então, com isso feito, o que podemos fazer aqui agora? Uma coisa que podemos fazer, vou apenas limpar essa console enquanto ainda permanecemos na console do Ruby debug. Vou apenas limpar o terminal aqui para termos espaço para trabalhar.3:16 Uma coisa que podemos fazer é usar o comando show_cmds aqui, apertar enter, e então podemos ver uma lista de todos os comandos disponíveis que temos acesso nessa sessão aqui. Então, olhando alguns desses comandos aqui, temos alguns comandos do IRB, temos alguns comandos de depuração, alguns comandos diversos, alguns comandos de contexto, e assim por diante. Então vamos começar a olhar alguns dos que acho mais úteis de conhecer. A primeira coisa, essa também é um comando disponível no IRB, mas é o comando whereami. Se você algum dia esquecer onde colocou o ponto de interrupção e como o código em volta se parece, você pode digitar esse comando, e ele vai trazer isso de volta e mostrar as 10 linhas em torno de onde esse ponto de interrupção está.3:58 Então vemos aqui, dizendo 13 a 22 nesse arquivo aqui. Então ele mostra 10 linhas, mais ou menos cinco, em torno de onde esse ponto de interrupção está. Então é assim que sempre podemos trazer esse contexto de volta sem ter que rolar por aí, ou se limparmos o terminal, podemos recuperar esse contexto de onde estamos nessa sessão aqui. Então whereami é ótimo de se ter. Também, outro que é bom aqui é o comando list.4:28 Agora, muitos dos comandos disponíveis na gem Ruby debug têm abreviações. Então, para list, você pode simplesmente digitar L, ou pode digitar a palavra completa list. E uma coisa que você pode fazer é dar a ele um intervalo de números de linha. Por exemplo, agora só conseguimos ver de 13 a 22, se eu quisesse ver como 22 até, digamos, 28 se parece, uma coisa que posso fazer é digitar list ou digitar L, vou apenas digitar list por agora e dizer 22 traço 28. Certo.5:05 Agora apertamos enter aqui. Agora vemos as linhas que pedimos desse arquivo, exatamente de 22 a 28. Então o comando list é ótimo. Então um dos outros que eu realmente gosto é o comando show_source. Então podemos dizer show_source e depois dar a ele, sabe, uma string como uma constante que queremos consultar.5:22 Pode ser uma constante, podemos passar um método que queremos ver, mas vou apenas fazer essa constante event por agora, mostrando. Então show_source event, apertamos enter aqui. Podemos ver todo, opa, podemos ver todo o código-fonte dessa classe event aqui. Simplesmente chamando isso. Então nunca precisamos saltar dessa sessão de console aqui e voltar para nosso editor para relembrar essa informação.5:48 Além disso, também podemos consultar apenas, sabe, o código-fonte do nosso método. Vamos olhar isso agora. Vamos ver se quiséssemos ver, sabe, como o código-fonte do método to-param aqui se parece. E ainda não tínhamos isso aberto. Vamos ver como fazer isso.6:03 Então, se quiséssemos consultar o método to-param, poderíamos dizer show_source e depois dar a ele a string event. E então podemos usar o cerquilha porque está no nosso símbolo hash, desculpe. Podemos usar esse símbolo, ou isso, para indicar que queremos consultar o método de instância to-param, certo? Então vamos dizer hash to-param, fechar nossa string, apertar enter. E agora vemos o código-fonte do método to-param.6:27 Se quiséssemos consultar o método de classe current, então poderíamos dizer show_source e depois dizer event. E então poderíamos fazer os dois pontos e depois current, aqui mesmo, fechar nossa string. Agora vemos o código-fonte do método de classe current, certo? E ainda estamos nessa sessão do Ruby debug. Nunca precisamos saltar dessa console e voltar para nosso código-fonte.6:54 Podemos fazer tudo isso a partir daqui. Então isso é interessante. Um dos meus, um dos outros comandos que eu realmente gosto, é apenas o comando info. Se digitarmos info aqui mesmo, podemos ver, sabe, uma grande lista de informações. Essas são, sabe, todas as variáveis e variáveis de instância e outras coisas que temos disponíveis agora no contexto em que estamos.7:11 Então podemos, sabe, pegar isso, por exemplo. Podemos pegar at generated associated methods, certo? Podemos copiar isso. E isso aponta para um objeto aqui, onde estão os métodos disponíveis nesse objeto. Então podemos dizer at generated associated methods ponto methods ponto sort, por exemplo, e antes de executar isso, vou apenas limpar a console, apertar enter.7:34 E agora vemos todos os métodos disponíveis nesse objeto ali, certo? Então isso é muito interessante. E, de novo, se você esquecer onde está, fazendo alguns experimentos, o que quer que seja. Lembre-se, whereami? E você pode ver onde está atualmente.7:46 Agora que recuperamos nosso contexto, vamos olhar outro comando disponível para nós. O comando step. Olhando a documentação aqui, o comando step, você pode simplesmente dizer step por si só, ou dar a ele um número. E isso, o comando step permite que você entre no código. Eu penso nisso como entrar nos pontos de execução ao longo do programa.8:13 Então você pode fazer step, sabe, apenas um passo, múltiplos passos, e chega ao próximo, como dizem aqui, próximo ponto interrompível. Se fizermos um step onde estamos agora, agora estamos na zona 18 aqui. Se dissermos step sem número, vemos que damos um step para a próxima linha aqui, mas começamos no início da linha aqui. Então, agora, esse método atual ainda não foi chamado, e também, sabe, a outra metade dessa condicional ainda não foi executada. Então estamos meio que no início dessa linha aqui antes que qualquer outra coisa aconteça.8:50 Agora, se dermos step de novo, vamos ver que terminamos dentro do método current agora, certo? Então demos um step, estávamos bem aqui. Na linha 19, no início aqui, entramos nessa chamada aqui para current. Então isso meio que dá um step para esse próximo ponto de execução, é como eu gosto de pensar nisso. Então agora estamos aqui, certo?9:12 E então você pode fazer coisas aqui e brincar com esse código aqui, se quiser, sabe, você pode apenas ver, ah, o que first up publish me dá, sabe, antes de chamar esse order e assim por diante, certo? Agora o que é divertido aqui é que, se você continuar dando step em um certo ponto, pelo menos nesse caso aqui chamando esses métodos de classe aqui, damos step de novo, vemos que descemos agora para o código-fonte do Active Record scoping named.rb, certo? Então agora estamos dentro de algum código-fonte do Rails aqui, no qual entramos dando step usando debug e o comando step para navegar pela execução ou pontos interrompíveis, como dizem, no código aqui. Então você pode continuar essa jornada aqui e dar step e step, e vai apenas continuar, sabe, para os próximos pontos interrompíveis, o próximo ponto, e assim por diante, se você quiser, sabe, seguir com seu programa, parar de dar step assim e continuar até dizer o próximo ponto de interrupção que você definiu, se ele, sabe, cair no caminho de execução aqui, ou apenas continuar seu programa, e se não houver outros pontos de interrupção, apenas ir até terminar, você pode digitar continue ou con para abreviar, mas vou apenas fazer a forma longa aqui, continue, vamos apertar continue e então vemos que nosso programa vai até o fim, ele pega esse latest event, e agora estamos de volta na sessão do IRB, então saímos da sessão de depuração e agora estamos de volta na sessão do IRB. Então vou saltar da sessão do IRB aqui e voltar para a console, e vamos atingir nosso ponto de interrupção de novo e olhar algumas outras coisas.10:49 Então aqui estamos de novo, de volta ao nosso ponto de interrupção, também tem o comando next. Se olharmos a documentação lá para next, em contraste com step onde ele entra dentro, next passa por cima e vai retomar o programa até a próxima linha. Então vamos ver o que acontece usando next aqui. Então estamos na linha 18 bem aqui, se damos step para next, vemos que estamos na próxima linha. Certo, isso foi parecido com o que fizemos com step, certo?11:18 Então vamos para o próximo ponto bem aqui, certo, o próximo ponto interrompível, e estamos no início aqui, current não foi chamado, nem previous, mas enquanto da última vez, quando demos step, terminamos no método current, vamos ver o que acontece quando damos next aqui. Então vemos aqui que ele passou por cima, certo? Toda essa linha aqui, ele executou essa linha de código e então passou para a próxima linha. Então não pegamos todos os detalhes, se preferir, do método current e depois do Active Record, certo? Passamos por cima daquela linha toda, ela fez sua função, e agora estamos na próxima linha, que por acaso, para nós, é o fim dessa definição de método aqui.12:05 Certo, então vou saltar dessa sessão e então vou voltar para nossa console Rails aqui, e vou atingir nosso ponto de interrupção de novo chamando event ponto latest, certo. E agora estivemos usando binding.irb e depois entrando na sessão do Ruby debug chamando comandos da gem Ruby debug. Então essa é uma forma de chegar lá. Se você usa binding.irb e depois chama um dos comandos de debug, ele vai automaticamente executar esse comando e colocar você em, ou colocar isso, colocar você em, vai automaticamente colocar você naquela sessão de depuração e executar esse comando que você usou. Se você não quiser executar um comando e apenas quiser entrar na sessão de depuração, você pode simplesmente digitar debug, certo.12:52 E isso vai levá-lo à sessão de depuração. E se você digitar whereami, vai ver que ainda está no mesmo lugar no código, certo? Estamos bem aqui. Além disso, vemos uma lista de alguns frames aqui, e vamos chegar em frames em um segundo. Mas é assim que você pode entrar no depurador, através da, ou da gem Ruby debug através do IRB ou binding.irb.13:19 Alternativamente, se saímos daqui, temos algumas outras opções. Então também podemos fazer binding.b, certo. E se entrarmos de novo na nossa console, nossa console Rails, e atingirmos aquele ponto de interrupção criado por binding.b, vamos ver que caímos imediatamente em uma sessão de depuração. Pulamos a parte do IRB e vamos direto para o debug. Então esse é um método que vem da gem debug.13:46 Essa é uma forma curta de binding.break. Então você pode digitar binding.break, a palavra completa break aqui, ou pode apenas fazer binding.b para abreviar. Então essa é uma forma de ir direto para a sessão do depurador e não ter que fazer binding.irb. Mas se, sabe, binding.irb é o hábito difícil de abandonar. Se você tem a gem debug na sua aplicação, ainda pode entrar nela através de binding.irb.14:11 Vamos olhar outra forma de entrar nisso rapidamente. Então podemos fazer bind ponto IRB, binding.b, e assim por diante, a outra coisa que podemos fazer é chamar debugger, exatamente assim, certo. Agora, se voltarmos para nossa console Rails, e então fizermos event ponto latest, vemos que atingimos então o debugger aqui, e, de novo, caímos direto em uma sessão de depuração. Então essas são suas formas de entrar na gem debug, certo? Agora, vamos olhar o comando break, porque esse é muito interessante.14:46 Então, com o comando break por si só, também é B para abreviar, mas vou usar a forma longa aqui. break por si só, se você apertar enter nisso, vai apenas retornar uma lista de todos os pontos de interrupção que você definiu, se os tiver definido. Não temos nenhum agora. No entanto, uma coisa interessante aqui é que você pode definir pontos de interrupção adicionais de dentro dessa sessão aqui, certo? Então digamos que quiséssemos adicionar um ponto de interrupção depois da linha 22 aqui, certo?15:15 Então, na linha 23, queremos adicionar um ponto de interrupção. Então o que podemos fazer é dizer break ou B, e então simplesmente 23, certo? E agora você vê que obtemos essa saída aqui, linha do ponto de interrupção, e em qual arquivo estava, e então qual linha, certo? Então agora, se digitarmos o comando break aqui, vamos ver essa mesma saída. Então agora temos um ponto de interrupção definido.15:37 E agora, se quiséssemos saltar direto de onde estamos, desde que o próximo ponto de interrupção que definimos esteja no caminho de execução do nosso programa, o que podemos fazer é digitar continue, certo? E vai executar a partir de onde estamos no nosso programa atualmente na linha 18 aqui, onde esse debugger foi definido, e vai passar pelo nosso programa até atingirmos outro ponto de interrupção, o que no nosso caso vai acontecer, porque na próxima linha bem aqui chamamos current, e definimos um ponto de interrupção dentro daquele método na linha 23. Apertamos continue aqui. Vemos que o código executa até o fim, e para bem ali no início da linha 23 aqui em current. Então isso é realmente interessante.16:16 Sabe, você pode definir pontos de interrupção adicionais e chegar até eles, sabe, desde que estejam no caminho de execução, você pode continuar até eles, e continuar atingindo-os e adicionando-os conforme necessário, sem ter que saltar dessa sessão, voltar para seu código-fonte, colocar um novo ponto de interrupção onde quiser, executar tudo de novo, atingi-los todos de novo, e assim por diante. Você pode apenas permanecer, sabe, no mesmo contexto aqui, sem quebrar seu foco, e trabalhar para depurar algo. Você também não está limitado a definir pontos de interrupção adicionais apenas no arquivo atual em que está. Então vamos olhar isso a seguir. Certo, então digamos que estamos depurando algo em torno dessa chamada de método aqui, esse método full, certo?16:56 Alguma coisa está acontecendo, não sabemos bem o quê, só queremos atingir um debugger aqui e começar a depurar essa coisa, certo? Então vamos colocar um debugger ali, e então vamos entrar na nossa console Rails aqui, e então vamos apenas dizer team igual a team.first para começar aqui, e então vamos apenas dizer team.full, ponto de interrogação, certo? E atingimos nosso ponto de interrupção do debugger, estamos em uma sessão de depurador agora, certo? E agora queremos adicionar, vemos que eles chamam esse método at or above capacity em team users. Então o que podemos fazer agora, se sabemos, sabemos que isso está no arquivo team user, não sabemos em qual linha está, se soubéssemos em qual linha estava, uma coisa que poderíamos fazer é dizer, e eu apenas sei aqui que é a linha 16, já verifiquei, voltando aqui, uma coisa que podemos fazer é adicionar um ponto de interrupção nesse arquivo e nessa linha, então poderíamos dizer break, e então precisamos passar o caminho para o arquivo, isso vai ser longo, então tenham paciência, talvez eu avance rápido aqui, app, models, team, user, e então dois pontos 16, certo?18:02 Então adicionamos um ponto de interrupção nesse arquivo e nessa linha, e agora, se fôssemos digitar continue ou cont para abreviar, C-O-N-T, apertamos enter aqui, vemos que nosso programa executou até chegarmos naquele ponto de interrupção aqui, que definimos, certo? Agora, provavelmente poderíamos ter usado step para dar step por tudo isso e chegar aqui também, mas eu só queria mostrar um exemplo de como você pode definir pontos de interrupção em outros arquivos. Agora, uma coisa interessante que você pode fazer aqui é que, em vez desse caminho aqui e de passar um número de linha, você pode simplesmente passar a classe e o método e definir um ponto de interrupção dessa forma, então vamos ver rapidamente como fazer isso. Certo, de volta, entrando em outra sessão de console Rails aqui, digamos team igual a team.first de novo, certo? E então vamos dizer team.full, vamos atingir isso, um ponto de interrupção do debugger, e agora queremos definir um ponto de interrupção de onde estamos atualmente nesse método lá na classe team user.19:05 Poderíamos fazer isso como vimos, passando o caminho para aquele arquivo e o número da linha, mas digamos que não sabemos o número da linha, e não queremos voltar para nosso editor, abrir aquele arquivo, e adicionar o ponto de interrupção lá, porque se vamos fazer isso mesmo, poderíamos apenas adicionar o debugger enquanto estamos bem ali e reiniciar todo esse processo, mas estamos tentando manter nosso contexto aqui e não perder nosso foco no que estamos fazendo agora. Queremos ficar no ritmo e no caminho certo e continuar tentando depurar algo aqui. Então o que podemos fazer aqui, se não sabemos o número da linha, podemos combinar com a classe e o nome do método. Como esse é um método de classe aqui em team user, podemos simplesmente dizer break on team user ponto at or above capacity, ponto de interrogação, certo, e então podemos apertar enter nisso, e então vemos que esse ponto de interrupção em um método foi chamado, e vemos que foi adicionado ao arquivo team user na linha 16, certo, e como vimos antes, essa era exatamente a linha em que esse método está definido. Então agora, se apertarmos continue aqui, ou cont C-O-N-T para abreviar aqui, se apertarmos enter, nosso programa vai continuar até atingir esse próximo ponto de interrupção.20:26 Então fazemos isso, e vemos, lá estamos. Estamos no início aqui desse método aqui. Estamos dentro do corpo do método, no início dessa linha. Certo, então vamos encerrar esse vídeo olhando frames, certo. Estou de volta na console Rails aqui.20:39 Peguei a primeira team. Vou apenas chamar team.full para atingirmos nosso ponto de interrupção de novo. Certo, agora estamos em uma sessão de depurador. Então o que podemos fazer, como você pode ver bem aqui, ele nos mostra os primeiros dois frames aqui e depois diz em 27 frames, e depois diz use BT para todos os frames. Então o comando BT vai listar todos os frames que temos acesso agora.21:06 Vou apenas abrir um pouco de espaço aqui no nosso terminal, e então vamos executar esse comando BT e ver o que obtemos ali. Também, BT é apenas a abreviação de back trace. Como você pode ver aqui, estamos obtendo um autocompletar. Então você pode digitar a palavra completa back trace ou BT para obter essa lista aqui. E o que vemos aqui, quando executamos esse comando, é que obtemos uma lista de todos os frames que temos agora.21:31 É essencialmente um stack trace aqui, certo? Então esse é o frame em que estamos, onde atingimos nosso ponto de interrupção. E então isso é tudo o que aconteceu antes de atingirmos esse ponto de interrupção, certo? Então o que podemos fazer aqui é usar esses identificadores ou números de ID no início aqui, o, sabe, cerquilha zero, cerquilha um, ou hash um, hash dois. Podemos usar esses para saltar direto para um frame, ou podemos avançar um por um.22:03 Então a forma de, se quisermos apenas ir, isso vai ser um pouco estranho. Se estivermos olhando essa lista, pensaríamos que queremos ir aqui para baixo, mas na verdade o que você quer fazer é usar o comando up para subir um frame, e apenas pense que qualquer que seja o frame atual em que você esteja, up vai incrementá-lo para, sabe, o próximo número maior, certo? Então, se estamos aqui e queremos ir para main, podemos simplesmente digitar o comando up. E agora vemos que nosso frame atual é main bem aqui. Se digitarmos L ou list aqui mesmo, vemos algum código-fonte para o frame atual, certo?22:39 Agora, se quisermos voltar para o frame de onde acabamos de vir, podemos digitar down. Então, se descermos, podemos ver que estamos de volta aqui nesse frame, e de novo, podemos digitar list para ver o código-fonte, e vemos o código-fonte bem aqui para esse frame atual. Além disso, podemos saltar para um frame em particular. Por exemplo, se quisermos ir para esse frame aqui, frame 12, podemos digitar F e então o número identificador, que é 12 no nosso caso, ou o comando completo, que é frame, e então 12, certo? E agora vemos que estamos no frame 12, que é esse arquivo do IRB aqui.23:23 E se digitarmos L ou list, podemos ver o código-fonte para esse frame aqui. Então isso é um recurso muito interessante. Ele permite que você suba e desça pelo stack trace e veja coisas em diferentes contextos de frame. E, de novo, uma vez que você está em um frame, você pode digitar list, como tenho feito, para ver o código-fonte. Você também pode digitar info para ver as, sabe, variáveis locais, variáveis de instância e outras coisas disponíveis que você tem nesse contexto.23:52 Então isso também é bem interessante. Sabe, info é ótimo. Também existem alguns argumentos que você pode passar para o comando info. Você pode encontrar mais informações sobre isso no readme da gem debug. Mas, por exemplo, você pode dizer info locals, e ele vai apenas te dar de volta as variáveis locais, e não todo o resto.24:14 Uma última coisa, se você estiver na sessão de depuração e não conseguir lembrar dos comandos ou do que pode fazer aqui, existe uma opção help. Você pode simplesmente digitar help, e ele vai te dar uma lista de todos os comandos disponíveis que você tem dentro da sessão de depuração aqui, com uns cabeçalhos bem legais separando as diferentes seções de comandos, comandos de ponto de interrupção, comandos de fluxo de controle, e assim por diante. E, além disso, como você vê aqui, você pode simplesmente digitar help, obter a lista completa, ou help, e então algum comando, e obter ajuda só para esse comando. Por exemplo, digamos help back trace, certo? E então vemos as informações para todos os comandos back trace.24:53 Então, com isso, vou encerrar esse vídeo aqui. Espero que isso tenha exposto vocês a algumas coisas novas que vocês têm, novas ferramentas que vocês podem usar e ter à disposição para ajudar melhor na depuração de erros de aplicação. Também, isso foi meio que uma abordagem introdutória a essa gem, tem bastante mais para ler no readme, muitas coisas poderosas aqui. Minha esperança, não me citem nisso, mas vou tentar. Meu objetivo é fazer um vídeo de acompanhamento aqui, espero que com alguém dos mantenedores dessa gem, e ver se conseguimos fazer um vídeo juntos e talvez explorar alguns dos usos mais avançados dessa gem e fornecer esse próximo nível de depuração.25:47 Então vamos ver o que acontece aí. Vou tentar o meu melhor para conseguir alguém do time aqui para se juntar a mim em uma chamada de vídeo e explorar essas coisas, mas de qualquer forma, definitivamente usem essa gem. Ela é ótima, é realmente poderosa. E é isso, então vou deixar vocês aqui, e boa depuração.Tutoriais relacionados
Sobre este tutorial
Este tutorial resume um screencast da GoRails sobre depuração com a gemdebug do Ruby, apresentado por Collin. O screencast é a obra original. A GoRails o publica, junto com o restante da série, em gorails.com.