django-resilient-logger 0.1.0__tar.gz

django_resilient_logger-0.1.0/.gitignore

@@ -0,0 +1,172 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# PyPI configuration file
+.pypirc
+.DS_Store

django_resilient_logger-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 City of Helsinki
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+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.

django_resilient_logger-0.1.0/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: django-resilient-logger
+Version: 0.1.0
+Summary: A module that fixes provides django-specific resilient logger module.
+Project-URL: Homepage, https://github.com/City-of-Helsinki/django-resilient-logger
+Project-URL: Issues, https://github.com/City-of-Helsinki/django-resilient-logger/issues
+Author-email: City of Helsinki <dev@hel.fi>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: django,extra tools,logging,plugin extension
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 4.2
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Requires-Python: >=3.9
+Requires-Dist: apscheduler>=3.0.0
+Requires-Dist: django>=4.2
+Requires-Dist: elasticsearch>=8.0.0
+Provides-Extra: test
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-django; extra == 'test'

django_resilient_logger-0.1.0/pyproject.toml

@@ -0,0 +1,83 @@
+[project]
+name = "django-resilient-logger"
+version = "0.1.0"
+authors = [{ name = "City of Helsinki", email = "dev@hel.fi" }]
+description = "A module that fixes provides django-specific resilient logger module."
+readme = "README.md"
+requires-python = ">=3.9"
+keywords = [
+    "django",
+    "logging",
+    "extra tools",
+    "plugin extension",
+]
+classifiers = [
+    "Environment :: Web Environment",
+    "Framework :: Django",
+    "Framework :: Django :: 4.2",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Internet :: WWW/HTTP",
+    "Topic :: Internet :: WWW/HTTP :: Dynamic Content",
+]
+license = "MIT"
+license-files = ["LICENSE"]
+dependencies = [
+  "django>=4.2",
+  "apscheduler>=3.0.0",
+  "elasticsearch>=8.0.0"
+]
+
+[project.urls]
+Homepage = "https://github.com/City-of-Helsinki/django-resilient-logger"
+Issues = "https://github.com/City-of-Helsinki/django-resilient-logger/issues"
+
+[project.optional-dependencies]
+test = ["pytest", "pytest-django"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.sdist]
+include = ["/resilient_logger"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["resilient_logger"]
+
+[tool.ruff]
+target-version = "py39"
+
+[tool.ruff.lint]
+select = [
+    # Pyflakes
+    "F",
+    # pycodestyle
+    "E",
+    "W",
+    # isort
+    "I",
+    # pep8-naming
+    "N",
+    # flake8-bugbear without opinionated rules
+    "B0",
+    # flake8-pie
+    "PIE",
+    # flake8-print
+    "T20",
+]
+extend-per-file-ignores = { "./tests/*" = ["E501"] }
+
+[tool.pytest.ini_options]
+pythonpath = "."
+DJANGO_SETTINGS_MODULE = "tests.settings"
+norecursedirs = [".git", "venv"]

django_resilient_logger-0.1.0/resilient_logger/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

django_resilient_logger-0.1.0/resilient_logger/abstract_log_facade.py

@@ -0,0 +1,46 @@
+from abc import abstractmethod
+from typing import Any, Generator, Self, Union
+
+class AbstractLogFacade:
+    """
+    Abstract base class (interface) that defines the method signatures.
+    This is required because Django will not work if we import something that relies on Models too early.
+    """
+    @abstractmethod
+    def get_id(self) -> Union[str, int]:
+        return NotImplemented
+    
+    @abstractmethod
+    def get_level(self) -> int:
+        return NotImplemented
+
+    @abstractmethod
+    def get_message(self) -> Any:
+        return NotImplemented
+    
+    @abstractmethod
+    def get_context(self) -> Any:
+        return NotImplemented
+    
+    @abstractmethod
+    def is_sent(self) -> bool:
+        return NotImplemented
+
+    @abstractmethod
+    def mark_sent(self) -> None:
+        return NotImplemented
+    
+    @classmethod
+    @abstractmethod
+    def create(cls, level: int, message: Any, context: Any) -> Self:
+        return NotImplemented
+    
+    @classmethod
+    @abstractmethod
+    def get_unsent_entries(cls, chunk_size: int) -> Generator[Self, None, None]:
+        return NotImplemented
+
+    @classmethod
+    @abstractmethod
+    def clear_sent_entries(cls, days_to_keep: int = 30) -> None:
+        return NotImplemented

django_resilient_logger-0.1.0/resilient_logger/abstract_submitter.py

@@ -0,0 +1,144 @@
+from abc import abstractmethod
+from django.db import transaction
+
+import logging
+import os
+
+from typing import Any, Dict, List, Optional, Generator, Type, TypedDict
+
+from resilient_logger.abstract_log_facade import AbstractLogFacade
+from apscheduler.schedulers.background import BackgroundScheduler
+
+logger = logging.getLogger(__name__)
+
+class IntervalOptions(TypedDict):
+    """
+    Defines internal format for apscheduler trigger definitions (trigger, trigger_args).
+    See: https://apscheduler.readthedocs.io/en/3.x/modules/schedulers/base.html#apscheduler.schedulers.base.BaseScheduler.add_job
+    """
+    trigger: str
+    args: Dict[str, Any]
+
+_default_submit_unsent_entries_trigger = IntervalOptions({
+    'trigger': 'interval',
+    'args': { 'minutes': 15 }
+})
+
+_default_clear_sent_entries_trigger = IntervalOptions({
+    'trigger': 'cron',
+    'args': {
+        'month':"*",
+        'day': "1",
+        'hour': "0",
+        'minute': "0",
+        'second': "0",
+    }
+})
+
+class AbstractSubmitter:
+    """
+    Abstract base class for different submitters. By design, does not use any implementation specific
+    storages or submit targets. Those are defined by sub-classes and runtime provided log_facade class.
+    """
+    _batch_limit: int
+    _chunk_size: int
+    _log_facade: Type[AbstractLogFacade]
+
+    def __init__(
+            self,
+            log_facade: Type[AbstractLogFacade],
+            batch_limit: int = 5000,
+            chunk_size: int = 500,
+            submit_unsent_entries_trigger: Optional[IntervalOptions] = _default_submit_unsent_entries_trigger,
+            clear_sent_entries_trigger: Optional[IntervalOptions] = _default_clear_sent_entries_trigger,
+    ) -> None:
+        self._log_facade = log_facade
+        self._batch_limit = batch_limit
+        self._chunk_size = chunk_size
+
+        if not submit_unsent_entries_trigger:
+            logger.info("NOT scheduling submit_entries, submit_unsent_entries_trigger is set to None.")
+
+        if not clear_sent_entries_trigger:
+            logger.info("NOT scheduling clear_old_entries, clear_sent_entries_trigger is set to None.")
+
+        if (submit_unsent_entries_trigger or clear_sent_entries_trigger) and self.should_schedule():
+            scheduler = BackgroundScheduler()
+            scheduler.start()
+
+            if submit_unsent_entries_trigger:
+                scheduler.add_job(
+                    self.submit_unsent_entries,
+                    id="submit_unsent_entries",
+                    name="submit_unsent_entries",
+                    max_instances=1,
+                    replace_existing=True,
+                    trigger=submit_unsent_entries_trigger.get('trigger'),
+                    **submit_unsent_entries_trigger.get('args'),
+                )
+
+            if clear_sent_entries_trigger:
+                scheduler.add_job(
+                    self.clear_sent_entries,
+                    id="clear_sent_entries",
+                    name="clear_sent_entries",
+                    max_instances=1,
+                    replace_existing=True,
+                    trigger=clear_sent_entries_trigger.get('trigger'),
+                    **clear_sent_entries_trigger.get('args'),
+                )
+
+    @abstractmethod
+    def _submit_entry(self, entry: AbstractLogFacade) -> Optional[str]:
+        """This method is different for each submitter, so it's required to override this."""
+        return NotImplemented
+    
+    @transaction.atomic
+    def submit_entry(self, entry: AbstractLogFacade) -> Optional[str]:
+        result_id = self._submit_entry(entry)
+        if result_id is not None:
+            entry.mark_sent()
+            return result_id
+        
+        return None
+
+    def submit(self, level: int, message: Any, context: Any) -> Optional[str]:
+        entry = self.get_log_facade().create(level, message, context)
+        return self.submit_entry(entry)
+
+    @transaction.atomic
+    def submit_unsent_entries(self) -> Optional[List[str]]:
+        result_ids: List[str] = []
+
+        for count, entry in enumerate(self.get_unsent_entries()):
+            if count >= self._batch_limit:
+                print(f"Job limit of {self._batch_limit} logs reached, stopping...")
+                break
+
+            result_id = self.submit_entry(entry)
+
+            if result_id is not None:
+                entry.mark_sent()
+                result_ids.append(result_id)
+
+        return result_ids
+
+    def get_unsent_entries(self) -> Generator[AbstractLogFacade, None, None]:
+        return self.get_log_facade().get_unsent_entries(self._chunk_size)
+    
+    def clear_sent_entries(self, days_to_keep: int = 30) -> None:
+        return self.get_log_facade().clear_sent_entries(days_to_keep)
+    
+    def get_log_facade(self) -> Type[AbstractLogFacade]:
+        if not self._log_facade:
+            raise Exception("self._log_facade is None, cannot proceed without it.")
+        
+        return self._log_facade
+
+    @staticmethod
+    def should_schedule():
+        if os.environ.get("SUBMITTER_SCHEDULED", None) is None:
+            os.environ['SUBMITTER_SCHEDULED'] = 'True'
+            return True
+
+        return False 

django_resilient_logger-0.1.0/resilient_logger/admin.py

@@ -0,0 +1,38 @@
+import json
+import logging
+
+from django.contrib import admin
+from django.core.paginator import Paginator
+from django.utils.html import escape
+from django.utils.safestring import mark_safe
+
+from resilient_logger.models import ResilientLogEntry
+
+logger = logging.getLogger(__name__)
+
+@admin.register(ResilientLogEntry)
+class ResilientLogEntryAdmin(admin.ModelAdmin):
+    exclude = ("message",)
+    readonly_fields = ("id", "created_at", "is_sent", "message_prettified")
+    list_display = ("id", "__str__", "created_at", "is_sent")
+    list_filter = ("created_at", "is_sent")
+
+    # For increasing listing performance
+    show_full_result_count = False
+    paginator = Paginator
+
+    def has_delete_permission(self, request, obj=None):
+        return False
+
+    def has_add_permission(self, request):
+        return False
+
+    def has_change_permission(self, request, obj=None):
+        return False
+
+    @admin.display(description="message")
+    def message_prettified(self, instance):
+        """Format the message to be a bit a more user-friendly."""
+        message = json.dumps(instance.message, indent=2, sort_keys=True)
+        content = f"<pre>{escape(message)}</pre>"
+        return mark_safe(content)

django_resilient_logger-0.1.0/resilient_logger/apps.py

@@ -0,0 +1,5 @@
+from django.apps import AppConfig
+        
+class ResilientLoggerConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "resilient_logger"

django_resilient_logger-0.1.0/resilient_logger/elasticsearch_submitter.py

@@ -0,0 +1,55 @@
+import logging
+from typing import Optional, Type, override
+from elasticsearch import Elasticsearch
+from resilient_logger.abstract_log_facade import AbstractLogFacade
+from resilient_logger.abstract_submitter import AbstractSubmitter
+
+logger = logging.getLogger(__name__)
+
+# Constants
+ES_STATUS_CREATED = "created"
+
+class ElasticsearchSubmitter(AbstractSubmitter):
+    """
+    Submitter class that sends the resilient log entries to Elasticsearch.
+    """
+    _client: Elasticsearch
+    _index: str
+
+    def __init__(self,
+            log_facade: Type[AbstractLogFacade],
+            client: Elasticsearch,
+            index: str,
+            batch_limit: int = 5000,
+            chunk_size: int = 500,
+    ) -> None:
+        super().__init__(log_facade, batch_limit, chunk_size)
+
+        if not client:
+            raise Exception(f"ElasticsearchSubmitter is missing required argument client.")
+
+        if not index:
+            raise Exception(f"ElasticsearchSubmitter is missing required argument index.")
+        
+        self._index = index
+        self._client = client
+    
+    @override
+    def _submit_entry(self, entry: AbstractLogFacade) -> Optional[str]:
+        document = entry.get_context()
+        document["level"] = entry.get_level()
+        document["message"] = entry.get_message()
+
+        response = self._client.index(
+            index=self._index,
+            id=str(entry.get_id()),
+            document=document,
+            op_type="create",
+        )
+
+        logger.info(f"Sending status: {response}")
+
+        if response.get("result") == ES_STATUS_CREATED:
+            return response.get("_id")
+        
+        return None

django_resilient_logger-0.1.0/resilient_logger/handlers.py

@@ -0,0 +1,48 @@
+import logging
+from collections.abc import Callable
+from functools import cached_property
+from resilient_logger.abstract_log_facade import AbstractLogFacade
+from resilient_logger.abstract_submitter import AbstractSubmitter
+from typing import Dict, Optional
+from resilient_logger.utils import dynamic_class, get_log_record_extra
+
+logger = logging.getLogger(__name__)
+
+class ResilientLogHandler(logging.Handler):
+    _submitter_construct: Optional[Callable[[], AbstractSubmitter]]
+
+    def __init__(self, submitter: Dict, log_facade: Dict, level: int = logging.NOTSET):
+        super().__init__(level)
+
+        def submitter_construct():
+            """
+            Submitter rely on Django's DB models and cannot be instantiated during init since Django app registry is not ready by then.
+            Work around this by doing lazy initialization when the submitter is used first time.
+            """
+
+            submitter_args = submitter.copy()
+            submitter_class = submitter_args.pop('class')
+
+            log_facade_args = log_facade.copy()
+            log_facade_class = log_facade_args.pop('class')
+
+            Submitter = dynamic_class(AbstractSubmitter, submitter_class)
+            LogFacade = dynamic_class(AbstractLogFacade, log_facade_class)
+
+            instance = Submitter(**submitter_args, log_facade=LogFacade)
+            return instance
+
+        self._submitter_construct = submitter_construct
+
+    def emit(self, record: logging.LogRecord):
+        self._submitter.submit(record.levelno, record.getMessage(), get_log_record_extra(record))
+
+    @cached_property
+    def _submitter(self) -> AbstractSubmitter:
+        if self._submitter_construct is None:
+            raise Exception("Unable to proceed without lazy constructor")
+        
+        instance = self._submitter_construct()
+        self._submitter_construct = None
+        return instance
+    

django_resilient_logger-0.1.0/resilient_logger/migrations/0001_initial.py

@@ -0,0 +1,28 @@
+# Generated by Django 5.1.7 on 2025-04-10 10:10
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='ResilientLogEntry',
+            fields=[
+                ('id', models.AutoField(primary_key=True, serialize=False)),
+                ('is_sent', models.BooleanField(default=False, verbose_name='is sent')),
+                ('level', models.IntegerField(default=0, verbose_name='level')),
+                ('message', models.JSONField(verbose_name='message')),
+                ('context', models.JSONField(null=True, verbose_name='context')),
+                ('created_at', models.DateTimeField(auto_now_add=True, verbose_name='created at')),
+            ],
+            options={
+                'verbose_name_plural': 'resilient log entries',
+            },
+        ),
+    ]

django_resilient_logger-0.1.0/resilient_logger/models.py

@@ -0,0 +1,14 @@
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+
+
+class ResilientLogEntry(models.Model):
+    id = models.AutoField(primary_key=True)
+    is_sent = models.BooleanField(default=False, verbose_name=_("is sent"))
+    level = models.IntegerField(verbose_name=_("level"), default=0)
+    message = models.JSONField(verbose_name=_("message"))
+    context = models.JSONField(verbose_name=_("context"), null=True)
+    created_at = models.DateTimeField(auto_now_add=True, verbose_name=_("created at"))
+
+    class Meta:
+        verbose_name_plural = "resilient log entries"

django_resilient_logger-0.1.0/resilient_logger/proxy_submitter.py

@@ -0,0 +1,25 @@
+import logging
+import uuid
+from typing import Optional, Type, override
+from resilient_logger.abstract_log_facade import AbstractLogFacade
+from resilient_logger.abstract_submitter import AbstractSubmitter
+
+class ProxySubmitter(AbstractSubmitter):
+    """
+    Submitter class that sends the resilient log entries to another logger.
+    """
+    _logger: logging.Logger
+
+    def __init__(self,
+            log_facade: Type[AbstractLogFacade],
+            name: str = __name__,
+            batch_limit: int = 5000,
+            chunk_size: int = 500,
+    ) -> None:
+        super().__init__(log_facade, batch_limit, chunk_size)
+        self._logger = logging.getLogger(name)
+    
+    @override
+    def _submit_entry(self, entry: AbstractLogFacade) -> Optional[str]:
+        self._logger.log(entry.get_level(), entry.get_message(), extra=entry.get_context() or {})
+        return str(uuid.uuid4())

django_resilient_logger-0.1.0/resilient_logger/resilient_log_facade.py

@@ -0,0 +1,67 @@
+from datetime import timedelta, datetime
+from django.db import transaction
+from resilient_logger.abstract_log_facade import AbstractLogFacade
+from resilient_logger.models import ResilientLogEntry
+from typing import Any, Generator, Self, Union, override
+
+class ResilientLogFacade(AbstractLogFacade):
+    _log: ResilientLogEntry
+
+    def __init__(self, log: ResilientLogEntry):
+        self._log = log
+
+    @override
+    def get_id(self) -> Union[str, int]:
+        return self._log.id
+
+    @override
+    def get_level(self) -> int:
+        return self._log.level
+    
+    @override
+    def get_message(self) -> Any:
+        return self._log.message
+    
+    @override
+    def get_context(self) -> Any:
+        return self._log.context
+    
+    @override
+    def is_sent(self) -> bool:
+        return self._log.is_sent
+
+    @override
+    def mark_sent(self) -> None:
+        self._log.is_sent = True
+        self._log.save(update_fields=["is_sent"])
+
+    @override
+    @classmethod
+    @transaction.atomic
+    def create(cls, level: int, message: Any, context: Any) -> Self:
+        entry = ResilientLogEntry.objects.create(level=level, message=message, context=context)
+        return cls(entry)
+    
+    @override
+    @classmethod
+    @transaction.atomic
+    def get_unsent_entries(cls, chunk_size: int) -> Generator[AbstractLogFacade, None, None]:
+        entries = (
+            ResilientLogEntry
+                .objects
+                .filter(is_sent=False)
+                .order_by("created_at")
+                .iterator(chunk_size=chunk_size)
+        )
+
+        for entry in entries:
+            yield ResilientLogFacade(entry)
+
+    @override
+    @classmethod
+    @transaction.atomic
+    def clear_sent_entries(cls, days_to_keep: int = 30) -> None:
+        ResilientLogEntry.objects.filter(
+            is_sent=True,
+            created_at__lte=(datetime.now() - timedelta(days=days_to_keep)),
+        ).select_for_update().delete()

django_resilient_logger-0.1.0/resilient_logger/tests/test_admin.py

@@ -0,0 +1,31 @@
+from unittest.mock import Mock
+
+import pytest
+from django.contrib.admin import AdminSite
+
+from resilient_logger.admin import ResilientLogEntryAdmin
+from resilient_logger.models import ResilientLogEntry
+
+
+@pytest.mark.django_db
+def test_resilient_logger_admin_message_prettified(superuser):
+    request = Mock(user=superuser)
+    model_admin = ResilientLogEntryAdmin(ResilientLogEntry, AdminSite())
+    assert list(model_admin.get_fields(request)) == [
+        "id",
+        "created_at",
+        "is_sent",
+        "message_prettified",
+    ]
+
+
+@pytest.mark.django_db
+def test_resilient_logger_admin_permissions(superuser):
+    request = Mock(user=superuser)
+    log_entry = ResilientLogEntry.objects.create(message={})
+    model_admin = ResilientLogEntryAdmin(ResilientLogEntry, AdminSite())
+    # The user should have permission to view, but not modify or delete resilient logs
+    assert model_admin.has_view_permission(request, log_entry)
+    assert not model_admin.has_add_permission(request)
+    assert not model_admin.has_change_permission(request, log_entry)
+    assert not model_admin.has_delete_permission(request, log_entry)

django_resilient_logger-0.1.0/resilient_logger/utils.py

@@ -0,0 +1,55 @@
+from importlib import import_module
+import logging
+from typing import Type, TypeVar
+
+BUILTIN_LOG_RECORD_ATTRS = {
+    'args',
+    'asctime',
+    'created',
+    'exc_info',
+    'exc_text',
+    'filename',
+    'funcName',
+    'levelname',
+    'levelno',
+    'lineno',
+    'module',
+    'msecs',
+    'message',
+    'msg',
+    'name',
+    'pathname',
+    'process',
+    'processName',
+    'relativeCreated',
+    'stack_info',
+    'taskName',
+    'thread',
+    'threadName',
+}
+
+TClass = TypeVar("TClass")
+
+def dynamic_class(type: Type[TClass], class_path: str) -> Type[TClass]:
+    """
+    Loads dynamically class of given type from class_path
+    and ensures it's sub-class of given input type.
+    """
+    parts = class_path.split('.')
+    class_name = parts.pop()
+    module_name = '.'.join(parts)
+    module = import_module(module_name)
+    cls = getattr(module, class_name)
+
+    if not issubclass(cls, type):
+        raise Exception(f"Class '{class_path}' is not sub-class of the {type}.")
+    
+    return cls
+
+def get_log_record_extra(record: logging.LogRecord):
+    """Returns `extra` passed to the logger."""
+    return {
+        name: record.__dict__[name]
+        for name in record.__dict__
+        if name not in BUILTIN_LOG_RECORD_ATTRS
+    }