Release v1.0.33 - How to DEBUG Django

app-generator · app-generator · commit 21a88b49f813 · 2023-05-10T08:51:46.000+03:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,11 @@
 # Change Log
 
+## [1.0.33] 2023-05-10
+### Changes
+
+- Update [Django](https://docs.appseed.us/technologies/django/) Section
+  - [How to DEBUG Django](https://docs.appseed.us/technologies/django/how-to-debug/)
+
 ## [1.0.32] 2023-05-10
 ### Changes
 
diff --git a/docs/technologies/django/how-to-debug.mdx b/docs/technologies/django/how-to-debug.mdx
@@ -5,31 +5,32 @@ description: Learn how to DENUG Django and activate Logging
 
 import SubHeading from "@site/src/components/SubHeading";
 
-<SubHeading color="#25c2a0">Learn how to DENUG Django and activate Logging</SubHeading>
+<SubHeading color="#25c2a0">Learn how to DBUG Django and activate Logging</SubHeading>
 
-Logging and Debugging are essential aspects of any web application, as it allows developers to record and analyze the execution of their code, making it easier to identify and resolve issues. In a Django application, proper logging can not only save valuable time during development and debugging but also help you ensure the stability and security of your application in production.
+**Logging** and **Debugging** are essential aspects of any web application, as it allows developers to record and analyze the execution of their code, making it easier to identify and resolve issues. 
+In a **Django** application, proper logging can not only save valuable time during development and debugging but also help you ensure the stability and security of your application in production.
 
 In this article, we will discuss the importance of logging and debugging in Django applications. Our journey will be divided into three key sections:
 
-* Configuring Django for Logging
+* ✅ Configuring Django for Logging
     
-* Using `pdb` in a Django Application
-    
-* Configuring Django Debug Toolbar
+* ✅ Using `pdb` in a Django Application
     
+* ✅ Configuring Django Debug Toolbar
 
 So, let's dive in and explore the world of Django logging!
 
+<br />
+
 ## Project Setup
 
-For this article, you can find the code on GitHub at [https://github.com/app-generator/sample-django-debug](https://github.com/app-generator/sample-django-debug).
+For this article, you can find the code on GitHub at **[How to DEBUG Django Sample](https://github.com/app-generator/sample-django-debug)**.
 
 To make things quicker, you can clone this specific commit so you can follow the tutorial.
 
 ```bash
-$ git clone https://github.com/app-generator/django-volt-dashboard.git
-$ cd django-volt-dashboard
-$ git checkout e2cb798e96f8b41a94c981c617b93f88ed9034ec
+$ git clone https://github.com/app-generator/sample-django-debug.git
+$ cd sample-django-debug
 ```
 
 Once the project is set up, you can install the dependencies and start the Django project.
@@ -43,9 +44,12 @@ $ python manage.py migrate
 $ python manage.py runserver
 ```
 
+<br />
+
 ## Configuring Django for Logging
 
-Django natively integrates logging using Python's built-in logging module. This integration allows developers to easily track events, monitor application behavior, and diagnose issues. Django allows you principally to use the default logging system or to create your custom loggers.
+Django natively integrates logging using Python's built-in logging module. This integration allows developers to easily track events, monitor application behavior, and diagnose issues.
+ Django allows you principally to use the default logging system or to create your custom loggers.
 
 * **Default logging settings**: Django provides a default logging configuration that is applied if you don't explicitly configure logging in your `settings.py`. This default configuration logs messages with the `WARNING` level and above to the console. In `DEBUG` mode, Django also logs SQL queries.
     
@@ -54,6 +58,8 @@ Django natively integrates logging using Python's built-in logging module. This
 
 We will write our configuration for Logging in the next lines.
 
+<br />
+
 ### Custom Logging Settings
 
 As stated in the previous section, customizing the `Logging` in Django add the following configuration in `core/settings.py`.
@@ -99,46 +105,45 @@ LOGGING = {
 
 Let's explain the code we have above :
 
-1. General configuration
-    
+> 👉 `General configuration`
 
-* `version`: `1`
+* **version**: `1`
     
     * The version key is set to 1, indicating that this is a version 1 schema for logging configuration, which is the default and only version available for the logging configuration in Python's logging module.
         
-* `disable_existing_loggers`: `False`
+* **disable_existing_loggers**: `False`
     
     * This setting controls whether or not to disable all existing loggers when the configuration is applied. By setting it to `False`, the existing loggers are enabled.
         
 
-1. Formatters
+> 👉 **Formatters**
     
 
-* `default`
+* **default**
     
     * A custom formatter with the format string `"%(asctime)s %(name)-12s %(levelname)-8s %(message)s"`. This format includes a timestamp, logger name, log level, and the log message.
         
-* `django.server`
+* **django.server**
     
     * This formatter is the same as the default formatter for the `django.server` logger.
         
 
-1. Handlers
+> 👉 **Handlers**
     
 
-* `apps_home`
+* **apps_home**
     
     * A file handler that logs messages with a log level of `DEBUG` and above to a file named `logs/apps_home.log`.
         
-* `console`
+* **console**
     
     * A stream handler logs messages with a log level of `DEBUG` and above to the console (standard output). This handler uses the `default` formatter defined earlier.
         
 
-1. Loggers
+> 👉 **Loggers**
     
 
-* `apps.home`
+* **apps.home**
     
     * A logger for the `apps.home` module (replace this with the actual name of your application or module). This logger has two handlers, `apps_home` and `console`, which means it will log messages to both the specified log file and the console. The log level is set to `DEBUG`, so it will log messages with a level of `DEBUG` and above. The `propagate` key is set to `False`, which means that the log messages handled by this logger will not be passed to higher-level loggers (e.g., the root logger or the `django` logger).
         
@@ -191,7 +196,7 @@ This code is part of a Django view module that demonstrates how to use the custo
 
 Visit the project at this link : `http://localhost:8000/test_logs` and you will see the current result
 
-![](https://cdn.hashnode.com/res/hashnode/image/upload/v1682865033264/a1c3deb4-fe65-44f7-9a13-8c24ddddfd63.png)
+![Debug Django - Error Page](https://cdn.hashnode.com/res/hashnode/image/upload/v1682865033264/a1c3deb4-fe65-44f7-9a13-8c24ddddfd63.png)
 
 And you can check the `logs/apps_home.log` and you will see the content.
 
@@ -203,9 +208,12 @@ And we have just logged our first error. Using the logging feature integrated wi
 
 In the next section, we will explore how to use `pdb` for debugging in a Django application.
 
-## Using pdb for Debugging in Django Application
+<br />
 
-`pdb`, short for "Python Debugger", is a built-in Python module that provides a way to interactively debug your code. You can use `pdb` in a Django application to debug your views, models, or other code within the app. We will use `pdb` in the `test_logs` view by adding `pdb.set_trace()` after the line `users = User.objects.all()`.
+## Using **PDB** for Debugging
+
+`pdb`, short for "Python Debugger", is a built-in Python module that provides a way to interactively debug your code. 
+You can use `pdb` in a Django application to debug your views, models, or other code within the app. We will use `pdb` in the `test_logs` view by adding `pdb.set_trace()` after the line `users = User.objects.all()`.
 
 ```python
 ...
@@ -216,9 +224,11 @@ def test_logs(request):
 ...
 ```
 
-The line `pdb.set_trace()` is used to create a breakpoint in your Python code when using the `pdb` debugger. When the code execution reaches this line, it will pause and open an interactive debugging session in your terminal or console.
+The line `pdb.set_trace()` is used to create a breakpoint in your Python code when using the `pdb` debugger. 
+When the code execution reaches this line, it will pause and open an interactive debugging session in your terminal or console.
 
-At this point, you can interact with the debugger using various commands to inspect the variables, step through the code, execute arbitrary code, and more. This helps you identify and fix issues in your code more efficiently by providing an interactive debugging environment.
+At this point, you can interact with the debugger using various commands to inspect the variables, step through the code, execute arbitrary code, and more. 
+This helps you identify and fix issues in your code more efficiently by providing an interactive debugging environment.
 
 Here are some useful `pdb` commands you can use during the debugging session:
 
@@ -239,13 +249,15 @@ Here are some useful `pdb` commands you can use during the debugging session:
 * `h` (help): Show a list of available commands.
     
 
-Visit this URL again [http://localhost:8000/test\_logs](http://localhost:8000/test_logs) and go on the terminal when you are running the Django server and let's type some commands. You can check the results of these commands typed in the image below.
+Visit this URL again [http://localhost:8000/test\_logs](http://localhost:8000/test_logs) and go on the terminal when you are running the Django server and let's type some commands. 
+You can check the results of these commands typed in the image below.
 
 ![](https://cdn.hashnode.com/res/hashnode/image/upload/v1682867617748/b896ea35-e0e3-4300-987e-b123af4ba1fa.png)
 
 To quit the interactive debugging terminal, just type `q` and Django will continue the execution of the code.
 
-Pdb is a great tool you can use in development to leverage your debugging requirements in a Django application. However, it's not recommended to use `pdb.set_trace()` in a live, production environment, as it may cause the application to hang when it reaches the breakpoint. Use `pdb` only during development and testing.
+Pdb is a great tool you can use in development to leverage your debugging requirements in a Django application. 
+However, it's not recommended to use `pdb.set_trace()` in a live, production environment, as it may cause the application to hang when it reaches the breakpoint. Use `pdb` only during development and testing.
 
 > If you're using Python 3.7 or later, you can use the built-in `breakpoint()` function instead of `pdb.set_trace()`. To do this, simply replace the `pdb.set_trace()` line with:
 > 
@@ -255,13 +267,18 @@ Pdb is a great tool you can use in development to leverage your debugging requir
 > 
 > By default, this will invoke `pdb`, but it can be customized to use other debuggers if needed.
 
-We now understand how to use `pdb` to debug in our Django application. However, you might also want to have real-time data and a better description of errors when building a web application or an API with Django. In the next section, we will learn why and how to use `django-debug-toolbar`.
+We now understand how to use `pdb` to debug in our Django application. 
+However, you might also want to have real-time data and a better description of errors when building a web application or an API with Django. 
+In the next section, we will learn why and how to use `django-debug-toolbar`.
+
+<br />
 
-## Integrating django-debug-toolbar
+## Integrating `django-debug-toolbar`
 
 As a developer, you might have already faced issues such as performance issues, SQL queries, template rendering issues, and more, all within the context of your application.
 
-[**Django Debug Toolbar**](https://django-debug-toolbar.readthedocs.io/en/latest/) is a third-party package that provides a set of panels displaying various debug information about the current request/response in your Django application. It is an essential tool for Django developers and it can help you with the following issues:
+[**Django Debug Toolbar**](https://django-debug-toolbar.readthedocs.io/en/latest/) is a third-party package that provides a set of panels displaying various debug information about the current request/response in your Django application. 
+It is an essential tool for Django developers and it can help you with the following issues:
 
 1. **Performance analysis**: It allows you to analyze the performance of your views, identifying potential bottlenecks and slow database queries.
     
@@ -302,7 +319,8 @@ INSTALLED_APPS = [
 ...
 ```
 
-The next step is to add the middleware. In the `settings.py` file, add `'debug_toolbar.middleware.DebugToolbarMiddleware'` to the `MIDDLEWARE` list. Ensure it is placed after `'django.middleware.common.CommonMiddleware'`.
+The next step is to add the middleware. In the `settings.py` file, add `'debug_toolbar.middleware.DebugToolbarMiddleware'` to the `MIDDLEWARE` list. 
+Ensure it is placed after `'django.middleware.common.CommonMiddleware'`.
 
 ```python
 ...
@@ -315,7 +333,8 @@ MIDDLEWARE = [
 ...
 ```
 
-We can then configure the internal IPs and add some configuration for the js files. The toolbar will only be shown for clients connecting from specific IP addresses. In your settings.py file, set the `INTERNAL_IPS` setting to include your IP address or use `'127.0.0.1'` and `localhost` for local development:
+We can then configure the internal IPs and add some configuration for the js files. The toolbar will only be shown for clients connecting from specific IP addresses. 
+In your settings.py file, set the `INTERNAL_IPS` setting to include your IP address or use `'127.0.0.1'` and `localhost` for local development:
 
 ```python
 INTERNAL_IPS = [
@@ -369,8 +388,17 @@ And we are done.🚀 We have just integrated `django-debug-toolbar` in the Djang
 
 Coupled with `pdb` and `logging`, you have a set of powerful tools you can use for debugging in your Django application.
 
+<br />
+
 ## Conclusion
 
-In this article, we have talked about `Django Debug Toolbar`, `pdb`, and `logging` which are essential tools for efficient Django application development. Utilizing these tools, you can identify performance bottlenecks, debug code issues, and optimize database queries with ease.
+In this article, we have talked about `Django Debug Toolbar`, `pdb`, and `logging` which are essential tools for efficient Django application development. 
+Utilizing these tools, you can identify performance bottlenecks, debug code issues, and optimize database queries with ease.
+
+<br />
+
+## Resources
 
-You can find the code in this article on [https://github.com/app-generator/sample-django-debug](https://github.com/app-generator/sample-django-debug).
+- 👉 [How to DEBUG Django](https://github.com/app-generator/sample-django-debug) - the sample updated for this tutorial  
+- 👉 Free [Support](https://appseed.us/support/) via Email & Discord
+- 👉 [Custom Development Services](https://appseed.us/custom-development/) provided by experts
