Quali sono alcune alternative leggere a django-sentry per la registrazione?

Question

Esistono alternative leggere a django-sentry per la registrazione degli errori in un ambiente Django?

Ho utilizzato django-db-log in precedenza, ora noto come django-sentry. Alcuni degli altri che ho trovato erano praticamente morti perché non avevano quasi commesso negli ultimi due anni.

Grazie.

Answer 1

La sentinella è in overkill e Djangodblog è deprecato, ho fatto il mio, cannibalizzando le parti necessarie da entrambi.

Come funziona è catturando il segnale di errore. Quindi usa il reporter delle eccezioni integrato di Django per generare la pagina di errore 500 fantasiosa che Django visualizza quando il debug è abilitato. Lo memorizziamo nel DB e lo rendiamo nella console di amministrazione.

Ecco la mia realizzazione:

Modello:

class Error(Model): 
    """ 
    Model for storing the individual errors. 
    """ 
    kind = CharField(_('type'), 
     null=True, blank=True, max_length=128, db_index=True 
    ) 
    info = TextField(
     null=False, 
    ) 
    data = TextField(
     blank=True, null=True 
    ) 
    path = URLField(
     null=True, blank=True, verify_exists=False, 
    ) 
    when = DateTimeField(
     null=False, auto_now_add=True, db_index=True, 
    ) 
    html = TextField(
     null=True, blank=True, 
    ) 

    class Meta: 
     """ 
     Meta information for the model. 
     """ 
     verbose_name = _('Error') 
     verbose_name_plural = _('Errors') 

    def __unicode__(self): 
     """ 
     String representation of the object. 
     """ 
     return "%s: %s" % (self.kind, self.info) 

Admin:

class ErrorAdmin(admin.ModelAdmin): 
    list_display = ('path', 'kind', 'info', 'when') 
    list_display_links = ('path',) 
    ordering  = ('-id',) 
    search_fields = ('path', 'kind', 'info', 'data') 
    readonly_fields = ('path', 'kind', 'info', 'data', 'when', 'html',) 
    fieldsets  = (
     (None, { 
      'fields': ('kind', 'data', 'info') 
     }), 
    ) 

    def has_delete_permission(self, request, obj=None): 
     """ 
     Disabling the delete permissions 
     """ 
     return False 

    def has_add_permission(self, request): 
     """ 
     Disabling the create permissions 
     """ 
     return False 

    def change_view(self, request, object_id, extra_context={}): 
     """ 
     The detail view of the error record. 
     """ 
     obj = self.get_object(request, unquote(object_id)) 

     extra_context.update({ 
      'instance': obj, 
      'error_body': mark_safe(obj.html), 
     }) 

     return super(ErrorAdmin, self).change_view(request, object_id, extra_context) 

admin.site.register(Error, ErrorAdmin) 

Helper:

class LoggingExceptionHandler(object): 
    """ 
    The logging exception handler 
    """ 
    @staticmethod 
    def create_from_exception(sender, request=None, *args, **kwargs): 
     """ 
     Handles the exception upon receiving the signal. 
     """ 
     kind, info, data = sys.exc_info() 

     if not issubclass(kind, Http404): 

      error = Error.objects.create(
       kind = kind.__name__, 
       html = ExceptionReporter(request, kind, info, data).get_traceback_html(), 
       path = request.build_absolute_uri(), 
       info = info, 
       data = '\n'.join(traceback.format_exception(kind, info, data)), 
      ) 
      error.save() 

Init:

from django.core.signals import got_request_exception 

from modules.error.signals import LoggingExceptionHandler 

got_request_exception.connect(LoggingExceptionHandler.create_from_exception) 

Answer 2

C'è anche: http://pypi.python.org/pypi/django-logdb se si desidera qualcosa di più leggero ma ancora pronto per la produzione.