-
Notifications
You must be signed in to change notification settings - Fork 0
/
debugging_rails_applications.html
1150 lines (1057 loc) · 61.6 KB
/
debugging_rails_applications.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Debugging Rails Applications — Ruby on Rails Guides</title>
<link rel="stylesheet" type="text/css" href="stylesheets/style.css" data-turbolinks-track="reload">
<link rel="stylesheet" type="text/css" href="stylesheets/print.css" media="print">
<link rel="stylesheet" type="text/css" href="stylesheets/syntaxhighlighter/shCore.css" data-turbolinks-track="reload">
<link rel="stylesheet" type="text/css" href="stylesheets/syntaxhighlighter/shThemeRailsGuides.css" data-turbolinks-track="reload">
<link rel="stylesheet" type="text/css" href="stylesheets/fixes.css" data-turbolinks-track="reload">
<link href="images/favicon.ico" rel="shortcut icon" type="image/x-icon" />
<script src="javascripts/syntaxhighlighter.js" data-turbolinks-track="reload"></script>
<script src="javascripts/turbolinks.js" data-turbolinks-track="reload"></script>
<script src="javascripts/guides.js" data-turbolinks-track="reload"></script>
<script src="javascripts/responsive-tables.js" data-turbolinks-track="reload"></script>
<meta property="og:title" content="Debugging Rails Applications — Ruby on Rails Guides" />
<meta name="description" content="Debugging Rails ApplicationsThis guide introduces techniques for debugging Ruby on Rails applications.After reading this guide, you will know: The purpose of debugging. How to track down problems and issues in your application that your tests aren't identifying. The different ways of debugging. How to analyze the stack trace." />
<meta property="og:description" content="Debugging Rails ApplicationsThis guide introduces techniques for debugging Ruby on Rails applications.After reading this guide, you will know: The purpose of debugging. How to track down problems and issues in your application that your tests aren't identifying. The different ways of debugging. How to analyze the stack trace." />
<meta property="og:locale" content="en_US" />
<meta property="og:site_name" content="Ruby on Rails Guides" />
<meta property="og:image" content="https://avatars.githubusercontent.com/u/4223" />
<meta property="og:type" content="website" />
</head>
<body class="guide">
<div id="topNav">
<div class="wrapper">
<strong class="more-info-label">공식 웹사이트 <a href="https://rubyonrails.org/">rubyonrails.org:</a> </strong>
<span class="red-button more-info-button">
루비온레일스 웹사이트
</span>
<ul class="more-info-links s-hidden">
<li class="more-info"><a href="https://weblog.rubyonrails.org/">블로그</a></li>
<li class="more-info"><a href="https://guides.rubyonrails.org/">영문가이드</a></li>
<li class="more-info"><a href="https://api.rubyonrails.org/">레일스API</a></li>
<li class="more-info"><a href="https://stackoverflow.com/questions/tagged/ruby-on-rails">질문하기</a></li>
<li class="more-info"><a href="https://github.com/rails/rails">GitHub에서 기여하기</a></li>
</ul>
</div>
</div>
<div id="header">
<div class="wrapper clearfix">
<h1><a href="index.html" title="Return to home page">Guides.rubyonrails.org</a></h1>
<ul class="nav">
<li><a class="nav-item" href="index.html">홈</a></li>
<li class="guides-index guides-index-large">
<a href="index.html" id="guidesMenu" class="guides-index-item nav-item">가이드 인덱스</a>
<div id="guides" class="clearfix" style="display: none;">
<hr />
<div class="guides-section-container">
<div class="guides-section">
<dt>시작하면서</dt>
<dd><a href="getting_started.html">레일스로 시작하기</a></dd>
</div>
<div class="guides-section">
<dt>모델</dt>
<dd><a href="active_record_basics.html">액티브 레코드 기본</a></dd>
<dd><a href="active_record_migrations.html">액티브 레코드 마이그레이션</a></dd>
<dd><a href="active_record_validations.html">액티브 레코드 유효성 검증</a></dd>
<dd><a href="active_record_callbacks.html">액티브 레코드 콜백</a></dd>
<dd><a href="association_basics.html">Active Record Associations</a></dd>
<dd><a href="active_record_querying.html">Active Record Query Interface</a></dd>
</div>
<div class="guides-section">
<dt>Views</dt>
<dd><a href="layouts_and_rendering.html">Layouts and Rendering in Rails</a></dd>
<dd><a href="form_helpers.html">Action View Form Helpers</a></dd>
</div>
<div class="guides-section">
<dt>Controllers</dt>
<dd><a href="action_controller_overview.html">Action Controller Overview</a></dd>
<dd><a href="routing.html">Rails Routing from the Outside In</a></dd>
</div>
<div class="guides-section">
<dt>Other Components</dt>
<dd><a href="active_support_core_extensions.html">Active Support Core Extensions</a></dd>
<dd><a href="action_mailer_basics.html">Action Mailer Basics</a></dd>
<dd><a href="active_job_basics.html">Active Job Basics</a></dd>
<dd><a href="active_storage_overview.html">Active Storage Overview</a></dd>
<dd><a href="action_cable_overview.html">Action Cable Overview</a></dd>
</div>
<div class="guides-section">
<dt>Digging Deeper</dt>
<dd><a href="i18n.html">Rails Internationalization (I18n) API</a></dd>
<dd><a href="testing.html">Testing Rails Applications</a></dd>
<dd><a href="security.html">Securing Rails Applications</a></dd>
<dd><a href="debugging_rails_applications.html">Debugging Rails Applications</a></dd>
<dd><a href="configuring.html">Configuring Rails Applications</a></dd>
<dd><a href="command_line.html">The Rails Command Line</a></dd>
<dd><a href="asset_pipeline.html">The Asset Pipeline</a></dd>
<dd><a href="working_with_javascript_in_rails.html">Working with JavaScript in Rails</a></dd>
<dd><a href="autoloading_and_reloading_constants.html">Autoloading and Reloading Constants (Zeitwerk Mode)</a></dd>
<dd><a href="autoloading_and_reloading_constants_classic_mode.html">Autoloading and Reloading Constants (Classic Mode)</a></dd>
<dd><a href="caching_with_rails.html">Caching with Rails: An Overview</a></dd>
<dd><a href="api_app.html">Using Rails for API-only Applications</a></dd>
</div>
<div class="guides-section">
<dt>Extending Rails</dt>
<dd><a href="rails_on_rack.html">Rails on Rack</a></dd>
<dd><a href="generators.html">Creating and Customizing Rails Generators & Templates</a></dd>
</div>
<div class="guides-section">
<dt>Contributions</dt>
<dd><a href="contributing_to_ruby_on_rails.html">Contributing to Ruby on Rails</a></dd>
<dd><a href="api_documentation_guidelines.html">API Documentation Guidelines</a></dd>
<dd><a href="ruby_on_rails_guides_guidelines.html">Guides Guidelines</a></dd>
</div>
<div class="guides-section">
<dt>Policies</dt>
<dd><a href="maintenance_policy.html">Maintenance Policy</a></dd>
</div>
<div class="guides-section">
<dt>Release Notes</dt>
<dd><a href="upgrading_ruby_on_rails.html">Upgrading Ruby on Rails</a></dd>
<dd><a href="6_0_release_notes.html">Version 6.0 - August 2019</a></dd>
<dd><a href="5_2_release_notes.html">Version 5.2 - April 2018</a></dd>
<dd><a href="5_1_release_notes.html">Version 5.1 - April 2017</a></dd>
<dd><a href="5_0_release_notes.html">Version 5.0 - June 2016</a></dd>
<dd><a href="4_2_release_notes.html">Version 4.2 - December 2014</a></dd>
<dd><a href="4_1_release_notes.html">Version 4.1 - April 2014</a></dd>
<dd><a href="4_0_release_notes.html">Version 4.0 - June 2013</a></dd>
<dd><a href="3_2_release_notes.html">Version 3.2 - January 2012</a></dd>
<dd><a href="3_1_release_notes.html">Version 3.1 - August 2011</a></dd>
<dd><a href="3_0_release_notes.html">Version 3.0 - August 2010</a></dd>
<dd><a href="2_3_release_notes.html">Version 2.3 - March 2009</a></dd>
<dd><a href="2_2_release_notes.html">Version 2.2 - November 2008</a></dd>
</div>
</div>
</div>
</li>
<li><a class="nav-item" href="contributing_to_ruby_on_rails.html">기여하기</a></li>
<li class="guides-index guides-index-small">
<select class="guides-index-item nav-item">
<option value="index.html">가이드 인덱스</option>
<optgroup label="시작하면서">
<option value="getting_started.html">레일스로 시작하기</option>
</optgroup>
<optgroup label="모델">
<option value="active_record_basics.html">액티브 레코드 기본</option>
<option value="active_record_migrations.html">액티브 레코드 마이그레이션</option>
<option value="active_record_validations.html">액티브 레코드 유효성 검증</option>
<option value="active_record_callbacks.html">액티브 레코드 콜백</option>
<option value="association_basics.html">Active Record Associations</option>
<option value="active_record_querying.html">Active Record Query Interface</option>
</optgroup>
<optgroup label="Views">
<option value="layouts_and_rendering.html">Layouts and Rendering in Rails</option>
<option value="form_helpers.html">Action View Form Helpers</option>
</optgroup>
<optgroup label="Controllers">
<option value="action_controller_overview.html">Action Controller Overview</option>
<option value="routing.html">Rails Routing from the Outside In</option>
</optgroup>
<optgroup label="Other Components">
<option value="active_support_core_extensions.html">Active Support Core Extensions</option>
<option value="action_mailer_basics.html">Action Mailer Basics</option>
<option value="active_job_basics.html">Active Job Basics</option>
<option value="active_storage_overview.html">Active Storage Overview</option>
<option value="action_cable_overview.html">Action Cable Overview</option>
</optgroup>
<optgroup label="Digging Deeper">
<option value="i18n.html">Rails Internationalization (I18n) API</option>
<option value="testing.html">Testing Rails Applications</option>
<option value="security.html">Securing Rails Applications</option>
<option value="debugging_rails_applications.html">Debugging Rails Applications</option>
<option value="configuring.html">Configuring Rails Applications</option>
<option value="command_line.html">The Rails Command Line</option>
<option value="asset_pipeline.html">The Asset Pipeline</option>
<option value="working_with_javascript_in_rails.html">Working with JavaScript in Rails</option>
<option value="autoloading_and_reloading_constants.html">Autoloading and Reloading Constants (Zeitwerk Mode)</option>
<option value="autoloading_and_reloading_constants_classic_mode.html">Autoloading and Reloading Constants (Classic Mode)</option>
<option value="caching_with_rails.html">Caching with Rails: An Overview</option>
<option value="api_app.html">Using Rails for API-only Applications</option>
</optgroup>
<optgroup label="Extending Rails">
<option value="rails_on_rack.html">Rails on Rack</option>
<option value="generators.html">Creating and Customizing Rails Generators & Templates</option>
</optgroup>
<optgroup label="Contributions">
<option value="contributing_to_ruby_on_rails.html">Contributing to Ruby on Rails</option>
<option value="api_documentation_guidelines.html">API Documentation Guidelines</option>
<option value="ruby_on_rails_guides_guidelines.html">Guides Guidelines</option>
</optgroup>
<optgroup label="Policies">
<option value="maintenance_policy.html">Maintenance Policy</option>
</optgroup>
<optgroup label="Release Notes">
<option value="upgrading_ruby_on_rails.html">Upgrading Ruby on Rails</option>
<option value="6_0_release_notes.html">Version 6.0 - August 2019</option>
<option value="5_2_release_notes.html">Version 5.2 - April 2018</option>
<option value="5_1_release_notes.html">Version 5.1 - April 2017</option>
<option value="5_0_release_notes.html">Version 5.0 - June 2016</option>
<option value="4_2_release_notes.html">Version 4.2 - December 2014</option>
<option value="4_1_release_notes.html">Version 4.1 - April 2014</option>
<option value="4_0_release_notes.html">Version 4.0 - June 2013</option>
<option value="3_2_release_notes.html">Version 3.2 - January 2012</option>
<option value="3_1_release_notes.html">Version 3.1 - August 2011</option>
<option value="3_0_release_notes.html">Version 3.0 - August 2010</option>
<option value="2_3_release_notes.html">Version 2.3 - March 2009</option>
<option value="2_2_release_notes.html">Version 2.2 - November 2008</option>
</optgroup>
</select>
</li>
</ul>
</div>
</div>
<hr class="hide" />
<div id="feature">
<div class="wrapper">
<h2>Debugging Rails Applications</h2><p>This guide introduces techniques for debugging Ruby on Rails applications.</p><p>After reading this guide, you will know:</p>
<ul>
<li>The purpose of debugging.</li>
<li>How to track down problems and issues in your application that your tests aren't identifying.</li>
<li>The different ways of debugging.</li>
<li>How to analyze the stack trace.</li>
</ul>
<div id="subCol">
<h3 class="chapter"><img src="images/chapters_icon.gif" alt="" />Chapters</h3>
<ol class="chapters">
<li>
<a href="#view-helpers-for-debugging">View Helpers for Debugging</a>
<ul>
<li><a href="#debug"><code>debug</code></a></li>
<li><a href="#to-yaml"><code>to_yaml</code></a></li>
<li><a href="#inspect"><code>inspect</code></a></li>
</ul>
</li>
<li>
<a href="#the-logger">The Logger</a>
<ul>
<li><a href="#what-is-the-logger-questionmark">What is the Logger?</a></li>
<li><a href="#log-levels">Log Levels</a></li>
<li><a href="#sending-messages">Sending Messages</a></li>
<li><a href="#verbose-query-logs">Verbose Query Logs</a></li>
<li><a href="#tagged-logging">Tagged Logging</a></li>
<li><a href="#impact-of-logs-on-performance">Impact of Logs on Performance</a></li>
</ul>
</li>
<li>
<a href="#debugging-with-the-byebug-gem">Debugging with the <code>byebug</code> gem</a>
<ul>
<li><a href="#setup">Setup</a></li>
<li><a href="#the-shell">The Shell</a></li>
<li><a href="#the-context">The Context</a></li>
<li><a href="#threads">Threads</a></li>
<li><a href="#debugging-with-the-byebug-gem-inspecting-variables">Inspecting Variables</a></li>
<li><a href="#step-by-step">Step by Step</a></li>
<li><a href="#breakpoints">Breakpoints</a></li>
<li><a href="#catching-exceptions">Catching Exceptions</a></li>
<li><a href="#resuming-execution">Resuming Execution</a></li>
<li><a href="#editing">Editing</a></li>
<li><a href="#quitting">Quitting</a></li>
<li><a href="#debugging-with-the-byebug-gem-settings">Settings</a></li>
</ul>
</li>
<li>
<a href="#debugging-with-the-web-console-gem">Debugging with the <code>web-console</code> gem</a>
<ul>
<li><a href="#console">Console</a></li>
<li><a href="#debugging-with-the-web-console-gem-inspecting-variables">Inspecting Variables</a></li>
<li><a href="#debugging-with-the-web-console-gem-settings">Settings</a></li>
</ul>
</li>
<li>
<a href="#debugging-memory-leaks">Debugging Memory Leaks</a>
<ul>
<li><a href="#valgrind">Valgrind</a></li>
</ul>
</li>
<li><a href="#plugins-for-debugging">Plugins for Debugging</a></li>
<li><a href="#references">References</a></li>
</ol>
</div>
</div>
</div>
<div id="container">
<div class="wrapper">
<div id="mainCol">
<h3 id="view-helpers-for-debugging"><a class="anchorlink" href="#view-helpers-for-debugging">1 View Helpers for Debugging</a></h3><p>One common task is to inspect the contents of a variable. Rails provides three different ways to do this:</p>
<ul>
<li><code>debug</code></li>
<li><code>to_yaml</code></li>
<li><code>inspect</code></li>
</ul>
<h4 id="debug"><a class="anchorlink" href="#debug">1.1 <code>debug</code></a></h4><p>The <code>debug</code> helper will return a <pre> tag that renders the object using the YAML format. This will generate human-readable data from any object. For example, if you have this code in a view:</p><div class="code_container">
<pre class="brush: ruby; html-script: true; gutter: false; toolbar: false">
<%= debug @article %>
<p>
<b>Title:</b>
<%= @article.title %>
</p>
</pre>
</div>
<p>You'll see something like this:</p><div class="code_container">
<pre class="brush: plain; gutter: false; toolbar: false">
--- !ruby/object Article
attributes:
updated_at: 2008-09-05 22:55:47
body: It's a very helpful guide for debugging your Rails app.
title: Rails debugging guide
published: t
id: "1"
created_at: 2008-09-05 22:55:47
attributes_cache: {}
Title: Rails debugging guide
</pre>
</div>
<h4 id="to-yaml"><a class="anchorlink" href="#to-yaml">1.2 <code>to_yaml</code></a></h4><p>Alternatively, calling <code>to_yaml</code> on any object converts it to YAML. You can pass this converted object into the <code>simple_format</code> helper method to format the output. This is how <code>debug</code> does its magic.</p><div class="code_container">
<pre class="brush: ruby; html-script: true; gutter: false; toolbar: false">
<%= simple_format @article.to_yaml %>
<p>
<b>Title:</b>
<%= @article.title %>
</p>
</pre>
</div>
<p>The above code will render something like this:</p><div class="code_container">
<pre class="brush: plain; gutter: false; toolbar: false">
--- !ruby/object Article
attributes:
updated_at: 2008-09-05 22:55:47
body: It's a very helpful guide for debugging your Rails app.
title: Rails debugging guide
published: t
id: "1"
created_at: 2008-09-05 22:55:47
attributes_cache: {}
Title: Rails debugging guide
</pre>
</div>
<h4 id="inspect"><a class="anchorlink" href="#inspect">1.3 <code>inspect</code></a></h4><p>Another useful method for displaying object values is <code>inspect</code>, especially when working with arrays or hashes. This will print the object value as a string. For example:</p><div class="code_container">
<pre class="brush: ruby; html-script: true; gutter: false; toolbar: false">
<%= [1, 2, 3, 4, 5].inspect %>
<p>
<b>Title:</b>
<%= @article.title %>
</p>
</pre>
</div>
<p>Will render:</p><div class="code_container">
<pre class="brush: plain; gutter: false; toolbar: false">
[1, 2, 3, 4, 5]
Title: Rails debugging guide
</pre>
</div>
<h3 id="the-logger"><a class="anchorlink" href="#the-logger">2 The Logger</a></h3><p>It can also be useful to save information to log files at runtime. Rails maintains a separate log file for each runtime environment.</p><h4 id="what-is-the-logger-questionmark"><a class="anchorlink" href="#what-is-the-logger-questionmark">2.1 What is the Logger?</a></h4><p>Rails makes use of the <code>ActiveSupport::Logger</code> class to write log information. Other loggers, such as <code>Log4r</code>, may also be substituted.</p><p>You can specify an alternative logger in <code>config/application.rb</code> or any other environment file, for example:</p><div class="code_container">
<pre class="brush: ruby; gutter: false; toolbar: false">
config.logger = Logger.new(STDOUT)
config.logger = Log4r::Logger.new("Application Log")
</pre>
</div>
<p>Or in the <code>Initializer</code> section, add <em>any</em> of the following</p><div class="code_container">
<pre class="brush: ruby; gutter: false; toolbar: false">
Rails.logger = Logger.new(STDOUT)
Rails.logger = Log4r::Logger.new("Application Log")
</pre>
</div>
<div class="info"><p>By default, each log is created under <code>Rails.root/log/</code> and the log file is named after the environment in which the application is running.</p></div><h4 id="log-levels"><a class="anchorlink" href="#log-levels">2.2 Log Levels</a></h4><p>When something is logged, it's printed into the corresponding log if the log
level of the message is equal to or higher than the configured log level. If you
want to know the current log level, you can call the <code>Rails.logger.level</code>
method.</p><p>The available log levels are: <code>:debug</code>, <code>:info</code>, <code>:warn</code>, <code>:error</code>, <code>:fatal</code>,
and <code>:unknown</code>, corresponding to the log level numbers from 0 up to 5,
respectively. To change the default log level, use</p><div class="code_container">
<pre class="brush: ruby; gutter: false; toolbar: false">
config.log_level = :warn # In any environment initializer, or
Rails.logger.level = 0 # at any time
</pre>
</div>
<p>This is useful when you want to log under development or staging without flooding your production log with unnecessary information.</p><div class="info"><p>The default Rails log level is <code>debug</code> in all environments.</p></div><h4 id="sending-messages"><a class="anchorlink" href="#sending-messages">2.3 Sending Messages</a></h4><p>To write in the current log use the <code>logger.(debug|info|warn|error|fatal|unknown)</code> method from within a controller, model, or mailer:</p><div class="code_container">
<pre class="brush: ruby; gutter: false; toolbar: false">
logger.debug "Person attributes hash: #{@person.attributes.inspect}"
logger.info "Processing the request..."
logger.fatal "Terminating application, raised unrecoverable error!!!"
</pre>
</div>
<p>Here's an example of a method instrumented with extra logging:</p><div class="code_container">
<pre class="brush: ruby; gutter: false; toolbar: false">
class ArticlesController < ApplicationController
# ...
def create
@article = Article.new(article_params)
logger.debug "New article: #{@article.attributes.inspect}"
logger.debug "Article should be valid: #{@article.valid?}"
if @article.save
logger.debug "The article was saved and now the user is going to be redirected..."
redirect_to @article, notice: 'Article was successfully created.'
else
render :new
end
end
# ...
private
def article_params
params.require(:article).permit(:title, :body, :published)
end
end
</pre>
</div>
<p>Here's an example of the log generated when this controller action is executed:</p><div class="code_container">
<pre class="brush: plain; gutter: false; toolbar: false">
Started POST "/articles" for 127.0.0.1 at 2018-10-18 20:09:23 -0400
Processing by ArticlesController#create as HTML
Parameters: {"utf8"=>"✓", "authenticity_token"=>"XLveDrKzF1SwaiNRPTaMtkrsTzedtebPPkmxEFIU0ordLjICSnXsSNfrdMa4ccyBjuGwnnEiQhEoMN6H1Gtz3A==", "article"=>{"title"=>"Debugging Rails", "body"=>"I'm learning how to print in logs.", "published"=>"0"}, "commit"=>"Create Article"}
New article: {"id"=>nil, "title"=>"Debugging Rails", "body"=>"I'm learning how to print in logs.", "published"=>false, "created_at"=>nil, "updated_at"=>nil}
Article should be valid: true
(0.0ms) begin transaction
↳ app/controllers/articles_controller.rb:31
Article Create (0.5ms) INSERT INTO "articles" ("title", "body", "published", "created_at", "updated_at") VALUES (?, ?, ?, ?, ?) [["title", "Debugging Rails"], ["body", "I'm learning how to print in logs."], ["published", 0], ["created_at", "2018-10-19 00:09:23.216549"], ["updated_at", "2018-10-19 00:09:23.216549"]]
↳ app/controllers/articles_controller.rb:31
(2.3ms) commit transaction
↳ app/controllers/articles_controller.rb:31
The article was saved and now the user is going to be redirected...
Redirected to http://localhost:3000/articles/1
Completed 302 Found in 4ms (ActiveRecord: 0.8ms)
</pre>
</div>
<p>Adding extra logging like this makes it easy to search for unexpected or unusual behavior in your logs. If you add extra logging, be sure to make sensible use of log levels to avoid filling your production logs with useless trivia.</p><h4 id="verbose-query-logs"><a class="anchorlink" href="#verbose-query-logs">2.4 Verbose Query Logs</a></h4><p>When looking at database query output in logs, it may not be immediately clear why multiple database queries are triggered when a single method is called:</p><div class="code_container">
<pre class="brush: plain; gutter: false; toolbar: false">
irb(main):001:0> Article.pamplemousse
Article Load (0.4ms) SELECT "articles".* FROM "articles"
Comment Load (0.2ms) SELECT "comments".* FROM "comments" WHERE "comments"."article_id" = ? [["article_id", 1]]
Comment Load (0.1ms) SELECT "comments".* FROM "comments" WHERE "comments"."article_id" = ? [["article_id", 2]]
Comment Load (0.1ms) SELECT "comments".* FROM "comments" WHERE "comments"."article_id" = ? [["article_id", 3]]
=> #<Comment id: 2, author: "1", body: "Well, actually...", article_id: 1, created_at: "2018-10-19 00:56:10", updated_at: "2018-10-19 00:56:10">
</pre>
</div>
<p>After running <code>ActiveRecord::Base.verbose_query_logs = true</code> in the <code>rails console</code> session to enable verbose query logs and running the method again, it becomes obvious what single line of code is generating all these discrete database calls:</p><div class="code_container">
<pre class="brush: plain; gutter: false; toolbar: false">
irb(main):003:0> Article.pamplemousse
Article Load (0.2ms) SELECT "articles".* FROM "articles"
↳ app/models/article.rb:5
Comment Load (0.1ms) SELECT "comments".* FROM "comments" WHERE "comments"."article_id" = ? [["article_id", 1]]
↳ app/models/article.rb:6
Comment Load (0.1ms) SELECT "comments".* FROM "comments" WHERE "comments"."article_id" = ? [["article_id", 2]]
↳ app/models/article.rb:6
Comment Load (0.1ms) SELECT "comments".* FROM "comments" WHERE "comments"."article_id" = ? [["article_id", 3]]
↳ app/models/article.rb:6
=> #<Comment id: 2, author: "1", body: "Well, actually...", article_id: 1, created_at: "2018-10-19 00:56:10", updated_at: "2018-10-19 00:56:10">
</pre>
</div>
<p>Below each database statement you can see arrows pointing to the specific source filename (and line number) of the method that resulted in a database call. This can help you identify and address performance problems caused by N+1 queries: single database queries that generates multiple additional queries.</p><p>Verbose query logs are enabled by default in the development environment logs after Rails 5.2.</p><div class="warning"><p>We recommend against using this setting in production environments. It relies on Ruby's <code>Kernel#caller</code> method which tends to allocate a lot of memory in order to generate stacktraces of method calls.</p></div><h4 id="tagged-logging"><a class="anchorlink" href="#tagged-logging">2.5 Tagged Logging</a></h4><p>When running multi-user, multi-account applications, it's often useful
to be able to filter the logs using some custom rules. <code>TaggedLogging</code>
in Active Support helps you do exactly that by stamping log lines with subdomains, request ids, and anything else to aid debugging such applications.</p><div class="code_container">
<pre class="brush: ruby; gutter: false; toolbar: false">
logger = ActiveSupport::TaggedLogging.new(Logger.new(STDOUT))
logger.tagged("BCX") { logger.info "Stuff" } # Logs "[BCX] Stuff"
logger.tagged("BCX", "Jason") { logger.info "Stuff" } # Logs "[BCX] [Jason] Stuff"
logger.tagged("BCX") { logger.tagged("Jason") { logger.info "Stuff" } } # Logs "[BCX] [Jason] Stuff"
</pre>
</div>
<h4 id="impact-of-logs-on-performance"><a class="anchorlink" href="#impact-of-logs-on-performance">2.6 Impact of Logs on Performance</a></h4><p>Logging will always have a small impact on the performance of your Rails app,
particularly when logging to disk. Additionally, there are a few subtleties:</p><p>Using the <code>:debug</code> level will have a greater performance penalty than <code>:fatal</code>,
as a far greater number of strings are being evaluated and written to the
log output (e.g. disk).</p><p>Another potential pitfall is too many calls to <code>Logger</code> in your code:</p><div class="code_container">
<pre class="brush: ruby; gutter: false; toolbar: false">
logger.debug "Person attributes hash: #{@person.attributes.inspect}"
</pre>
</div>
<p>In the above example, there will be a performance impact even if the allowed
output level doesn't include debug. The reason is that Ruby has to evaluate
these strings, which includes instantiating the somewhat heavy <code>String</code> object
and interpolating the variables.
Therefore, it's recommended to pass blocks to the logger methods, as these are
only evaluated if the output level is the same as — or included in — the allowed level
(i.e. lazy loading). The same code rewritten would be:</p><div class="code_container">
<pre class="brush: ruby; gutter: false; toolbar: false">
logger.debug {"Person attributes hash: #{@person.attributes.inspect}"}
</pre>
</div>
<p>The contents of the block, and therefore the string interpolation, are only
evaluated if debug is enabled. This performance savings are only really
noticeable with large amounts of logging, but it's a good practice to employ.</p><h3 id="debugging-with-the-byebug-gem"><a class="anchorlink" href="#debugging-with-the-byebug-gem">3 Debugging with the <code>byebug</code> gem</a></h3><p>When your code is behaving in unexpected ways, you can try printing to logs or
the console to diagnose the problem. Unfortunately, there are times when this
sort of error tracking is not effective in finding the root cause of a problem.
When you actually need to journey into your running source code, the debugger
is your best companion.</p><p>The debugger can also help you if you want to learn about the Rails source code
but don't know where to start. Just debug any request to your application and
use this guide to learn how to move from the code you have written into the
underlying Rails code.</p><h4 id="setup"><a class="anchorlink" href="#setup">3.1 Setup</a></h4><p>You can use the <code>byebug</code> gem to set breakpoints and step through live code in
Rails. To install it, just run:</p><div class="code_container">
<pre class="brush: plain; gutter: false; toolbar: false">
$ gem install byebug
</pre>
</div>
<p>Inside any Rails application you can then invoke the debugger by calling the
<code>byebug</code> method.</p><p>Here's an example:</p><div class="code_container">
<pre class="brush: ruby; gutter: false; toolbar: false">
class PeopleController < ApplicationController
def new
byebug
@person = Person.new
end
end
</pre>
</div>
<h4 id="the-shell"><a class="anchorlink" href="#the-shell">3.2 The Shell</a></h4><p>As soon as your application calls the <code>byebug</code> method, the debugger will be
started in a debugger shell inside the terminal window where you launched your
application server, and you will be placed at the debugger's prompt <code>(byebug)</code>.
Before the prompt, the code around the line that is about to be run will be
displayed and the current line will be marked by '=>', like this:</p><div class="code_container">
<pre class="brush: plain; gutter: false; toolbar: false">
[1, 10] in /PathTo/project/app/controllers/articles_controller.rb
3:
4: # GET /articles
5: # GET /articles.json
6: def index
7: byebug
=> 8: @articles = Article.find_recent
9:
10: respond_to do |format|
11: format.html # index.html.erb
12: format.json { render json: @articles }
(byebug)
</pre>
</div>
<p>If you got there by a browser request, the browser tab containing the request
will be hung until the debugger has finished and the trace has finished
processing the entire request.</p><p>For example:</p><div class="code_container">
<pre class="brush: plain; gutter: false; toolbar: false">
=> Booting Puma
=> Rails 5.1.0 application starting in development on http://0.0.0.0:3000
=> Run `rails server -h` for more startup options
Puma starting in single mode...
* Version 3.4.0 (ruby 2.3.1-p112), codename: Owl Bowl Brawl
* Min threads: 5, max threads: 5
* Environment: development
* Listening on tcp://localhost:3000
Use Ctrl-C to stop
Started GET "/" for 127.0.0.1 at 2014-04-11 13:11:48 +0200
ActiveRecord::SchemaMigration Load (0.2ms) SELECT "schema_migrations".* FROM "schema_migrations"
Processing by ArticlesController#index as HTML
[3, 12] in /PathTo/project/app/controllers/articles_controller.rb
3:
4: # GET /articles
5: # GET /articles.json
6: def index
7: byebug
=> 8: @articles = Article.find_recent
9:
10: respond_to do |format|
11: format.html # index.html.erb
12: format.json { render json: @articles }
(byebug)
</pre>
</div>
<p>Now it's time to explore your application. A good place to start is
by asking the debugger for help. Type: <code>help</code></p><div class="code_container">
<pre class="brush: plain; gutter: false; toolbar: false">
(byebug) help
break -- Sets breakpoints in the source code
catch -- Handles exception catchpoints
condition -- Sets conditions on breakpoints
continue -- Runs until program ends, hits a breakpoint or reaches a line
debug -- Spawns a subdebugger
delete -- Deletes breakpoints
disable -- Disables breakpoints or displays
display -- Evaluates expressions every time the debugger stops
down -- Moves to a lower frame in the stack trace
edit -- Edits source files
enable -- Enables breakpoints or displays
finish -- Runs the program until frame returns
frame -- Moves to a frame in the call stack
help -- Helps you using byebug
history -- Shows byebug's history of commands
info -- Shows several informations about the program being debugged
interrupt -- Interrupts the program
irb -- Starts an IRB session
kill -- Sends a signal to the current process
list -- Lists lines of source code
method -- Shows methods of an object, class or module
next -- Runs one or more lines of code
pry -- Starts a Pry session
quit -- Exits byebug
restart -- Restarts the debugged program
save -- Saves current byebug session to a file
set -- Modifies byebug settings
show -- Shows byebug settings
source -- Restores a previously saved byebug session
step -- Steps into blocks or methods one or more times
thread -- Commands to manipulate threads
tracevar -- Enables tracing of a global variable
undisplay -- Stops displaying all or some expressions when program stops
untracevar -- Stops tracing a global variable
up -- Moves to a higher frame in the stack trace
var -- Shows variables and its values
where -- Displays the backtrace
(byebug)
</pre>
</div>
<p>To see the previous ten lines you should type <code>list-</code> (or <code>l-</code>).</p><div class="code_container">
<pre class="brush: plain; gutter: false; toolbar: false">
(byebug) l-
[1, 10] in /PathTo/project/app/controllers/articles_controller.rb
1 class ArticlesController < ApplicationController
2 before_action :set_article, only: [:show, :edit, :update, :destroy]
3
4 # GET /articles
5 # GET /articles.json
6 def index
7 byebug
8 @articles = Article.find_recent
9
10 respond_to do |format|
</pre>
</div>
<p>This way you can move inside the file and see the code above the line where you
added the <code>byebug</code> call. Finally, to see where you are in the code again you can
type <code>list=</code></p><div class="code_container">
<pre class="brush: plain; gutter: false; toolbar: false">
(byebug) list=
[3, 12] in /PathTo/project/app/controllers/articles_controller.rb
3:
4: # GET /articles
5: # GET /articles.json
6: def index
7: byebug
=> 8: @articles = Article.find_recent
9:
10: respond_to do |format|
11: format.html # index.html.erb
12: format.json { render json: @articles }
(byebug)
</pre>
</div>
<h4 id="the-context"><a class="anchorlink" href="#the-context">3.3 The Context</a></h4><p>When you start debugging your application, you will be placed in different
contexts as you go through the different parts of the stack.</p><p>The debugger creates a context when a stopping point or an event is reached. The
context has information about the suspended program which enables the debugger
to inspect the frame stack, evaluate variables from the perspective of the
debugged program, and know the place where the debugged program is stopped.</p><p>At any time you can call the <code>backtrace</code> command (or its alias <code>where</code>) to print
the backtrace of the application. This can be very helpful to know how you got
where you are. If you ever wondered about how you got somewhere in your code,
then <code>backtrace</code> will supply the answer.</p><div class="code_container">
<pre class="brush: plain; gutter: false; toolbar: false">
(byebug) where
--> #0 ArticlesController.index
at /PathToProject/app/controllers/articles_controller.rb:8
#1 ActionController::BasicImplicitRender.send_action(method#String, *args#Array)
at /PathToGems/actionpack-5.1.0/lib/action_controller/metal/basic_implicit_render.rb:4
#2 AbstractController::Base.process_action(action#NilClass, *args#Array)
at /PathToGems/actionpack-5.1.0/lib/abstract_controller/base.rb:181
#3 ActionController::Rendering.process_action(action, *args)
at /PathToGems/actionpack-5.1.0/lib/action_controller/metal/rendering.rb:30
...
</pre>
</div>
<p>The current frame is marked with <code>--></code>. You can move anywhere you want in this
trace (thus changing the context) by using the <code>frame n</code> command, where <em>n</em> is
the specified frame number. If you do that, <code>byebug</code> will display your new
context.</p><div class="code_container">
<pre class="brush: plain; gutter: false; toolbar: false">
(byebug) frame 2
[176, 185] in /PathToGems/actionpack-5.1.0/lib/abstract_controller/base.rb
176: # is the intended way to override action dispatching.
177: #
178: # Notice that the first argument is the method to be dispatched
179: # which is *not* necessarily the same as the action name.
180: def process_action(method_name, *args)
=> 181: send_action(method_name, *args)
182: end
183:
184: # Actually call the method associated with the action. Override
185: # this method if you wish to change how action methods are called,
(byebug)
</pre>
</div>
<p>The available variables are the same as if you were running the code line by
line. After all, that's what debugging is.</p><p>You can also use <code>up [n]</code> and <code>down [n]</code> commands in order to change the context
<em>n</em> frames up or down the stack respectively. <em>n</em> defaults to one. Up in this
case is towards higher-numbered stack frames, and down is towards lower-numbered
stack frames.</p><h4 id="threads"><a class="anchorlink" href="#threads">3.4 Threads</a></h4><p>The debugger can list, stop, resume, and switch between running threads by using
the <code>thread</code> command (or the abbreviated <code>th</code>). This command has a handful of
options:</p>
<ul>
<li>
<code>thread</code>: shows the current thread.</li>
<li>
<code>thread list</code>: is used to list all threads and their statuses. The current
thread is marked with a plus (+) sign.</li>
<li>
<code>thread stop n</code>: stops thread <em>n</em>.</li>
<li>
<code>thread resume n</code>: resumes thread <em>n</em>.</li>
<li>
<code>thread switch n</code>: switches the current thread context to <em>n</em>.</li>
</ul>
<p>This command is very helpful when you are debugging concurrent threads and need
to verify that there are no race conditions in your code.</p><h4 id="debugging-with-the-byebug-gem-inspecting-variables"><a class="anchorlink" href="#debugging-with-the-byebug-gem-inspecting-variables">3.5 Inspecting Variables</a></h4><p>Any expression can be evaluated in the current context. To evaluate an
expression, just type it!</p><p>This example shows how you can print the instance variables defined within the
current context:</p><div class="code_container">
<pre class="brush: plain; gutter: false; toolbar: false">
[3, 12] in /PathTo/project/app/controllers/articles_controller.rb
3:
4: # GET /articles
5: # GET /articles.json
6: def index
7: byebug
=> 8: @articles = Article.find_recent
9:
10: respond_to do |format|
11: format.html # index.html.erb
12: format.json { render json: @articles }
(byebug) instance_variables
[:@_action_has_layout, :@_routes, :@_request, :@_response, :@_lookup_context,
:@_action_name, :@_response_body, :@marked_for_same_origin_verification,
:@_config]
</pre>
</div>
<p>As you may have figured out, all of the variables that you can access from a
controller are displayed. This list is dynamically updated as you execute code.
For example, run the next line using <code>next</code> (you'll learn more about this
command later in this guide).</p><div class="code_container">
<pre class="brush: plain; gutter: false; toolbar: false">
(byebug) next
[5, 14] in /PathTo/project/app/controllers/articles_controller.rb
5 # GET /articles.json
6 def index
7 byebug
8 @articles = Article.find_recent
9
=> 10 respond_to do |format|
11 format.html # index.html.erb
12 format.json { render json: @articles }
13 end
14 end
15
(byebug)
</pre>
</div>
<p>And then ask again for the instance_variables:</p><div class="code_container">
<pre class="brush: plain; gutter: false; toolbar: false">
(byebug) instance_variables
[:@_action_has_layout, :@_routes, :@_request, :@_response, :@_lookup_context,
:@_action_name, :@_response_body, :@marked_for_same_origin_verification,
:@_config, :@articles]
</pre>
</div>
<p>Now <code>@articles</code> is included in the instance variables, because the line defining
it was executed.</p><div class="info"><p>You can also step into <strong>irb</strong> mode with the command <code>irb</code> (of course!).
This will start an irb session within the context you invoked it.</p></div><p>The <code>var</code> method is the most convenient way to show variables and their values.
Let's have <code>byebug</code> help us with it.</p><div class="code_container">
<pre class="brush: plain; gutter: false; toolbar: false">
(byebug) help var
[v]ar <subcommand>
Shows variables and its values
var all -- Shows local, global and instance variables of self.
var args -- Information about arguments of the current scope
var const -- Shows constants of an object.
var global -- Shows global variables.
var instance -- Shows instance variables of self or a specific object.
var local -- Shows local variables in current scope.
</pre>
</div>
<p>This is a great way to inspect the values of the current context variables. For
example, to check that we have no local variables currently defined:</p><div class="code_container">
<pre class="brush: plain; gutter: false; toolbar: false">
(byebug) var local
(byebug)
</pre>
</div>
<p>You can also inspect for an object method this way:</p><div class="code_container">
<pre class="brush: plain; gutter: false; toolbar: false">
(byebug) var instance Article.new
@_start_transaction_state = {}
@aggregation_cache = {}
@association_cache = {}
@attributes = #<ActiveRecord::AttributeSet:0x007fd0682a9b18 @attributes={"id"=>#<ActiveRecord::Attribute::FromDatabase:0x007fd0682a9a00 @name="id", @value_be...
@destroyed = false
@destroyed_by_association = nil
@marked_for_destruction = false
@new_record = true
@readonly = false
@transaction_state = nil
</pre>
</div>
<p>You can also use <code>display</code> to start watching variables. This is a good way of
tracking the values of a variable while the execution goes on.</p><div class="code_container">
<pre class="brush: plain; gutter: false; toolbar: false">
(byebug) display @articles
1: @articles = nil
</pre>
</div>
<p>The variables inside the displayed list will be printed with their values after
you move in the stack. To stop displaying a variable use <code>undisplay n</code> where
<em>n</em> is the variable number (1 in the last example).</p><h4 id="step-by-step"><a class="anchorlink" href="#step-by-step">3.6 Step by Step</a></h4><p>Now you should know where you are in the running trace and be able to print the
available variables. But let's continue and move on with the application
execution.</p><p>Use <code>step</code> (abbreviated <code>s</code>) to continue running your program until the next
logical stopping point and return control to the debugger. <code>next</code> is similar to
<code>step</code>, but while <code>step</code> stops at the next line of code executed, doing just a
single step, <code>next</code> moves to the next line without descending inside methods.</p><p>For example, consider the following situation:</p><div class="code_container">
<pre class="brush: plain; gutter: false; toolbar: false">
Started GET "/" for 127.0.0.1 at 2014-04-11 13:39:23 +0200
Processing by ArticlesController#index as HTML
[1, 6] in /PathToProject/app/models/article.rb
1: class Article < ApplicationRecord
2: def self.find_recent(limit = 10)
3: byebug
=> 4: where('created_at > ?', 1.week.ago).limit(limit)
5: end
6: end
(byebug)
</pre>
</div>
<p>If we use <code>next</code>, we won't go deep inside method calls. Instead, <code>byebug</code> will
go to the next line within the same context. In this case, it is the last line
of the current method, so <code>byebug</code> will return to the next line of the caller
method.</p><div class="code_container">
<pre class="brush: plain; gutter: false; toolbar: false">
(byebug) next
[4, 13] in /PathToProject/app/controllers/articles_controller.rb
4: # GET /articles
5: # GET /articles.json
6: def index
7: @articles = Article.find_recent
8:
=> 9: respond_to do |format|
10: format.html # index.html.erb
11: format.json { render json: @articles }
12: end
13: end
(byebug)
</pre>
</div>
<p>If we use <code>step</code> in the same situation, <code>byebug</code> will literally go to the next
Ruby instruction to be executed -- in this case, Active Support's <code>week</code> method.</p><div class="code_container">
<pre class="brush: plain; gutter: false; toolbar: false">
(byebug) step
[49, 58] in /PathToGems/activesupport-5.1.0/lib/active_support/core_ext/numeric/time.rb
49:
50: # Returns a Duration instance matching the number of weeks provided.
51: #
52: # 2.weeks # => 14 days
53: def weeks
=> 54: ActiveSupport::Duration.weeks(self)
55: end
56: alias :week :weeks
57:
58: # Returns a Duration instance matching the number of fortnights provided.
(byebug)
</pre>
</div>
<p>This is one of the best ways to find bugs in your code.</p><div class="info"><p>You can also use <code>step n</code> or <code>next n</code> to move forward <code>n</code> steps at once.</p></div><h4 id="breakpoints"><a class="anchorlink" href="#breakpoints">3.7 Breakpoints</a></h4><p>A breakpoint makes your application stop whenever a certain point in the program
is reached. The debugger shell is invoked in that line.</p><p>You can add breakpoints dynamically with the command <code>break</code> (or just <code>b</code>).
There are 3 possible ways of adding breakpoints manually:</p>
<ul>
<li>
<code>break n</code>: set breakpoint in line number <em>n</em> in the current source file.</li>
<li>
<code>break file:n [if expression]</code>: set breakpoint in line number <em>n</em> inside
file named <em>file</em>. If an <em>expression</em> is given it must evaluated to <em>true</em> to
fire up the debugger.</li>
<li>
<code>break class(.|\#)method [if expression]</code>: set breakpoint in <em>method</em> (. and
# for class and instance method respectively) defined in <em>class</em>. The
<em>expression</em> works the same way as with file:n.</li>
</ul>
<p>For example, in the previous situation</p><div class="code_container">
<pre class="brush: plain; gutter: false; toolbar: false">
[4, 13] in /PathToProject/app/controllers/articles_controller.rb
4: # GET /articles
5: # GET /articles.json
6: def index
7: @articles = Article.find_recent
8:
=> 9: respond_to do |format|
10: format.html # index.html.erb
11: format.json { render json: @articles }
12: end
13: end
(byebug) break 11
Successfully created breakpoint with id 1
</pre>
</div>
<p>Use <code>info breakpoints</code> to list breakpoints. If you supply a number, it lists
that breakpoint. Otherwise it lists all breakpoints.</p><div class="code_container">
<pre class="brush: plain; gutter: false; toolbar: false">
(byebug) info breakpoints
Num Enb What
1 y at /PathToProject/app/controllers/articles_controller.rb:11
</pre>
</div>
<p>To delete breakpoints: use the command <code>delete n</code> to remove the breakpoint
number <em>n</em>. If no number is specified, it deletes all breakpoints that are
currently active.</p><div class="code_container">
<pre class="brush: plain; gutter: false; toolbar: false">
(byebug) delete 1
(byebug) info breakpoints
No breakpoints.
</pre>
</div>
<p>You can also enable or disable breakpoints:</p>
<ul>
<li>
<code>enable breakpoints [n [m [...]]]</code>: allows a specific breakpoint list or all
breakpoints to stop your program. This is the default state when you create a
breakpoint.</li>
<li>
<code>disable breakpoints [n [m [...]]]</code>: make certain (or all) breakpoints have
no effect on your program.</li>
</ul>
<h4 id="catching-exceptions"><a class="anchorlink" href="#catching-exceptions">3.8 Catching Exceptions</a></h4><p>The command <code>catch exception-name</code> (or just <code>cat exception-name</code>) can be used to
intercept an exception of type <em>exception-name</em> when there would otherwise be no
handler for it.</p><p>To list all active catchpoints use <code>catch</code>.</p><h4 id="resuming-execution"><a class="anchorlink" href="#resuming-execution">3.9 Resuming Execution</a></h4><p>There are two ways to resume execution of an application that is stopped in the
debugger:</p>
<ul>
<li>
<code>continue [n]</code>: resumes program execution at the address where your script last
stopped; any breakpoints set at that address are bypassed. The optional argument
<code>n</code> allows you to specify a line number to set a one-time breakpoint which is
deleted when that breakpoint is reached.</li>
<li>
<code>finish [n]</code>: execute until the selected stack frame returns. If no frame
number is given, the application will run until the currently selected frame
returns. The currently selected frame starts out the most-recent frame or 0 if
no frame positioning (e.g up, down, or frame) has been performed. If a frame
number is given it will run until the specified frame returns.</li>
</ul>
<h4 id="editing"><a class="anchorlink" href="#editing">3.10 Editing</a></h4><p>Two commands allow you to open code from the debugger into an editor:</p>
<ul>
<li>
<code>edit [file:n]</code>: edit file named <em>file</em> using the editor specified by the
EDITOR environment variable. A specific line <em>n</em> can also be given.</li>
</ul>