Suppressing Django's Default 404 Warning Logs

You can suppress Django's default 404 warning logs while still maintaining your custom error logging by using Django's logging configuration. Here are a few approaches to solve your specific issue:

1. Use a Custom Exception Middleware

Create a custom middleware that catches your specific exceptions and prevents them from being logged by Django's default logger:

PYTHONCopied
class SuppressWarningMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        response = self.get_response(request)
        # Mark responses that shouldn't be logged
        if hasattr(response, 'no_log') and response.no_log:
            request.no_log = True
        return response

Then modify your view to mark the response:

PYTHONCopied
def view_foobar(request, node=None, tag=None):
    try:
        machines = Machine.objects.filter(something...)
    except ObjectDoesNotExist:
        logger.error(f"Node {node} not found .....")
        response = HttpResponse("Not found", status=404, content_type="text/plain")
        response.no_log = True
        return response

Add this middleware to your MIDDLEWARE setting before Django's middleware.

2. Configure Django's Logging System

A more direct approach is to configure Django's logging system to filter out these specific warnings:

PYTHONCopied
# In your settings.py
LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'filters': {
        'exclude_404_warnings': {
            '()': 'django.utils.log.CallbackFilter',
            'callback': lambda record: not (
                record.levelname == 'WARNING' and 
                record.name == 'django.request' and 
                'Not Found' in record.getMessage()
            )
        },
    },
    'handlers': {
        'django_request': {
            'level': 'WARNING',
            'filters': ['exclude_404_warnings'],
            'class': 'logging.StreamHandler',
        },
    },
    'loggers': {
        'django.request': {
            'handlers': ['django_request'],
            'level': 'WARNING',
            'propagate': False,
        },
    }
}

3. Use Django's Built-in 404 Exception

Instead of returning an HttpResponse with a 404 status, raise Django's Http404 exception but configure the logging to ignore it:

PYTHONCopied
from django.http import Http404

def view_foobar(request, node=None, tag=None):
    try:
        machines = Machine.objects.filter(something...)
    except ObjectDoesNotExist:
        logger.error(f"Node {node} not found .....")
        raise Http404("Not found")

Then in your settings.py, configure logging to ignore these specific 404s:

PYTHONCopied
LOGGING = {
    # ... other logging configuration
    'loggers': {
        'django.request': {
            'handlers': ['console'],
            'level': 'ERROR',  # Change from WARNING to ERROR
            'propagate': True,
        },
    }
}

This will only log actual errors, not warnings like 404s.

4. Create a Custom 404 View

You can also create a custom 404 view that handles your specific case:

PYTHONCopied
# In your views.py
def custom_404_view(request, exception=None):
    # This won't be logged by Django's default logger
    return HttpResponse("Not found", status=404, content_type="text/plain")

# In your urls.py
handler404 = 'yourapp.views.custom_404_view'

This approach works well if you want a consistent 404 handling across your application.

Each of these approaches has its advantages depending on your specific requirements. The logging configuration approach (#2) is probably the most direct solution to your specific problem.