CSC/ECE 517 Fall 2012/ch2b 2w-1w65 am: Difference between revisions

From Expertiza_Wiki
Jump to navigation Jump to search
Line 1: Line 1:
==Introduction==
==Introduction==
===Debugging in SaaS/Rails can be tricky===
This is a wiki article for the material presented in the Coursera SaaS video series, 3.13 Debugging by Dr. Armando Fox and Dr. David Patterson. We aim to cover all the material presented in the video with definitions and examples<br><br>
1) Some people are used to printing the error on the terminal(ex. Standard error). This may not be possible for a web application since its primary form of input and output is through HTTP requests and responses.
'''Why debugging in Rails can be tricky?'''<br>
*We are used to printing the error on the terminal in most applications(Example: STDERR). This may not be possible for a web application since its primary form of input and output is through HTTP requests and responses.


2)Errors early in flow might manifest itself late.
*Errors early in flow might manifest itself late.
For example,
Consider the following hierarchy seen in a Rails application:
Consider the following hierarchy:  
  URI -> Route -> Controller -> Model -> View -> Renderer
  URI -> Route -> Controller -> model -> view -> renderer
   
  Here, something that goes wrong in the controller might not manifest itself until the renderer. The root cause of the error might have happened a long time ago.
Here, something that goes wrong in the controller might not manifest itself until the renderer. The root cause of the error might have happened a long time ago.
3) Error can be hard to localize/reproduce if it affects only some users or routes.


There are several approaches that can be used for debugging on Saas depending on the mode of operation.
*Errors can be hard to localize/reproduce if it affects only some users or routes.


===Printing to terminal===
There are several approaches that can be used for debugging based on the mode of operation, that is development mode or production mode:
In development mode the user is the master and he can easily debug using this approach. This is not possible in production mode though.
'''Printing to terminal:'''This is useful for developers, when they are writing code they can print errors to the terminal and then examine them. We cannot use this approach in production mode.<br>


===Logging===
'''Logging:''' This is a more general approach to debugging which can be used in both modes. The logged entries are permanent record of what the application is doing. The recorded errors are saved in a log file and can be referenced later.<br>
This is a more general approach. The logged entries are permanent record of what your application is doing. The recorded errors can also be used to be referenced later. This approach can be used both in the development mode as well as the production mode.


===Interactive Debugging===
'''Interactive Debugging:''' Using this tool you can stop the application in its tracks and inspect the state of the variables or other parameters to locate the error.<br>
In this approach you can stop the application in its track and inspect the variables or other parameters to locate the error.
 
Here is a summary of the various approaches and the modes in which they can be used: <br>
{| class="wikitable"
|-
! Approach !! Development !! Production
|-
| Printing to Terminal || ✓ ||
|-
| Logging || ✓ || ✓
|-
| Interactive Debugging || ✓ ||
|}


==RASP==
==RASP==

Revision as of 23:00, 17 November 2012

Introduction

This is a wiki article for the material presented in the Coursera SaaS video series, 3.13 Debugging by Dr. Armando Fox and Dr. David Patterson. We aim to cover all the material presented in the video with definitions and examples

Why debugging in Rails can be tricky?

  • We are used to printing the error on the terminal in most applications(Example: STDERR). This may not be possible for a web application since its primary form of input and output is through HTTP requests and responses.
  • Errors early in flow might manifest itself late.

Consider the following hierarchy seen in a Rails application:

URI -> Route -> Controller -> Model -> View -> Renderer

Here, something that goes wrong in the controller might not manifest itself until the renderer. The root cause of the error might have happened a long time ago.

  • Errors can be hard to localize/reproduce if it affects only some users or routes.

There are several approaches that can be used for debugging based on the mode of operation, that is development mode or production mode:

Printing to terminal:This is useful for developers, when they are writing code they can print errors to the terminal and then examine them. We cannot use this approach in production mode.

Logging: This is a more general approach to debugging which can be used in both modes. The logged entries are permanent record of what the application is doing. The recorded errors are saved in a log file and can be referenced later.

Interactive Debugging: Using this tool you can stop the application in its tracks and inspect the state of the variables or other parameters to locate the error.

Here is a summary of the various approaches and the modes in which they can be used:

Approach Development Production
Printing to Terminal
Logging
Interactive Debugging

RASP

Tips to deal with an error

i) Read the error message carefully.

ii) Ask your colleague an informed question in case you are doing pair programming.

iii) Search using StackOverflow or Google Especially if its an error which is particular to a version of gems or OS

iv) Post on StackOverflow or class forum Get minimal but complete information which reproduces the error message which you are experiencing and post it.

Understanding Error Messages in Rails

Application Trace

Back Trace

Full Trace

Env Dump and Session Dump

Most Common Error Messages in Ruby

Interactive Debugger

What is an interactive debugger?

Conclusion

Further Reading

References

https://www.youtube.com/watch?v=Ee5vfe0mLb8