exceptbot-drf 1.0.0__py3-none-any.whl

exceptbot/__init__.py

@@ -0,0 +1 @@
+default_app_config = 'exceptbot.apps.ExceptBotConfig'

exceptbot/admin.py

@@ -0,0 +1,260 @@
+from django.contrib import admin
+from django.utils import timezone
+from django.utils.html import format_html
+
+from .models import ExceptionLog, AppSettings
+
+
+@admin.register(ExceptionLog)
+class ExceptionLogAdmin(admin.ModelAdmin):
+    list_display = (
+        'id',
+        'exception_type',
+        'short_url',
+        'http_method',
+        'status_code',
+        'source_badge',
+        'file_name_short',
+        'line_number',
+        'user',
+        'count',
+        'is_resolved_badge',
+        'timestamp',
+    )
+
+    list_filter = (
+        'is_resolved',
+        'source',
+        'http_method',
+        'status_code',
+        'exception_type',
+        'timestamp',
+        'user',
+    )
+
+    search_fields = (
+        'exception_type',
+        'url_path',
+        'file_name',
+        'full_error_message',
+        'error_line_content',
+        'user__username',
+        'user__email',
+    )
+
+    readonly_fields = (
+        'url_path',
+        'http_method',
+        'status_code',
+        'source',
+        'request_data_display',
+        'ip_address',
+        'user_agent',
+        'exception_type',
+        'full_error_message_display',
+        'file_name',
+        'file_content_display',
+        'line_number',
+        'error_line_content',
+        'user',
+        'timestamp',
+        'count',
+        'resolved_at',
+        'ai_suggestion_display',
+    )
+
+    ordering = ('-timestamp',)
+
+    list_per_page = 25
+
+    fieldsets = (
+        ('error info', {
+            'fields': (
+                'exception_type',
+                'url_path',
+                'http_method',
+                'status_code',
+                'source',
+                'timestamp',
+                'count',
+            )
+        }),
+        (' position of code', {
+            'fields': (
+                'file_name',
+                'line_number',
+                'error_line_content',
+                'file_content_display',
+            )
+        }),
+        (' request information', {
+            'fields': (
+                'request_data_display',
+                'ip_address',
+                'user_agent',
+            ),
+            'classes': ('collapse',),
+        }),
+        (' error message', {
+            'fields': (
+                'full_error_message_display',
+            ),
+            'classes': ('collapse',),
+        }),
+        ('user and status resolved', {
+            'fields': (
+                'user',
+                'is_resolved',
+                'resolved_by',
+                'resolved_at',
+                'resolution_note',
+            )
+        }),
+        ('suggestion of ai', {
+            'fields': (
+                'ai_suggestion_display',
+            ),
+            'classes': ('collapse',),
+        }),
+    )
+
+    # actions = ['mark_as_resolved', 'mark_as_unresolved']
+
+    @admin.display(description='URL')
+    def short_url(self, obj):
+        if len(obj.url_path) > 40:
+            return obj.url_path[:40] + '...'
+        return obj.url_path
+
+    @admin.display(description='File')
+    def file_name_short(self, obj):
+        if not obj.file_name:
+            return '-'
+        return obj.file_name.split('/')[-1].split('\\')[-1]
+
+    @admin.display(description='Source')
+    def source_badge(self, obj):
+        colors = {
+            'backend': '#007bff',
+            'frontend': '#28a745',
+            'unknown': '#6c757d',
+        }
+        color = colors.get(obj.source, '#6c757d')
+        return format_html(
+            '<span style="background:{};color:white;padding:2px 8px;'
+            'border-radius:4px;font-size:11px;">{}</span>',
+            color,
+            obj.get_source_display(),
+        )
+
+    @admin.display(description='وضعیت', boolean=True)
+    def is_resolved_badge(self, obj):
+        return obj.is_resolved
+
+    @admin.display(description='Request Data')
+    def request_data_display(self, obj):
+        if not obj.request_data:
+            return '-'
+        import json
+        pretty = json.dumps(obj.request_data, indent=2, ensure_ascii=False)
+        return format_html(
+            '<pre style="background:#f8f9fa;padding:10px;'
+            'border-radius:4px;max-height:400px;overflow:auto;">{}</pre>',
+            pretty,
+        )
+
+    @admin.display(description='Full Error Message')
+    def full_error_message_display(self, obj):
+        if not obj.full_error_message:
+            return '-'
+        return format_html(
+            '<pre style="background:#fff3cd;padding:10px;'
+            'border-radius:4px;max-height:400px;overflow:auto;'
+            'white-space:pre-wrap;">{}</pre>',
+            obj.full_error_message,
+        )
+
+    @admin.display(description='File Content')
+    def file_content_display(self, obj):
+        if not obj.file_content:
+            return '-'
+        return format_html(
+            '<pre style="background:#f8f9fa;padding:10px;'
+            'border-radius:4px;max-height:500px;overflow:auto;'
+            'white-space:pre-wrap;">{}</pre>',
+            obj.file_content,
+        )
+
+    @admin.display(description='AI Suggestion')
+    def ai_suggestion_display(self, obj):
+        if not obj.ai_suggestion:
+            return 'هنوز پیشنهادی ساخته نشده است.'
+        return format_html(
+            '<div style="background:#e7f3ff;padding:15px;'
+            'border-radius:4px;max-height:600px;overflow:auto;'
+            'white-space:pre-wrap;">{}</div>',
+            obj.ai_suggestion,
+        )
+
+    @admin.action(description='✅ علامت‌گذاری به‌عنوان رفع‌شده')
+    def mark_as_resolved(self, request, queryset):
+        updated = queryset.update(
+            is_resolved=True,
+            resolved_by=request.user,
+            resolved_at=timezone.now(),
+        )
+        self.message_user(
+            request,
+            f'{updated} خطا به‌عنوان رفع‌شده علامت‌گذاری شد.'
+        )
+
+    @admin.action(description='↩️ برگرداندن به حالت رفع‌نشده')
+    def mark_as_unresolved(self, request, queryset):
+        updated = queryset.update(
+            is_resolved=False,
+            resolved_by=None,
+            resolved_at=None,
+            resolution_note='',
+        )
+        self.message_user(
+            request,
+            f'{updated} خطا به حالت رفع‌نشده برگشت.'
+        )
+
+    def has_add_permission(self, request):
+        return False
+
+    def has_change_permission(self, request, obj=None):
+        return True
+
+
+@admin.register(AppSettings)
+class AppSettingsAdmin(admin.ModelAdmin):
+    list_display = (
+        'id',
+        'project_name',
+        'base_url',
+        'has_openai_key',
+    )
+
+    fieldsets = (
+        ('اطلاعات پروژه', {
+            'fields': ('project_name', 'base_url'),
+        }),
+        ('تنظیمات هوش مصنوعی', {
+            'fields': ('openai_api_key',),
+            'description': 'برای دریافت پیشنهاد AI، کلید OpenAI خود را وارد کنید.',
+        }),
+    )
+
+    @admin.display(description='OpenAI Key', boolean=True)
+    def has_openai_key(self, obj):
+        return bool(obj.openai_api_key)
+
+    def has_add_permission(self, request):
+        if AppSettings.objects.exists():
+            return False
+        return super().has_add_permission(request)
+
+    def has_delete_permission(self, request, obj=None):
+        return False

exceptbot/apps.py

@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+
+
+class ExceptBotConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'exceptbot'
+    verbose_name = "ExceptBot: Exception Logger with AI Suggestions"

exceptbot/middleware.py

@@ -0,0 +1,126 @@
+import sys
+import traceback
+
+from django.db import transaction
+from django.utils import timezone
+from .models import ExceptionLog, AppSettings
+SENSITIVE_FIELDS = {
+    'password', 'password1', 'password2',
+    'token', 'access', 'refresh',
+    'secret', 'api_key', 'authorization',
+}
+
+def mask_sensitive_data(data):
+    if not isinstance(data, dict):
+        return data
+
+    masked = {}
+    for key, value in data.items():
+        if key.lower() in SENSITIVE_FIELDS:
+            masked[key] = '***MASKED***'
+        elif isinstance(value, dict):
+            masked[key] = mask_sensitive_data(value)
+        elif isinstance(value, list):
+            masked[key] = [
+                mask_sensitive_data(item) if isinstance(item, dict) else item
+                for item in value
+            ]
+        else:
+            masked[key] = value
+    return masked
+
+
+class ExceptBotMiddleware:
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        response = self.get_response(request)
+        return response
+
+    def process_exception(self, request, exception):
+        user = None
+        if hasattr(request, 'user') and request.user.is_authenticated:
+            user = request.user
+        app_settings = AppSettings.get_solo()
+        project_name = app_settings.project_name or ''
+        exc_type, exc_value, exc_traceback = sys.exc_info()
+        formatted_traceback = traceback.extract_tb(exc_traceback)
+
+        file_name = None
+        line_number = None
+        error_line_content = None
+        if project_name:
+            for stack in reversed(formatted_traceback):
+                if project_name in stack.filename:
+                    file_name = stack.filename
+                    line_number = stack.lineno
+                    error_line_content = stack.line
+                    break
+        if not file_name and formatted_traceback:
+            stack = formatted_traceback[-1]
+            file_name = stack.filename
+            line_number = stack.lineno
+            error_line_content = stack.line
+
+        full_error_message = ''.join(
+            traceback.format_exception(exc_type, exc_value, exc_traceback)
+        )
+        file_content = ''
+        try:
+            with open(file_name, 'r', encoding='utf-8') as file:
+                file_content = file.read()
+        except (FileNotFoundError, PermissionError, UnicodeDecodeError, TypeError):
+            file_content = f"# Could not read file: {file_name}"
+        url_path = request.path
+        exception_type = str(type(exception).__name__)
+        http_method = request.method
+        status_code = 500
+        source = request.META.get('HTTP_X_CLIENT_TYPE', 'backend').lower()
+        if source not in ('backend', 'frontend'):
+            source = 'unknown'
+        x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
+        if x_forwarded_for:
+            ip_address = x_forwarded_for.split(',')[0].strip()
+        else:
+            ip_address = request.META.get('REMOTE_ADDR')
+        user_agent = request.META.get('HTTP_USER_AGENT', '')[:1000]
+
+        request_data = None
+        try:
+            if hasattr(request, 'data'):
+                request_data = mask_sensitive_data(dict(request.data))
+            elif http_method in ('POST', 'PUT', 'PATCH'):
+                request_data = mask_sensitive_data(dict(request.POST))
+        except Exception:
+            request_data = None
+        with transaction.atomic():
+            existing_exception = ExceptionLog.objects.filter(
+                exception_type=exception_type,
+                file_name=file_name,
+                is_resolved=False,
+            ).first()
+
+            if existing_exception:
+                existing_exception.count += 1
+                existing_exception.timestamp = timezone.now()
+                existing_exception.save(update_fields=['count', 'timestamp'])
+            else:
+                ExceptionLog.objects.create(
+                    url_path=url_path,
+                    exception_type=exception_type,
+                    full_error_message=full_error_message,
+                    file_name=file_name,
+                    file_content=file_content,
+                    line_number=line_number,
+                    error_line_content=error_line_content,
+                    user=user,
+                    http_method=http_method,
+                    status_code=status_code,
+                    source=source,
+                    ip_address=ip_address,
+                    user_agent=user_agent,
+                    request_data=request_data,
+                )
+
+        return None

exceptbot/migrations/0001_initial.py

@@ -0,0 +1,63 @@
+# Generated by Django 6.1.1 on 2026-09-16 08:05
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='AppSettings',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('openai_api_key', models.CharField(blank=True, help_text="Required for AI recommendations. Get an OpenAI account; google 'openai api key'", max_length=255, null=True)),
+                ('base_url', models.CharField(blank=True, help_text='ex: https://exceptbot.com', max_length=255, null=True)),
+                ('project_name', models.CharField(blank=True, help_text="The directory name of your project. Ex: 'exceptbot'", max_length=255, null=True)),
+            ],
+            options={
+                'verbose_name': 'App Setting',
+                'verbose_name_plural': 'App Settings',
+            },
+        ),
+        migrations.CreateModel(
+            name='ExceptionLog',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('exception_type', models.CharField(db_index=True, max_length=255)),
+                ('full_error_message', models.TextField(blank=True)),
+                ('file_name', models.CharField(db_index=True, max_length=500)),
+                ('file_content', models.TextField(blank=True)),
+                ('line_number', models.PositiveIntegerField(blank=True, null=True)),
+                ('error_line_content', models.TextField(blank=True)),
+                ('url_path', models.TextField(db_index=True)),
+                ('http_method', models.CharField(db_index=True, default='GET', max_length=10)),
+                ('status_code', models.PositiveIntegerField(blank=True, db_index=True, null=True)),
+                ('source', models.CharField(choices=[('backend', 'Backend'), ('frontend', 'Frontend'), ('unknown', 'Unknown')], db_index=True, default='backend', max_length=20)),
+                ('request_data', models.JSONField(blank=True, null=True)),
+                ('ip_address', models.GenericIPAddressField(blank=True, null=True)),
+                ('user_agent', models.TextField(blank=True)),
+                ('timestamp', models.DateTimeField(auto_now_add=True, db_index=True)),
+                ('is_resolved', models.BooleanField(db_index=True, default=False)),
+                ('resolved_at', models.DateTimeField(blank=True, null=True)),
+                ('resolution_note', models.TextField(blank=True, default='')),
+                ('ai_suggestion', models.TextField(blank=True, null=True)),
+                ('count', models.PositiveIntegerField(default=1)),
+                ('resolved_by', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='resolved_exceptions', to=settings.AUTH_USER_MODEL)),
+                ('user', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='caused_exceptions', to=settings.AUTH_USER_MODEL)),
+            ],
+            options={
+                'verbose_name': 'Exception Log',
+                'verbose_name_plural': 'Exception Logs',
+                'ordering': ['-timestamp'],
+                'indexes': [models.Index(fields=['is_resolved', '-timestamp'], name='exceptbot_e_is_reso_f0a0d5_idx'), models.Index(fields=['exception_type', 'file_name', 'is_resolved'], name='exceptbot_e_excepti_0cf5b5_idx'), models.Index(fields=['source', 'is_resolved'], name='exceptbot_e_source_e78949_idx')],
+            },
+        ),
+    ]

exceptbot/models.py

@@ -0,0 +1,134 @@
+import re
+
+from django.conf import settings
+from django.db import models
+from django.utils import timezone
+
+
+class ExceptionLog(models.Model):
+    SOURCE_CHOICES = [
+        ('backend', 'Backend'),
+        ('frontend', 'Frontend'),
+        ('unknown', 'Unknown'),
+    ]
+    exception_type = models.CharField(max_length=255, db_index=True)
+    full_error_message = models.TextField(blank=True)
+    file_name = models.CharField(max_length=500, db_index=True)
+    file_content = models.TextField(blank=True)
+    line_number = models.PositiveIntegerField(null=True, blank=True)
+    error_line_content = models.TextField(blank=True)
+    url_path = models.TextField(db_index=True)
+    http_method = models.CharField(max_length=10, default='GET', db_index=True)
+    status_code = models.PositiveIntegerField(null=True, blank=True, db_index=True)
+    source = models.CharField(
+        max_length=20,
+        choices=SOURCE_CHOICES,
+        default='backend',
+        db_index=True,
+    )
+    request_data = models.JSONField(null=True, blank=True)
+    ip_address = models.GenericIPAddressField(null=True, blank=True)
+    user_agent = models.TextField(blank=True)
+    user = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        related_name='caused_exceptions',
+        null=True, blank=True,
+        on_delete=models.SET_NULL,
+        db_index=True,
+    )
+    timestamp = models.DateTimeField(auto_now_add=True, db_index=True)
+    is_resolved = models.BooleanField(default=False, db_index=True)
+    resolved_by = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        related_name='resolved_exceptions',
+        null=True, blank=True,
+        on_delete=models.SET_NULL,
+    )
+    resolved_at = models.DateTimeField(null=True, blank=True)
+    resolution_note = models.TextField(blank=True, default='')
+    ai_suggestion = models.TextField(null=True, blank=True)
+    count = models.PositiveIntegerField(default=1)
+
+    class Meta:
+        ordering = ['-timestamp']
+        verbose_name = 'Exception Log'
+        verbose_name_plural = 'Exception Logs'
+        indexes = [
+            models.Index(fields=['is_resolved', '-timestamp']),
+            models.Index(fields=['exception_type', 'file_name', 'is_resolved']),
+            models.Index(fields=['source', 'is_resolved']),
+        ]
+
+    def __str__(self):
+        return f"[{self.source}] {self.exception_type} at {self.url_path}"
+
+    def mark_resolved(self, user, note=''):
+        self.is_resolved = True
+        self.resolved_by = user
+        self.resolved_at = timezone.now()
+        self.resolution_note = note
+        self.save()
+
+    def get_blocks(self):
+        if not self.ai_suggestion:
+            return []
+        blocks = re.split(r'(```[a-zA-Z]*\n)', self.ai_suggestion)
+        formatted_blocks = []
+        in_code_block = False
+        language = None
+        for block in blocks:
+            if block.startswith('```'):
+                in_code_block = not in_code_block
+                language = block[3:].strip()
+                if language == '':
+                    language = None
+            elif in_code_block:
+                formatted_blocks.append({
+                    'text': block.strip(),
+                    'is_code': True,
+                    'language': language,
+                })
+            else:
+                formatted_blocks.append({
+                    'text': block,
+                    'is_code': False,
+                    'language': None,
+                })
+        return formatted_blocks
+
+
+class AppSettings(models.Model):
+    openai_api_key = models.CharField(
+        max_length=255,
+        blank=True,
+        null=True,
+        help_text="Required for AI recommendations. Get an OpenAI account; google 'openai api key'",
+    )
+    base_url = models.CharField(
+        max_length=255,
+        blank=True,
+        null=True,
+        help_text="ex: https://exceptbot.com",
+    )
+    project_name = models.CharField(
+        max_length=255,
+        blank=True,
+        null=True,
+        help_text="The directory name of your project. Ex: 'exceptbot'",
+    )
+
+    class Meta:
+        verbose_name = 'App Setting'
+        verbose_name_plural = 'App Settings'
+
+    def __str__(self):
+        return self.project_name or 'App Settings'
+
+    def save(self, *args, **kwargs):
+        self.pk = 1
+        super().save(*args, **kwargs)
+
+    @classmethod
+    def get_solo(cls):
+        obj, _ = cls.objects.get_or_create(pk=1)
+        return obj

exceptbot/permissions.py

@@ -0,0 +1,11 @@
+from rest_framework.permissions import BasePermission
+
+class IsSuperUser(BasePermission):
+    message = 'Only superusers can access ExceptBot endpoints.'
+
+    def has_permission(self, request, view):
+        return bool(
+            request.user
+            and request.user.is_authenticated
+            and request.user.is_superuser
+        )

exceptbot/serializers.py

@@ -0,0 +1,65 @@
+from rest_framework import serializers
+from .models import ExceptionLog, AppSettings
+
+
+class ExceptionLogListSerializer(serializers.ModelSerializer):
+    user = serializers.StringRelatedField(read_only=True)
+    resolved_by = serializers.StringRelatedField(read_only=True)
+    source_display = serializers.SerializerMethodField()
+
+    class Meta:
+        model = ExceptionLog
+        fields = [
+            'id',
+            'exception_type',
+            'url_path',
+            'http_method',
+            'status_code',
+            'source',
+            'source_display',
+            'file_name',
+            'line_number',
+            'user',
+            'count',
+            'is_resolved',
+            'resolved_by',
+            'resolved_at',
+            'timestamp',
+        ]
+
+    def get_source_display(self, obj):
+        return obj.get_source_display()
+
+
+
+class ExceptionLogDetailSerializer(serializers.ModelSerializer):
+    user = serializers.StringRelatedField(read_only=True)
+    resolved_by = serializers.StringRelatedField(read_only=True)
+    source_display = serializers.SerializerMethodField()
+
+    class Meta:
+        model = ExceptionLog
+        fields = '__all__'
+
+    def get_source_display(self, obj):
+        return obj.get_source_display()
+
+
+
+class ExceptionLogResolveSerializer(serializers.Serializer):
+    resolution_note = serializers.CharField(
+        required=False,
+        allow_blank=True,
+        default='',
+        max_length=2000,
+    )
+
+
+
+class AppSettingsSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = AppSettings
+        fields = ['openai_api_key', 'base_url', 'project_name']
+        extra_kwargs = {
+            'openai_api_key': {'write_only': False, 'required': False},
+        }