From 2da78862010a03fc4de3fcc273ac5386ba62baf4 Mon Sep 17 00:00:00 2001 From: MEHRSHAD MIRSHEKARY Date: Fri, 30 Aug 2024 12:14:59 +0330 Subject: [PATCH 1/2] :books: docs: Update Readme.md file - Updated README.md file to provide an overview of the project, its purpose, and how to get started. - Included sections on installation, configuration, and verification of django_logging. - Provided examples for adding the package to INSTALLED_APPS and running the Django server to ensure proper setup. - Added details on default logging configurations and instructions for further customization. - Included a brief conclusion directing users to additional settings for more advanced configurations. --- README.md | 293 +++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 291 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index 5018bee..e3da737 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,291 @@ -# django_logging -A Repository for logging in django applications +# Django Logging + +The [`django_logging`](https://github.com/ARYAN-NIKNEZHAD/django_logging) is a Django package designed to extend and enhance Python’s built-in logging capabilities. By providing customizable configurations and advanced features, it offers developers a comprehensive logging solution tailored specifically for Django applications. + +![License](https://img.shields.io/github/license/ARYAN-NIKNEZHAD/django_logging) +![PyPI release](https://img.shields.io/pypi/v/django_logging) +![Supported Python versions](https://img.shields.io/pypi/pyversions/django_logging) +![Supported Django versions](https://img.shields.io/pypi/djversions/django_logging) +![Documentation](https://img.shields.io/readthedocs/django_logging) +![Last Commit](https://img.shields.io/github/) +![Languages](https://img.shields.io/github/) + + + +## Project Detail + +- Language: Python > 3.8 +- Framework: Django > 4.2 + | + +## Documentation + +The documentation is organized into the following sections: + +- [Quick Start](#quick-start) +- [Usage](#usage) +- [Settings](#settings) +- [Available Format Options](#available-format-options) +- [Required Email Settings](#required-email-settings) + + +## Quick Start + +Getting started with `django_logging` is simple. Follow these steps to get up and running quickly: + +1. **Installation** + + Install `django_logging` via pip: + + ```shell + $ pip install django_logging + ``` + +2. **Add to Installed Apps** + +Add `django_logging` to your `INSTALLED_APPS` in your Django settings file: + +```python +INSTALLED_APPS = [ + ... + 'django_logging', + ... +] +``` + +3. **Default Configuration** + +By default, `django_logging` is configured to use its built-in settings. You do not need to configure anything manually unless you want to customize the behavior. The default settings will automatically handle logging with predefined formats and options. + + +4. **Verify Installation** + +To ensure everything is set up correctly, run your Django development server: +```shell +python manage.py runserver +``` + +By default, `django_logging` will log an initialization message to the console that looks like this: +```shell +INFO | 'datetime' | django_logging | Logging initialized with the following configurations: +Log File levels: ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL']. +Log files are being written to: logs. +Console output level: DEBUG. +Colorize console: True. +Log date format: %Y-%m-%d %H:%M:%S. +Email notifier enabled: False. +``` + + +That's it! `django_logging` is ready to use with default settings. For further customization, refer to the Settings section + + +## Usage +Once `django_logging` is installed and added to your INSTALLED_APPS, you can start using it right away. The package provides several features to customize and enhance logging in your Django project. Below is a guide on how to use the various features provided by `django_logging`. + +1. **Basic Logging Usage** +At its core, `django_logging` is built on top of Python’s built-in logging module. This means you can use the standard logging module to log messages across your Django project. Here’s a basic example of logging usage: +```python +import logging + +logger = logging.getLogger(__name__) + +logger.debug("This is a debug message") +logger.info("This is an info message") +logger.warning("This is a warning message") +logger.error("This is an error message") +logger.critical("This is a critical message") +``` +These logs will be handled according to the configurations set up by `django_logging`, using either the default settings or any custom settings you've provided. +Request Logging Middleware +To log request information such as the request path, user, IP address, and user agent, add `django_logging`.middleware.RequestLogMiddleware to your MIDDLEWARE setting: + +```python +MIDDLEWARE = [ + ... + 'django_logging.middleware.RequestLogMiddleware', + ... +] +``` + +This middleware will log request details at info level, here is an example with default format: +```shell +INFO | 'datetime' | django_logging | Request Info: (request_path: /example-path, user: example_user, +IP: 192.168.1.1, user_agent: Mozilla/5.0) + +``` + +3. **Context Manager** + +You can use the `config_setup` context manager to temporarily apply `django_logging` configurations within a specific block of code. +Example usage: +```python +from django_logging.utils.context_manager import config_setup +import logging + +logger = logging.getLogger(__name__) + +def foo(): + logger.info("This log will use the configuration set in the context manager!") + +with config_setup(): + """ Your logging configuration changes here""" + foo() + +# the logging configuration will restore to what it was before, in here outside of with block +``` +- Note: `AUTO_INITIALIZATION_ENABLE` must be set to `False` in the settings to use the context manager. If `AUTO_INITIALIZATION_ENABLE` is `True`, attempting to use the context manager will raise a `ValueError` with the message: +``` +"You must set 'AUTO_INITIALIZATION_ENABLE' to False in DJANGO_LOGGING in your settings to use the context manager." +``` + +4. **Log and Notify Utility** + +To send specific logs as email, use the `log_and_notify_admin` function. Ensure that the `ENABLE` option in `LOG_EMAIL_NOTIFIER` is set to `True` in your settings: +```python +from django_logging.utils.log_email_notifier.log_and_notify import log_and_notify_admin +import logging + +logger = logging.getLogger(__name__) + +log_and_notify_admin(logger, logging.INFO, "This is a log message") +``` +You can also include additional request information in the email by passing an `extra` dictionary: +```python +from django_logging.utils.log_email_notifier.log_and_notify import log_and_notify_admin +import logging + +logger = logging.getLogger(__name__) + +def some_view(request): + log_and_notify_admin( + logger, + logging.INFO, + "This is a log message", + extra={"request": request} + ) +``` + +- Note: To use the email notifier, `LOG_EMAIL_NOTIFIER["ENABLE"]` must be set to `True`. If it is not enabled, calling `log_and_notify_admin` will raise a `ValueError`: +```shell +"Email notifier is disabled. Please set the 'ENABLE' option to True in the 'LOG_EMAIL_NOTIFIER' in DJANGO_LOGGING in your settings to activate email notifications." +``` + +Additionally, ensure that all [Required Email Settings](#required-email-settings) are configured in your Django settings file. + +5. **Send Logs Command** + +To send the entire log directory to a specified email address, use the `send_logs` management command: +```shell +python manage.py send_logs example@domain.com +``` +This command will attach the log directory and send a zip file to the provided email address. + +## Settings + +The `DJANGO_LOGGING` configuration allows you to customize various aspects of logging within your Django project. Below is a detailed description of each configurable option. + +**Configuration Options** +The settings are defined in the `DJANGO_LOGGING` dictionary in your +`settings.py` file. Here’s a breakdown of each option: +By default, `django_logging` uses a built-in configuration that requires no additional setup. However, you can customize the logging settings by adding a `DJANGO_LOGGING` configuration to your Django settings file. + +Example configuration: +```python +DJANGO_LOGGING = { + "AUTO_INITIALIZATION_ENABLE": True, + "INITIALIZATION_MESSAGE_ENABLE": True, + "LOG_FILE_LEVELS": ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"], + "LOG_DIR": "logs", + "LOG_FILE_FORMATS": { + "DEBUG": 1, + "INFO": 1, + "WARNING": 1, + "ERROR": 1, + "CRITICAL": 1, + }, + "LOG_CONSOLE_LEVEL": "DEBUG", + "LOG_CONSOLE_FORMAT": 1, + "LOG_CONSOLE_COLORIZE": True, + "LOG_DATE_FORMAT": "%Y-%m-%d %H:%M:%S", + "LOG_EMAIL_NOTIFIER": { + "ENABLE": False, + "NOTIFY_ERROR": False, + "NOTIFY_CRITICAL": False, + "LOG_FORMAT": 1, + "USE_TEMPLATE": True + } +} +``` + +Here's a breakdown of the available configuration options: +- `AUTO_INITIALIZATION_ENABLE`: Accepts `bool`. Enables automatic initialization of logging configurations. Defaults to `True`. +- `INITIALIZATION_MESSAGE_ENABLE`: Accepts bool. Enables logging of the initialization message. Defaults to `True`. +- `LOG_FILE_LEVELS`: Accepts a list of valid log levels (a list of `str` where each value must be one of the valid levels). Defines the log levels for file logging. Defaults to `['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL']`. +- `LOG_DIR`: Accepts `str` like `"path/to/logs"` or a path using functions like `os.path.join()`. Specifies the directory where log files will be stored. Defaults to `"logs"`. +- `LOG_FILE_FORMATS`: Accepts log levels as keys and format options as values. The format option can be an `int` chosen from predefined options or a user-defined format `str`. Defines the format for log files. Defaults to `1` for all levels. + - **Note**: See the [Available Format Options](#available-format-options) below for available formats. +- `LOG_CONSOLE_LEVEL`: Accepts `str` that is a valid log level. Specifies the log level for console output. Defaults to `'DEBUG'`. +- `LOG_CONSOLE_FORMAT`: Accepts the same options as `LOG_FILE_FORMATS`. Defines the format for console output. Defaults to `1`. +- `LOG_CONSOLE_COLORIZE`: Accepts `bool`. Determines whether to colorize console output. Defaults to `True`. +- `LOG_DATE_FORMAT`: Accepts `str` that is a valid datetime format. Specifies the date format for log messages. Defaults to `'%Y-%m-%d %H:%M:%S'`. +- `LOG_EMAIL_NOTIFIER`: Is a dictionary where: + - `ENABLE`: Accepts `bool`. Determines whether the email notifier is enabled. Defaults to `False`. + - `NOTIFY_ERROR`: Accepts `bool`. Determines whether to notify on error logs. Defaults to `False`. + - `NOTIFY_CRITICAL`: Accepts `bool`. Determines whether to notify on critical logs. Defaults to `False`. + - `LOG_FORMAT`: Accepts the same options as other log formats (`int` or `str`). Defines the format for log messages sent via email. Defaults to `1`. + - `USE_TEMPLATE`: Accepts `bool`. Determines whether the email includes an HTML template. Defaults to `True`. + +## Available Format Options + +The `django_logging` package provides predefined log format options that you can use in configuration. Below are the available format options: + +```python +FORMAT_OPTIONS = { + 1: "%(levelname)s | %(asctime)s | %(module)s | %(message)s", + 2: "%(levelname)s | %(asctime)s | %(message)s", + 3: "%(levelname)s | %(message)s", + 4: "%(asctime)s - %(name)s - %(levelname)s - %(message)s", + 5: "%(levelname)s | %(message)s | [in %(pathname)s:%(lineno)d]", + 6: "%(asctime)s | %(levelname)s | %(message)s", + 7: "%(levelname)s | %(asctime)s | in %(module)s: %(message)s", + 8: "%(levelname)s | %(message)s | [%(filename)s:%(lineno)d]", + 9: "[%(asctime)s] | %(levelname)s | in %(module)s: %(message)s", + 10: "%(asctime)s | %(processName)s | %(name)s | %(levelname)s | %(message)s", + 11: "%(asctime)s | %(threadName)s | %(name)s | %(levelname)s | %(message)s", + 12: "%(levelname)s | [%(asctime)s] | (%(filename)s:%(lineno)d) | %(message)s", + 13: "%(levelname)s | [%(asctime)s] | {%(name)s} | (%(filename)s:%(lineno)d): %(message)s", +} +``` + +You can reference these formats by their corresponding integer keys in your logging configuration settings. + +## Required Email Settings + +To use the email notifier, the following email settings must be configured in your `settings.py`: +- `EMAIL_HOST`: The host to use for sending emails. +- `EMAIL_PORT`: The port to use for the email server. +- `EMAIL_HOST_USER`: The username to use for the email server. +- `EMAIL_HOST_PASSWORD`: The password to use for the email server. +- `EMAIL_USE_TLS`: Whether to use a TLS (secure) connection when talking to the email server. +- `DEFAULT_FROM_EMAIL`: The default email address to use for sending emails. +- `ADMIN_EMAIL`: The email address where log notifications will be sent. This is the recipient address used by the email notifier to deliver the logs. + +Example Email Settings: +```python +EMAIL_HOST = 'smtp.example.com' +EMAIL_PORT = 587 +EMAIL_HOST_USER = 'your-email@example.com' +EMAIL_HOST_PASSWORD = 'your-password' +EMAIL_USE_TLS = True +DEFAULT_FROM_EMAIL = 'your-email@example.com' +ADMIN_EMAIL = 'admin@example.com' +``` + +These settings ensure that the email notifier is correctly configured to send log notifications to the specified `ADMIN_EMAIL` address. + +## Conclusion + +Thank you for using `django_logging`. We hope this package enhances your Django application's logging capabilities. For more detailed documentation, customization options, and updates, please refer to the official documentation on [Read the Docs](https://django_logging.readthedocs.io/). If you have any questions or issues, feel free to open an issue on our [GitHub repository](https://github.com/ARYAN-NIKNEZHAD/django_logging). + +Happy logging! From f8c222378104fcbedb18ffa127d11aab29b5d827 Mon Sep 17 00:00:00 2001 From: MEHRSHAD MIRSHEKARY Date: Fri, 30 Aug 2024 12:27:02 +0330 Subject: [PATCH 2/2] :zap::books: docs:Add all neccessary files Added CHANGELOG file to provide all new changes to the project ----- Updated CONTRIBUTORS.md & LICENCE file Ensured clear documentation for whole project including Makefile and reStructureText format Closes #52 --- CHANGELOG.md | 3 + CODE_OF_CONDUCT.md | 162 +++++++++++++++++++++++++++++++++++++++++++++ CONTRIBUTING.md | 151 ++++++++++++++++++++++++++++++++++++++++++ CONTRIBUTORS.md | 10 +-- LICENCE | 4 +- 5 files changed, 323 insertions(+), 7 deletions(-) create mode 100644 CHANGELOG.md create mode 100644 CODE_OF_CONDUCT.md create mode 100644 CONTRIBUTING.md diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..6361e43 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,3 @@ +# Changelog + +All notable changes to this project will be documented in this file. diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md new file mode 100644 index 0000000..bdea694 --- /dev/null +++ b/CODE_OF_CONDUCT.md @@ -0,0 +1,162 @@ +## Code of Conduct for Contributing to django_logging + +we’re thrilled that you want to contribute to `django_logging`! to ensure a positive and protective environment for everyone involved, please adhere to the following guidelines. + +## Contribution Workflow + +1. **Fork and Clone**: Start by forking the `django_logging` repository on Github and cloning it to your local machine: + ```bash + git clone https://github.com/ARYAN-NIKNEZHAD/django_logging.git + cd django_logging + ``` + +2. **Create a Branch**: Create a new branch for your feature or bugfix: + ```bash + git checkout -b feature/your-feature-name + ``` + +3. **Install Dependencies**: Use Poetry to install the project’s dependencies. if poetry isn’t installed, refer to the [Poetry installation guide](https://python-poetry.org/docs/#installation) + ```bash + poetry install + ``` + +4. **Write Code and Tests**: Make your changes and write tests for your new code. Ensure that all tests pass: + ```bash + poetry run pytest + ``` +5. **Run Code Quality Checks**: Ensure code quality with Pylint: + ```bash + poetry run pylint django_logging + ``` + +6. **Commit Your Changes**: Use Commitizen to commit your changes according to the Conventional Commits specification: + ```bash + cz commit + ``` + +7. **Push and Create a PR**: Push your changes to your fork on GitHub and open a pull request: + ```bash + git push origin feature/your-feature-name + ``` + +8. **Bump Version**: Use Commitizen to update the version. + ```bash + cz bump + ``` + +9. **Generate Changelog**: Create a changelog with Commitizen: + ```bash + cz changelog + ``` + +10. **Export Dependencies**: Export the project dependencies for development and production: + ```bash + poetry export -f requirements.txt --output packages/requirements.txt --without-hashes + poetry export -f requirements.txt --dev --output packages/requirements-dev.txt --without-hashes + ``` + +## Commitizen Message Rule + +Commitizen follows the Conventional Commits specification. Your commit message should be structured as follows: + +``` +[optional scope]: + +[optional body] + +[optional footer(s)] +``` + +## Example of Commit Messages + +### 1. Initialization of Core +``` +feat(core): initialize the core module + +- Set up the core structure +- Added initial configurations and settings +- Created basic utility functions +``` + +### 2. Release with Build and Tag Version +``` +chore(release): build and tag version 1.0.0 + +- Built the project for production +- Created a new tag for version 1.0.0 +- Updated changelog with release notes +``` + +### 3. Adding a New Feature +``` +feat(auth): add user authentication + +- Implemented user login and registration +- Added JWT token generation and validation +- Created middleware for protected routes +``` + +### 4. Fixing a Bug +``` +fix(api): resolve issue with data fetching + +- Fixed bug causing incorrect data responses +- Improved error handling in API calls +- Added tests for the fixed bug +``` + +### 5. Update Documentation (Sphinx) +``` +docs(sphinx): update API documentation + +- Updated the Sphinx documentation for API changes +- Added examples for new endpoints +- Fixed typos and formatting issues +``` + +### 6. Update Dependencies +``` +chore(deps): update project dependencies + +- Updated all outdated npm packages +- Resolved compatibility issues with new package versions +- Ran tests to ensure no breaking changes +``` + +### 7. Update Version for Build and Publish +``` +chore(version): update version to 2.1.0 for build and publish + +- Incremented version number to 2.1.0 +- Updated package.json with the new version +- Prepared for publishing the new build +``` + +### 8. Adding Unit Tests +``` +test(auth): add unit tests for authentication module + +- Created tests for login functionality +- Added tests for registration validation +- Ensured 100% coverage for auth module +``` + +### 9. Refactoring Codebase +``` +refactor(core): improve code structure and readability + +- Refactored core module to enhance readability +- Extracted utility functions into separate files +- Updated documentation to reflect code changes +``` + +### 10. Improving Performance +``` +perf(parser): enhance parsing speed + +- Optimized parsing algorithm for better performance +- Reduced the time complexity of the parsing function +- Added benchmarks to track performance improvements +``` + +Thank you for contributing to `django_logging`! We look forward to your contributions. diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 0000000..4a57b2f --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,151 @@ +# Contributing to django_logging + + +We’re excited that you’re interested in contributing to `django_logging`! Whether you’re fixing a bug, adding a feature, or improving the project, your help is appreciated. + +## Overview + + +- **Setting Up Your Environment** +- **Testing Your Changes** +- **Code Style Guidelines** +- **Utilizing Pre-commit Hooks** +- **Creating a Pull Request** +- **Reporting Issues** +- **Resources** + +## Setting Up Your Environment + + +1. **Fork the Repository:** + + Begin by forking the `django_logging` repository on GitHub. This creates your own copy where you can make changes. + +2. **Clone Your Fork:** + + Use the following command to clone your fork locally: + + ```bash + git clone https://github.com/your-username/django_logging.git + cd django_logging + ``` + +3. **Install Dependencies:** + + Install the necessary dependencies using `Poetry`. If Poetry isn't installed on your machine, you can find installation instructions on the [Poetry website](https://python-poetry.org/docs/#installation). + + ```bash + poetry install + ``` + +4. **Create a Feature Branch:** + + It’s a good practice to create a new branch for your work: + + ```bash + git checkout -b feature/your-feature-name + ``` + +## Testing Your Changes + +We use `pytest` for running tests. Before submitting your changes, ensure that all tests pass: + + ```bash + poetry run pytest + ``` + +If you’re adding a new feature or fixing a bug, don’t forget to write tests to cover your changes. + + +## Code Style Guidelines + +Maintaining a consistent code style is crucial. We use `black` for code formatting and `isort` for import sorting. Make sure your code adheres to these styles: + + ```bash + poetry run black . + poetry run isort . + ``` +For linting, `pylint` is used to enforce style and catch potential errors: + + ```bash + poetry run pylint django_logging + ``` + +## Utilizing Pre-commit Hooks + +Pre-commit hooks are used to automatically check and format code before you make a commit. This ensures consistency and quality in the codebase. + +1. **Install Pre-commit:** + + ```bash + poetry add --dev pre-commit + ``` + +2. **Set Up the Hooks:** + + Install the pre-commit hooks by running: + + ```bash + poetry run pre-commit install + ``` +3. **Manual Hook Execution (Optional):** + + To run all hooks manually on your codebase: + + ```bash + poetry run pre-commit run --all-files + ``` + +## Creating a Pull Request + +Once your changes are ready, follow these steps to submit them: + +1. **Commit Your Changes:** + + Write clear and concise commit messages. Following the [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) format is recommended: + + ```bash + git commit -am 'feat: add custom logging formatter' + ``` +2. **Push Your Branch:** + + Push your branch to your fork on GitHub: + + ```bash + git push origin feature/your-feature-name + ``` + +3. **Open a Pull Request:** + + Go to the original `django_logging` repository and open a pull request. Include a detailed description of your changes and link any related issues. + +4. **Respond to Feedback:** + + After submitting, a maintainer will review your pull request. Be prepared to make revisions based on their feedback. + +## Reporting Issues + +Found a bug or have a feature request? We’d love to hear from you! + +1. **Open an Issue:** + + Head over to the `Issues` section of the `django_logging` repository and click "New Issue". + +2. **Describe the Problem:** + + Fill out the issue template with as much detail as possible. This helps us understand and address the issue more effectively. + +## Resources + +Here are some additional resources that might be helpful: + +- [Poetry Documentation](https://python-poetry.org/docs/) +- [Black Documentation](https://black.readthedocs.io/en/stable/) +- [isort Documentation](https://pycqa.github.io/isort/) +- [pytest Documentation](https://docs.pytest.org/en/stable/) +- [pylint Documentation](https://pylint.pycqa.org/en/latest/) +- [Pre-commit Documentation](https://pre-commit.com/) + +--- + +Thank you for your interest in contributing to `django_logging`! We look forward to your contributions. diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md index 448b9b0..327c8db 100644 --- a/CONTRIBUTORS.md +++ b/CONTRIBUTORS.md @@ -4,13 +4,13 @@ We would like to thank the following people for their contributions to the `djan ## Core Contributors -| Name | Role | GitHub | Email | Contributions | Image | -|----------------------|------------------|------------------------------------------------------------------------|----------------------|--------------------------------|--------------------------------------| -| **Aryan Niknezhad** | Project Creator & Lead Maintainer | [ARYAN-NIKNEZHAD](https://github.com/ARYAN-NIKNEZHAD) | aryan513966@gmail.com | Project creator and lead maintainer. | ![Aryan Niknezhad](https://avatars.githubusercontent.com/u/127540182?v=4) | -| **Mehrshad Mirshekary** | Maintainer | [MEHRSHAD-MIRSHEKARY](https://github.com/MEHRSHAD-MIRSHEKARY) | Not Provided | Maintainer | ![Mehrshad Mirshekary](https://avatars.githubusercontent.com/u/121759619?v=4) | +| Name | Role | GitHub | Email | Contributions | Image | +|----------------------|------------------|------------------------------------------------------------------------|-------------------------------|--------------------------------|--------------------------------------| +| **Aryan Niknezhad** | Project Creator & Lead Maintainer | [ARYAN-NIKNEZHAD](https://github.com/ARYAN-NIKNEZHAD) | aryan513966@gmail.com | Project creator and lead maintainer. | ![Aryan Niknezhad](https://avatars.githubusercontent.com/u/127540182?v=4) | +| **Mehrshad Mirshekary** | Maintainer | [MEHRSHAD-MIRSHEKARY](https://github.com/MEHRSHAD-MIRSHEKARY) | mehrshad_mirshekary@email.com | Maintainer | ![Mehrshad Mirshekary](https://avatars.githubusercontent.com/u/121759619?v=4) | --- To be added to this list, please contribute to the project by submitting a pull request, opening issues, or helping improve the documentation. We appreciate all contributions, big and small! -If you have contributed and are not listed here, please feel free to add your name and details in a pull request. \ No newline at end of file +If you have contributed and are not listed here, please feel free to add your name and details in a pull request. diff --git a/LICENCE b/LICENCE index c0e28fd..5fb0008 100644 --- a/LICENCE +++ b/LICENCE @@ -1,6 +1,6 @@ MIT License -Copyright (c) 2024 django_logging-team +Copyright (c) 2024 django_logging Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal @@ -18,4 +18,4 @@ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. \ No newline at end of file +SOFTWARE.