In this tutorial, we will learn about logging. The contents will be:<\/p>\n
- \n
- What is Logging?<\/li>\n
- Python Logging Module<\/li>\n
- Logging in Django<\/li>\n<\/ul>\n
Ready to learn. Let\u2019s get started.<\/p>\n
What is Logging?<\/h4>\n
Logging is a technique or medium which can let us track some events as the software executes. It is an important technique for developers. It helps them to track events. Logging is like an extra set of eyes for them. Developers are not only responsible for making software but also for maintaining them.<\/p>\n
Logging helps with that part of maintenance immensely.<\/p>\n
It tracks every event that occurs at all times. That means instead of the long tracebacks you get much more. This time when an error occurs you can see in which the system was. This method will help you resolve errors quickly. As you will be able to tell where the error occurred.<\/p>\n
How does it work? What\u2019s the idea behind it?<\/strong><\/p>\n
The logging is handled by a separate program. That logging program is simply a file-writer. The logger is said to record certain events in text format. The recorded information is then saved in files. The files for this are called logs.<\/p>\n
The logs are simple files saved with log extension. They contain the logs of events occurred.<\/p>\n
Well, this is just one of the most used implementations, as you can see. Since we are just storing the information, you can come up with more ways to deal with it.<\/p>\n
Okay, it\u2019s clear to us that logging is important. Is it difficult? No absolutely not buddy. Logging is not difficult at all. Anyone who knows a little bit about the setup can use this.<\/p>\n
Being a Python programmer, you get extra features here too. We got a whole module that lets us accomplish just that. As for other languages, there are many modules, Java has Log4j and JavaScript<\/strong><\/em> has its own loglevel. All these are amazing tools as well.<\/p>\n
Okay, so we will be dealing with Python (my favorite Language) here.<\/p>\n
Logging Module in Python<\/h4>\n
The logging module is a built-in Python module. It comes preinstalled with Python 3. Logging module is used to keep track of the events that occur as the program runs. That can be extended to any number of programs and thus for software, it is easy to set up and use.<\/p>\n
Why use logging module?<\/h4>\n
As a developer, we can ask why use the logging module. All logging does is writing to a file or printing it on the console. All that can be achieved by using print statements. Then what is the need for a logging module?. That\u2019s a valid question. The answer to that is logging is a module that gives what print cannot.<\/p>\n
We use print function to output something on console. So, when a function occurs, we can get a print statement that the function executed. While that approach works with smaller applications, it is inefficient.<\/p>\n
Print function becomes part of your program and if the software stops working, you won\u2019t get the result. Also, if anything occurs and system restarts, the console is also clear. So, what will you do then? The answer to that is logging module.<\/p>\n
The logging module is capable of:<\/p>\n
- \n
- Multithreading execution<\/li>\n
- Categorizing Messages via different log levels<\/li>\n
- It’s much more flexible and configurable<\/li>\n
- Gives a more structured information<\/li>\n<\/ul>\n
So, there are 4 main parts of logging module. We will look at them one by one.<\/p>\n
1. Loggers<\/h4>\n
The loggers are the objects that developers deal with. They can be understood as a function which will be invoked when they are called. We use loggers in our project files. Thus, when the function is invoked, we get a detailed report. The logger can generate multiple levels of responses.<\/p>\n
We can customize it to full extent.<\/p>\n
2. Handlers<\/h4>\n
Handlers are the objects which emit the information. Think of them as newspaper handlers. Their main task is to transmit the information. That can be achieved by writing the info in a log file (The default behaviour). There are various handlers provided by logging module.<\/p>\n
We can easily set-up multiple handlers for the same logger. There are SMTP Handlers too which will mail the log records to you. The handlers usually contain business logic for logging information.<\/p>\n
3. Formatters<\/h4>\n
The formatters are the ones which format the data. You see handlers cannot send the information as it\u2019s a Python data type<\/strong><\/em>. Before it can be sent to anyone, it needs to be converted.<\/p>\n
The logs are by-default in Log Records format. That is the class pre-defined by logging framework. It gives various methods to developers to use. That format can not be directly sent over a network or written in a text file. To convert that or format that, we need formatters.<\/p>\n
There are different formatters for different handlers.<\/p>\n
By default, the formatters will convert the Log Record into String. This behaviour can be easily changed and you can customize this as you want. This format can be based on the business logic that we write in Handlers.<\/p>\n
4. Filters<\/h4>\n
The last piece of the logging module is filters. The filters, as the name suggests, filter the messages. Not every message we pass needs to be stored or transported. Or there can be different handlers for different messages. All that is achievable with the help of filters.<\/p>\n
We can use filters with both loggers and handlers.<\/p>\n
Okay, so now we have got a basic idea of the logging module. It also provides us with message levels. The message levels are defined as:<\/p>\n
DEBUG:<\/strong> It is verbose system information when everything is running fine. It will tell you more precise details about the state of the system. Its severity point is 10.<\/p>\n
INFO:<\/strong> The info will produce less verbose system information but is similar to debug. It generally tells an overview of what the system is executing. Its severity point is 20.<\/p>\n
WARNING:<\/strong> This contains information regarding low-level problems. The problems may be ignored as they don\u2019t cause the system to halt. Although, it is recommended that these problems shall be resolved.<\/p>\n
Its severity point is 30.<\/p>\n
ERROR:<\/strong> This message is serious. The error will contain information about the major problem that has occurred. The problem may have stopped the operation of program and needs immediate attention.<\/p>\n
Its severity point is 40.<\/p>\n
CRITICAL:<\/strong> The most critical message. This message is emitted when the problem has caused the system to stop. That means the whole application has halted due to this problem.<\/p>\n
Its severity point is 50.<\/p>\n
The severity point determines what priority shall be given. Suppose, we set the log level to be 30. Then the logger will log or store the information when the level is greater than or equal to 30. So, you just need to confirm what level of logging you want. We will learn more about them in the further section.<\/p>\n
We can easily implement logging by importing the module. Since it\u2019s a built-in module, we need not install it via pip.<\/p>\n
Just write this in your Python file<\/strong> <\/em>and we can use loggers.<\/p>\n
Code:<\/strong><\/p>\n
import logging\r\nlogging.warning(\"DataFlair Logging Tutorials\")<\/pre>\n
![\"import](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2019\/11\/import-logging-output.png\")
<\/a><\/p>\nThe output generated by the code is right below. As you can see, the log is printed on the console, it has log-level<\/strong>, logger-name<\/strong> and message<\/strong>. root<\/strong> is the default logger-name<\/strong>. We will use these kinds of functions with our views in Django.<\/p>\n
Logging in Django<\/h4>\n
Django provides logging by using the logging module of Python. The logging module can be easily configured.<\/p>\n
When we want to use logging in Django there are certain steps to be followed. The procedure will be as follows:<\/p>\n
- \n
- We will configure our settings.py for various loggers, handlers, filters.<\/li>\n
- We will include the loggers code in views or any other module of Django where necessary.<\/li>\n<\/ol>\n
Okay, so let\u2019s get started.<\/p>\n
Create a new Project<\/h3>\n
We will create a new project for logging. You can then use the logging in existing projects. So, to create a new project, execute this command in the command line:<\/p>\n
$ django-admin startproject dataflairlogs<\/strong><\/em><\/p>\n
This will start the new project. Now, we will configure settings.py of the project.<\/p>\n
Configuring Settings<\/h3>\n
For including logging in Django, we need to configure its settings. Doing that is pretty easy. By configuring logging settings, we mean to define:<\/p>\n
- \n
- Loggers<\/li>\n
- Handlers<\/li>\n
- Filters<\/li>\n
- Formatters<\/li>\n<\/ul>\n
Since Django works with different modules therefore, we use the dictConfig<\/strong> method. There are other raw methods as well, but dictConfig<\/strong> is what Django\u2019s default behavior. Just copy this code in your settings.py<\/p>\n
Code:<\/strong><\/p>\n
# DataFlair #Logging Information\r\nLOGGING = {\r\n 'version': 1,\r\n # Version of logging\r\n 'disable_existing_loggers': False,\r\n #disable logging \r\n # Handlers #############################################################\r\n 'handlers': {\r\n 'file': {\r\n 'level': 'DEBUG',\r\n 'class': 'logging.FileHandler',\r\n 'filename': 'dataflair-debug.log',\r\n },\r\n########################################################################\r\n 'console': {\r\n 'class': 'logging.StreamHandler',\r\n },\r\n },\r\n # Loggers ####################################################################\r\n 'loggers': {\r\n 'django': {\r\n 'handlers': ['file', 'console'],\r\n 'level': 'DEBUG',\r\n 'propagate': True,\r\n 'level': os.getenv('DJANGO_LOG_LEVEL', 'DEBUG')\r\n },\r\n },\r\n}<\/pre>\n