django-api-profiler 0.1.0__py3-none-any.whl

django_api_profiler-0.1.0.dist-info/METADATA

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: django-api-profiler
+Version: 0.1.0
+Summary: Lightweight API profiling and endpoint analytics for Django
+Author: Ahmed
+License: MIT
+License-File: LICENSE
+Keywords: analytics,django,monitoring,performance,profiling
+Classifier: Framework :: Django
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Requires-Dist: django>=4.2
+Provides-Extra: async
+Requires-Dist: celery>=5.6.3; extra == 'async'
+Requires-Dist: redis>=7.4.0; extra == 'async'
+Provides-Extra: beat
+Requires-Dist: django-celery-beat>=2.9.0; extra == 'beat'
+Provides-Extra: postgres
+Requires-Dist: psycopg2-binary>=2.9.12; extra == 'postgres'
+Description-Content-Type: text/markdown
+
+# Django API Profiler
+
+Lightweight API profiling and endpoint analytics for Django.
+
+## Features
+
+- Request latency tracking
+- Endpoint summaries
+- p95 response metrics
+- Error rate monitoring
+- Slow request detection
+- N+1 query detection
+- Django admin integration
+- Optional async ingestion with Celery
+
+---
+
+## Installation
+
+```bash
+pip install django-api-profiler
+```
+
+---
+
+## Quickstart
+
+Add the app:
+
+```python
+INSTALLED_APPS = [
+    ...
+    "django_api_profiler",
+]
+```
+
+Add the middleware:
+
+```python
+MIDDLEWARE = [
+    ...
+    "django_api_profiler.middleware.ApiProfilerMiddleware",
+]
+```
+
+Run migrations:
+
+```bash
+python manage.py migrate
+```
+
+---
+
+## Configuration
+
+```python
+PROFILER = {
+    "ASYNC": False,
+    "SLOW_REQUEST_THRESHOLD_MS": 1000,
+    "AGGREGATION_WINDOW_MINUTES": 60,
+}
+```
+
+---
+
+## Admin Dashboard
+
+The package provides Django admin integration for:
+- endpoint summaries
+- latency metrics
+- error tracking
+- regression detection
+
+---
+
+## Optional Async Support
+
+Install async dependencies:
+
+```bash
+pip install django-api-profiler[async]
+```
+
+Then enable:
+
+```python
+PROFILER = {
+    "ASYNC": True,
+}
+```
+
+---
+
+## License
+
+MIT

django_api_profiler-0.1.0.dist-info/RECORD

@@ -0,0 +1,32 @@
+profiler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+profiler/admin.py,sha256=kargCQz4r6qsEp8eATzUQjdOY32OfdncePyNt-R031s,1729
+profiler/apps.py,sha256=JCzwLf8FhZAwfjC_HqkrzkJVK4B9Va_YJz2Byxw907w,91
+profiler/conf.py,sha256=43xeeREtn6KT95I-_N-hKiFyxIM-gcpME8R9u7Oo3Pc,788
+profiler/db_wrapper.py,sha256=SrLy4_SB3cyw4HssNtfi_8b7tpGL7f8GBWr9Hc3P_e4,1045
+profiler/middleware.py,sha256=D_8vUkuVIoTixKv97RnGGPCZ4rWeVbV9_h8o79Ay2Ds,1768
+profiler/tasks.py,sha256=IExwnEC3I-eTDk6zhnAzIiTMhIKiHMrIdjTN7uuWnsk,358
+profiler/migrations/0001_initial.py,sha256=3dQM7KQTqFwLwgg1xlc2Ftu0a1PG0IVSLp6dJXk1o7A,745
+profiler/migrations/0002_requestmetric_query_count_and_more.py,sha256=c-mY-v3G8zciWvss-AomwN0iq6zCliXpQeWGXPKoUlk,553
+profiler/migrations/0003_requestmetric_exception_message_and_more.py,sha256=sjhnYWokzJaTh4ZWAAOXGaNp6WlMGDXHFEVntWw3xEA,785
+profiler/migrations/0004_requestmetric_is_slow.py,sha256=Nbypm6BumwM9ijJyDrCrbi7bQARtrWnphyqyWcEoCxE,454
+profiler/migrations/0005_requestmetric_ip_address_requestmetric_request_id_and_more.py,sha256=UY6Bt8aheH_LvMDcsH36e96QRMFh9DxcHATAQDtebCM,1989
+profiler/migrations/0006_requestmetric_has_n_plus_one_and_more.py,sha256=wlqGk_YKivo1gKb3cKw9D1g1x9RPfTyommfIKelEAaI,621
+profiler/migrations/0007_endpointsummary.py,sha256=fwgLx730z6SzKpralFxCJFPNEHWJNO7CIq70kCHHa0o,1559
+profiler/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+profiler/models/__init__.py,sha256=dbdflC7cbquUytO_XNQF07H9LNaFarzvcyiF3zAr5uo,87
+profiler/models/endpoint_summary.py,sha256=7LyMvOmU0Q4rO40Hnr15RGnFUkB-q4M-XzA1YNKvvk8,952
+profiler/models/request_metric.py,sha256=IsEYlPIzvHXLU2d0MZZRYG6sUlT7Kv95FESBT1ig-Vw,1458
+profiler/services/__init__.py,sha256=2PsAKTW9kSlKswJVeWFXu--Dy8re8MzZ8IAWCLw1fa8,201
+profiler/services/analytics.py,sha256=KcMp7XRA6KhLYrl3cVrfV28cy66ST0Cleapn82mqR-Q,2568
+profiler/services/n_plus_one.py,sha256=sufELbmhkDFt4vkuINGnVDTrf1ddrfdfRTf0ttbm4Lc,711
+profiler/services/regression.py,sha256=qcmilFm1xGgK0TNqQpsw4pydA7nToWGzqn4w98_wFXc,2053
+profiler/services/request_metric.py,sha256=S4d8JEYs_GvYCzNhfkae1e4Q5_u0ZT9KoZDwMHO5ydA,1414
+profiler/tests/__init__.py,sha256=T_ZL3igsTtCRfEOSnxLhSj_Uaw7tq2tAP2Qp8NxyYL4,124
+profiler/tests/build_metric_payload.py,sha256=xQ5fkyG5fbAySrPszDvjO3_vd0zFXXiibWFhUin-Zjc,362
+profiler/tests/n_plus_one.py,sha256=jy9zRJya11idhwqemgXfjYhrkK58qE9DOJcFmEcpF1g,1521
+profiler/utils/__init__.py,sha256=9lWmF1LLmeeWIgpUoWm2FzJxBnpe6gelscLKNO9fSQ8,36
+profiler/utils/ingestion.py,sha256=0amZE5OR37DVAKNHz9VgsQpGGevI0FvGP_DZEZhitW8,746
+django_api_profiler-0.1.0.dist-info/METADATA,sha256=oZ0_1Wgx3gV02F7uXZwcrIXpxhTAhnWIxZZn-ZKPUig,1900
+django_api_profiler-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+django_api_profiler-0.1.0.dist-info/licenses/LICENSE,sha256=OBnxegkHQTCwyfUgvoG2eNmvWpG9I6FYJTkwfbMtbEU,1061
+django_api_profiler-0.1.0.dist-info/RECORD,,

django_api_profiler-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

django_api_profiler-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ahmed
+
+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.

profiler/admin.py

@@ -0,0 +1,80 @@
+from django.contrib import admin
+from django.utils.html import format_html
+from .models import RequestMetric , EndpointSummary
+
+
+@admin.register(RequestMetric)
+class RequestMetricAdmin(admin.ModelAdmin):
+    list_display = (
+        "path",
+        "method",
+        "status_code",
+        "colored_response_time",
+        "query_count",
+        "total_query_time_ms",
+        "exception_type",
+        "exception_message",
+        "created_at",
+    )
+
+    list_filter = (
+        "method",
+        "status_code",
+        "created_at"
+    )
+
+    readonly_fields = list_display
+
+    ordering = ("-created_at",)
+
+    def colored_response_time(self, obj):
+
+        if obj.response_time_ms > 1000:
+            color = "red"
+
+        elif obj.response_time_ms > 500:
+            color = "orange"
+
+        else:
+            color = "lightgreen"
+
+        formatted_time = f"{obj.response_time_ms:.2f} ms"
+
+        return format_html(
+            '<span style="color: {}; font-weight: bold;">{}</span>',
+            color,
+            formatted_time
+        )
+    
+
+@admin.register(EndpointSummary)
+class EndpointSummaryAdmin(admin.ModelAdmin):
+
+    list_display = (
+        "route",
+        "window_start",
+        "total_requests",
+        "avg_response_ms",
+        "p95_response_ms",
+        "error_count",
+        "slow_count",
+    )
+
+    list_filter = (
+        "window_start",
+        "computed_at",
+    )
+
+    search_fields = ("route",)
+
+    ordering = ("-window_start",)
+
+    readonly_fields = [field.name for field in EndpointSummary._meta.fields]
+
+    date_hierarchy = "window_start"
+
+    def has_add_permission(self, request):
+        return False
+
+    def has_delete_permission(self, request, obj=None):
+        return False

profiler/apps.py

@@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class ProfilerConfig(AppConfig):
+    name = 'profiler'

profiler/conf.py

@@ -0,0 +1,31 @@
+from django.conf import settings
+
+_DEFAULTS = {
+    "ASYNC": False,
+    "SLOW_REQUEST_THRESHOLD_MS": 1000,
+    "AGGREGATION_WINDOW_MINUTES": 60,
+    "IGNORED_PATHS": ["/admin", "/static", "/favicon.ico"],
+    "N_PLUS_ONE_THRESHOLD": 3,
+    "SLOW_QUERY_THRESHOLD_MS": 100,
+    "REGRESSION_RESPONSE_TIME_FACTOR": 2.0,
+    "REGRESSION_ERROR_RATE_DELTA": 0.1,
+}
+
+
+class ProfilerSettings:
+
+    def __init__(self):
+        self._user_settings = getattr(settings, "PROFILER", {})
+
+    def __getattr__(self, name):
+        if name not in _DEFAULTS:
+            raise AttributeError(f"Invalid profiler setting: '{name}'")
+        
+        default = _DEFAULTS[name]
+        user_value = self._user_settings.get(name, default)
+
+        return user_value
+    
+
+
+profiler_settings = ProfilerSettings()

profiler/db_wrapper.py

@@ -0,0 +1,33 @@
+from django.db.backends.utils import CursorWrapper
+import threading
+
+_local = threading.local()
+
+def reset_query_log():
+    _local.queries = []
+
+def get_query_log():
+    return list(getattr(_local, "queries", []))
+
+class ProfilingCursorWrapper(CursorWrapper):
+    def execute(self, sql, params=None):
+        import time
+        start = time.perf_counter()
+        try:
+            return super().execute(sql, params)
+        finally:
+            duration = (time.perf_counter() - start) * 1000
+            if not hasattr(_local, "queries"):
+                _local.queries = []
+            _local.queries.append({"sql": sql, "time_ms": duration})
+
+    def executemany(self, sql, param_list):
+        import time
+        start = time.perf_counter()
+        try:
+            return super().executemany(sql, param_list)
+        finally:
+            duration = (time.perf_counter() - start) * 1000
+            if not hasattr(_local, "queries"):
+                _local.queries = []
+            _local.queries.append({"sql": sql, "time_ms": duration})

profiler/middleware.py

@@ -0,0 +1,58 @@
+import time
+from django.urls import resolve, Resolver404
+from .db_wrapper import reset_query_log ,get_query_log
+from .services import build_metric_payload
+from .tasks import ingest_request_metric
+from .conf import profiler_settings
+from .utils import ingest_metric
+
+class ApiProfilerMiddleware:
+
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+
+        if any(request.path.startswith(path) for path in profiler_settings.IGNORED_PATHS):
+            return self.get_response(request)
+
+        try:
+            url_match = resolve(request.path)
+            route = url_match.route
+            view_name = url_match.view_name
+        except Resolver404:
+            route = request.path
+            view_name = None
+
+        reset_query_log()
+        start_time = time.perf_counter()
+
+        try:
+            response = self.get_response(request)
+            has_exception = False
+            exception = None
+
+        except Exception as e:
+            response = None
+            has_exception = True
+            exception = e
+            raise
+
+        finally:
+
+            payload = build_metric_payload(
+                path=request.path,
+                method=request.method,
+                status_code=response.status_code if response else 500,
+                duration_ms= (time.perf_counter() - start_time) * 1000,
+                route=route,
+                view_name=view_name,
+                has_exception=has_exception,
+                exception_type=type(exception).__name__ if exception else None,
+                exception_message=str(exception) if exception else None,
+                queries=get_query_log(),
+            )
+
+            ingest_metric(payload)
+
+        return response

profiler/migrations/0001_initial.py

@@ -0,0 +1,25 @@
+# Generated by Django 6.0.5 on 2026-05-09 13:00
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='RequestMetric',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('path', models.CharField(max_length=255)),
+                ('method', models.CharField(max_length=10)),
+                ('status_code', models.IntegerField()),
+                ('response_time_ms', models.FloatField()),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+            ],
+        ),
+    ]

profiler/migrations/0002_requestmetric_query_count_and_more.py

@@ -0,0 +1,23 @@
+# Generated by Django 6.0.5 on 2026-05-09 13:07
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('profiler', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='requestmetric',
+            name='query_count',
+            field=models.IntegerField(default=0),
+        ),
+        migrations.AddField(
+            model_name='requestmetric',
+            name='total_query_time_ms',
+            field=models.FloatField(default=0),
+        ),
+    ]

profiler/migrations/0003_requestmetric_exception_message_and_more.py

@@ -0,0 +1,28 @@
+# Generated by Django 6.0.5 on 2026-05-09 13:50
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('profiler', '0002_requestmetric_query_count_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='requestmetric',
+            name='exception_message',
+            field=models.TextField(blank=True, null=True),
+        ),
+        migrations.AddField(
+            model_name='requestmetric',
+            name='exception_type',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddField(
+            model_name='requestmetric',
+            name='has_exception',
+            field=models.BooleanField(default=False),
+        ),
+    ]

profiler/migrations/0004_requestmetric_is_slow.py

@@ -0,0 +1,19 @@
+# Generated by Django 6.0.5 on 2026-05-09 13:57
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('profiler', '0003_requestmetric_exception_message_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='requestmetric',
+            name='is_slow',
+            field=models.BooleanField(default=False),
+            preserve_default=False,
+        ),
+    ]

profiler/migrations/0005_requestmetric_ip_address_requestmetric_request_id_and_more.py

@@ -0,0 +1,58 @@
+# Generated by Django 6.0.5 on 2026-05-10 07:07
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('profiler', '0004_requestmetric_is_slow'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='requestmetric',
+            name='ip_address',
+            field=models.GenericIPAddressField(blank=True, null=True),
+        ),
+        migrations.AddField(
+            model_name='requestmetric',
+            name='request_id',
+            field=models.UUIDField(blank=True, null=True),
+        ),
+        migrations.AddField(
+            model_name='requestmetric',
+            name='route',
+            field=models.CharField(blank=True, max_length=500, null=True),
+        ),
+        migrations.AddField(
+            model_name='requestmetric',
+            name='user_id',
+            field=models.IntegerField(blank=True, null=True),
+        ),
+        migrations.AddField(
+            model_name='requestmetric',
+            name='view_name',
+            field=models.CharField(blank=True, max_length=255, null=True),
+        ),
+        migrations.AddIndex(
+            model_name='requestmetric',
+            index=models.Index(fields=['route'], name='profiler_re_route_f743d1_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='requestmetric',
+            index=models.Index(fields=['status_code'], name='profiler_re_status__151b6c_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='requestmetric',
+            index=models.Index(fields=['created_at'], name='profiler_re_created_fc9098_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='requestmetric',
+            index=models.Index(fields=['is_slow'], name='profiler_re_is_slow_878488_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='requestmetric',
+            index=models.Index(fields=['has_exception'], name='profiler_re_has_exc_5742cb_idx'),
+        ),
+    ]

profiler/migrations/0006_requestmetric_has_n_plus_one_and_more.py

@@ -0,0 +1,23 @@
+# Generated by Django 6.0.5 on 2026-05-10 08:57
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('profiler', '0005_requestmetric_ip_address_requestmetric_request_id_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='requestmetric',
+            name='has_n_plus_one',
+            field=models.BooleanField(default=False),
+        ),
+        migrations.AddField(
+            model_name='requestmetric',
+            name='n_plus_one_details',
+            field=models.JSONField(blank=True, null=True),
+        ),
+    ]

profiler/migrations/0007_endpointsummary.py

@@ -0,0 +1,35 @@
+# Generated by Django 6.0.5 on 2026-05-10 11:23
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('profiler', '0006_requestmetric_has_n_plus_one_and_more'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='EndpointSummary',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('route', models.CharField(max_length=500)),
+                ('window_start', models.DateTimeField()),
+                ('window_end', models.DateTimeField()),
+                ('total_requests', models.IntegerField(default=0)),
+                ('avg_response_ms', models.FloatField(default=0)),
+                ('p95_response_ms', models.FloatField(default=0)),
+                ('max_response_ms', models.FloatField(default=0)),
+                ('min_response_ms', models.FloatField(default=0)),
+                ('error_count', models.IntegerField(default=0)),
+                ('slow_count', models.IntegerField(default=0)),
+                ('n_plus_one_count', models.IntegerField(default=0)),
+                ('computed_at', models.DateTimeField(auto_now=True)),
+            ],
+            options={
+                'indexes': [models.Index(fields=['route', 'window_start'], name='profiler_en_route_97ec83_idx'), models.Index(fields=['window_start'], name='profiler_en_window__25116c_idx')],
+                'unique_together': {('route', 'window_start')},
+            },
+        ),
+    ]

profiler/models/__init__.py

@@ -0,0 +1,2 @@
+from .request_metric import RequestMetric
+from .endpoint_summary import EndpointSummary

profiler/models/endpoint_summary.py

@@ -0,0 +1,28 @@
+from django.db import models 
+
+class EndpointSummary(models.Model):
+    route = models.CharField(max_length=500)
+    window_start = models.DateTimeField()  
+    window_end = models.DateTimeField()   
+
+    total_requests = models.IntegerField(default=0)
+    avg_response_ms = models.FloatField(default=0)
+    p95_response_ms = models.FloatField(default=0)
+    max_response_ms = models.FloatField(default=0)
+    min_response_ms = models.FloatField(default=0)
+
+    error_count = models.IntegerField(default=0)
+    slow_count = models.IntegerField(default=0)
+    n_plus_one_count = models.IntegerField(default=0)
+
+    computed_at = models.DateTimeField(auto_now=True)
+
+    class Meta:
+        unique_together = ("route", "window_start")  
+        indexes = [
+            models.Index(fields=["route", "window_start"]),
+            models.Index(fields=["window_start"]),
+        ]
+
+    def __str__(self):
+        return f"{self.route} | {self.window_start}"

profiler/models/request_metric.py

@@ -0,0 +1,39 @@
+from django.db import models
+
+
+
+class RequestMetric(models.Model):
+    path = models.CharField(max_length=255)
+    method = models.CharField(max_length=10)
+    status_code = models.IntegerField()
+    response_time_ms = models.FloatField()
+    query_count = models.IntegerField(default=0)
+    total_query_time_ms = models.FloatField(default=0)
+    created_at = models.DateTimeField(auto_now_add=True)
+    is_slow = models.BooleanField()
+    has_exception = models.BooleanField(default=False)
+    exception_type = models.CharField(max_length=255,null=True,blank=True)
+    exception_message = models.TextField(null=True,blank=True)
+    route = models.CharField(max_length=500, null=True, blank=True)
+    view_name = models.CharField(max_length=255, null=True, blank=True)
+    user_id = models.IntegerField(null=True, blank=True)
+    ip_address = models.GenericIPAddressField(null=True, blank=True)
+    request_id = models.UUIDField(null=True, blank=True)
+    has_n_plus_one = models.BooleanField(default=False)
+    n_plus_one_details = models.JSONField(null=True, blank=True)
+    
+    
+    def __str__(self):
+        return  f"{self.method} {self.path}"
+        
+    
+    class Meta:
+        indexes = [
+            models.Index(fields=['route']),
+            models.Index(fields=['status_code']),
+            models.Index(fields=['created_at']),
+            models.Index(fields=['is_slow']),
+            models.Index(fields=['has_exception']),
+        ]
+    
+

profiler/services/__init__.py

@@ -0,0 +1,10 @@
+from .request_metric import (
+    save_metric_payload,
+    build_metric_payload
+)
+from .n_plus_one import (
+    detect_n_plus_one,
+    normalize_sql
+)
+
+from .analytics import compute_endpoint_summaries

profiler/services/analytics.py

@@ -0,0 +1,88 @@
+from django.conf import settings
+from django.utils import timezone
+from django.db.models import Count, Avg, Max, Min, Q
+from datetime import timedelta
+from ..models import RequestMetric, EndpointSummary
+from ..conf import profiler_settings
+from .regression import detect_regression
+
+
+def _get_last_completed_window() -> tuple:
+    now = timezone.now()
+    window_minutes = profiler_settings.AGGREGATION_WINDOW_MINUTES
+
+    minutes_since_epoch = int(now.timestamp() // 60)
+    window_start_minutes = (minutes_since_epoch // window_minutes) * window_minutes
+    window_start = timezone.datetime.fromtimestamp(
+        window_start_minutes * 60,
+        tz=timezone.utc
+    )
+
+    window_end = window_start
+    window_start = window_end - timedelta(minutes=window_minutes)
+
+    return window_start, window_end
+
+
+def _calculate_p95(values: list[float]) -> float:
+    if not values:
+        return 0.0
+    sorted_values = sorted(values)
+    index = int(len(sorted_values) * 0.95)
+    return sorted_values[min(index, len(sorted_values) - 1)]
+
+
+def compute_endpoint_summaries() -> int:
+
+    window_start, window_end = _get_last_completed_window()
+
+    metrics_in_window = RequestMetric.objects.filter(
+        created_at__gte=window_start,
+        created_at__lt=window_end,
+    )
+
+    if not metrics_in_window.exists():
+        return 0
+
+    routes = metrics_in_window.values_list("route", flat=True).distinct()
+
+    count = 0
+
+    for route in routes:
+        route_metrics = metrics_in_window.filter(route=route)
+
+        response_times = list(
+            route_metrics.values_list("response_time_ms", flat=True)
+        )
+
+
+        aggregates = route_metrics.aggregate(
+            total_requests=Count("id"),
+            avg_response_ms=Avg("response_time_ms"),
+            max_response_ms=Max("response_time_ms"),
+            min_response_ms=Min("response_time_ms"),
+            error_count=Count("id", filter=Q(status_code__gte=400)),
+            slow_count=Count("id", filter=Q(is_slow=True)),
+            n_plus_one_count=Count("id", filter=Q(has_n_plus_one=True)),
+        )
+
+        EndpointSummary.objects.update_or_create(
+            route=route,
+            window_start=window_start,
+            defaults={
+                "window_end": window_end,
+                "p95_response_ms": _calculate_p95(response_times),
+                **aggregates,
+            }
+        )
+
+        regressions = detect_regression(
+            route=route,
+            window_start=window_start,
+            window_end=window_end
+        )
+
+
+        count += 1
+
+    return count

profiler/services/n_plus_one.py

@@ -0,0 +1,31 @@
+from collections import Counter
+from ..conf import profiler_settings
+import re
+
+def normalize_sql(sql: str) -> str:
+    
+    sql = re.sub(r'\b\d+\b', '?', sql)
+    
+    sql = re.sub(r"'[^']*'", '?', sql)
+    
+    sql = ' '.join(sql.split())
+    
+    return sql.strip().lower()
+
+
+
+
+def detect_n_plus_one(queries: list[dict]) -> list[dict]:
+    
+    normalized = [normalize_sql(q["sql"]) for q in queries]
+    counts = Counter(normalized)
+    
+    duplicates = []
+    for pattern, count in counts.items():
+        if count >= profiler_settings.N_PLUS_ONE_THRESHOLD:
+            duplicates.append({
+                "query_pattern": pattern,
+                "count": count,
+            })
+    
+    return duplicates

profiler/services/regression.py

@@ -0,0 +1,61 @@
+import logging
+from datetime import timedelta
+from ..models import EndpointSummary
+from ..conf import profiler_settings
+
+logger = logging.getLogger(__name__)
+
+
+def detect_regression(route: str, window_start, window_end) -> list[dict]:
+    previous_window_start = window_start - timedelta(
+        minutes=profiler_settings.AGGREGATION_WINDOW_MINUTES
+    )
+
+    previous_summary = EndpointSummary.objects.filter(
+        route=route,
+        window_start=previous_window_start,
+    ).first()
+
+    current_summary = EndpointSummary.objects.filter(
+        route=route,
+        window_start=window_start,
+    ).first()
+
+    if not previous_summary or not current_summary:
+        return []
+
+    if current_summary.total_requests == 0 or previous_summary.total_requests == 0:
+        return []
+
+    regressions = []
+
+    if current_summary.avg_response_ms > previous_summary.avg_response_ms * profiler_settings.REGRESSION_RESPONSE_TIME_FACTOR:
+        regressions.append({
+            "type": "response_time",
+            "previous_avg_ms": previous_summary.avg_response_ms,
+            "current_avg_ms": current_summary.avg_response_ms,
+        })
+        logger.warning(
+            "Response time regression detected on %s: %.2fms → %.2fms",
+            route,
+            previous_summary.avg_response_ms,
+            current_summary.avg_response_ms,
+        )
+
+    current_error_rate = current_summary.error_count / current_summary.total_requests
+    previous_error_rate = previous_summary.error_count / previous_summary.total_requests
+
+    if current_error_rate > previous_error_rate + profiler_settings.REGRESSION_ERROR_RATE_DELTA:
+        regressions.append({
+            "type": "error_rate",
+            "previous_rate": round(previous_error_rate, 4),
+            "current_rate": round(current_error_rate, 4),
+        })
+        logger.warning(
+            "Error rate regression detected on %s: %.1f%% → %.1f%%",
+            route,
+            previous_error_rate * 100,
+            current_error_rate * 100,
+        )
+
+    return regressions

profiler/services/request_metric.py

@@ -0,0 +1,50 @@
+from django.http import HttpRequest, HttpResponse
+from ..models.request_metric import RequestMetric
+from ..db_wrapper import get_query_log
+from .n_plus_one import detect_n_plus_one
+from ..conf import profiler_settings
+
+
+
+
+
+def build_metric_payload(
+    path: str,
+    method: str,
+    status_code: int,
+    duration_ms: float,
+    route: str | None = None,
+    view_name: str | None = None,
+    has_exception: bool = False,
+    exception_type: str | None = None,
+    exception_message: str | None = None,
+    queries: list[dict] | None = None,
+) -> dict:
+
+    queries = queries or []
+
+    n_plus_one_results = detect_n_plus_one(queries)
+    has_n_plus_one = len(n_plus_one_results) > 0
+
+    return {
+        "path": path,
+        "method": method,
+        "status_code": status_code,
+        "response_time_ms": duration_ms,
+        "route": route,
+        "view_name": view_name,
+        "query_count": len(queries),
+        "total_query_time_ms": sum(q["time_ms"] for q in queries),
+        "has_exception": has_exception,
+        "is_slow": duration_ms > profiler_settings.SLOW_REQUEST_THRESHOLD_MS,
+        "exception_type": exception_type,
+        "exception_message": exception_message,
+        "has_n_plus_one": has_n_plus_one,
+        "n_plus_one_details": n_plus_one_results if has_n_plus_one else None,
+    }
+
+
+
+def save_metric_payload(payload: dict) -> None:
+
+    RequestMetric.objects.create(**payload)

profiler/tasks.py

@@ -0,0 +1,16 @@
+from celery import shared_task
+from .services import (
+    compute_endpoint_summaries,
+    save_metric_payload
+)
+
+@shared_task
+def run_aggregation() -> str:
+    count = compute_endpoint_summaries()
+    return f"Computed summaries for {count} endpoint(s)."
+
+
+@shared_task
+def ingest_request_metric(payload: dict) -> None:
+    save_metric_payload(payload)
+    

profiler/tests/__init__.py

@@ -0,0 +1,5 @@
+from .n_plus_one import (
+    NormalizeSQLTests,
+    DetectNPlusOneTests
+)
+from .build_metric_payload import BuildMetricTest

profiler/tests/build_metric_payload.py

@@ -0,0 +1,14 @@
+from django.test import TestCase
+from ..services import build_metric_payload
+
+
+class BuildMetricTest(TestCase):
+
+    def test_marks_slow_request(self):
+        payload = build_metric_payload(
+            path="/api/users/",
+            method="GET",
+            status_code=200,
+            duration_ms=2000,
+        )
+        self.assertTrue(payload["is_slow"])

profiler/tests/n_plus_one.py

@@ -0,0 +1,51 @@
+from django.test import TestCase 
+from ..services import detect_n_plus_one, normalize_sql
+
+
+
+class NormalizeSQLTests(TestCase):
+
+    def test_strips_numbers(self):
+        sql_query = "SELECT * FROM users WHERE id = 433"
+        self.assertEqual(
+            normalize_sql(sql_query),
+            "select * from users where id = ?"
+        )
+    
+    def test_strips_string(self):
+        sql_query = "SELECT * FROM users WHERE name = 'Ahmed'"
+
+        self.assertEqual(
+            normalize_sql(sql_query),
+            "select * from users where name = ?"
+        )
+    
+    def test_collapses_whitespace(self):
+
+        sql_query = "SELECT    * from    users"
+
+        self.assertEqual(
+            normalize_sql(sql_query),
+            "select * from users"
+        )
+
+
+class DetectNPlusOneTests(TestCase):
+
+    def test_detects_repeated_queries(self):
+        queries = [
+            {"sql": "SELECT * FROM users WHERE id = 1", "time_ms": 1},
+            {"sql": "SELECT * FROM users WHERE id = 2", "time_ms": 1},
+            {"sql": "SELECT * FROM users WHERE id = 3", "time_ms": 1},
+        ]
+        results = detect_n_plus_one(queries)
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["count"], 3)
+
+    def test_no_false_positive_on_unique_queries(self):
+        queries = [
+            {"sql": "SELECT * FROM users", "time_ms": 1},
+            {"sql": "SELECT * FROM posts", "time_ms": 1},
+        ]
+        results = detect_n_plus_one(queries)
+        self.assertEqual(results, [])

profiler/utils/__init__.py

@@ -0,0 +1 @@
+from .ingestion import ingest_metric

profiler/utils/ingestion.py

@@ -0,0 +1,33 @@
+from ..conf import profiler_settings
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def ingest_metric(payload: dict) -> None:
+    use_async = profiler_settings.ASYNC
+
+    if use_async:
+        _ingest_async(payload)
+    else:
+        _ingest_sync(payload)
+
+
+
+
+def _ingest_async(payload: dict) -> None:
+    try:
+        from ..tasks import ingest_request_metric
+        ingest_request_metric.delay(payload)
+    except Exception as e:
+        logger.error(
+            "Failed to queue metric asynchronously, falling back to sync. "
+            "Error: %s",
+            str(e),
+        )
+        _ingest_sync(payload)
+
+
+def _ingest_sync(payload: dict) -> None:
+    from ..services import save_metric_payload
+    save_metric_payload(payload)