django-devbar 0.3.0__tar.gz → 0.5.0__tar.gz

{django_devbar-0.3.0 → django_devbar-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-devbar
-Version: 0.3.0
+Version: 0.5.0
 Summary: Lightweight performance devbar for Django
 Keywords: django,debug,performance,monitoring,development
 Author: amureki
@@ -31,13 +31,34 @@ Description-Content-Type: text/markdown
 
 # django-devbar
 
+> [!WARNING]
+> This package is experimental and may introduce breaking changes in minor versions.
+
 Lightweight performance devbar for Django. Shows DB query count, query duration, application time, and detects duplicate queries with visual severity indicators.
 
+## Showcase
+
+Normal operation – showing query count, duration, and application time:
+
 ![devbar example](https://github.com/amureki/django-devbar/raw/3c6118d4283c211a5d84510de52e1d5c3e5e46e4/docs/devbar-example.svg)
 
+Duplicate queries detected – severity indicator and details shown:
+
 ![devbar warning example](https://github.com/amureki/django-devbar/raw/3c6118d4283c211a5d84510de52e1d5c3e5e46e4/docs/devbar-example-warning.svg)
 
-> **Note:** This package is experimental and may introduce breaking changes in minor versions.
+[optional] Chrome extension - showing detailed metrics in DevTools panel:
+
+[![Chrome DevTools extension](https://github.com/user-attachments/assets/9bbc41b7-3d93-46e7-aef4-9330a862b8f0)](#chrome-extension)
+
+## Motivation
+
+While [Django Debug Toolbar](https://django-debug-toolbar.readthedocs.io/) is a proven tool trusted by countless projects, django-devbar explores a different approach to development debugging:
+
+- **Minimal setup** — just add middleware, nothing else required
+- **Browser DevTools integration** — Chrome extension panel works with any response type, including JSON
+- **Zero extra dependencies** — only requires Django
+- **Lower overhead** — no extra requests to debug endpoints
+- **Non-intrusive** — HTML bar is optional; works via headers and DevTools panel alone
 
 ## Installation
 
@@ -65,34 +86,36 @@ All settings are optional. Configure via a `DEVBAR` dict in your Django settings
 
 ```python
 DEVBAR = {
-    'POSITION': 'bottom-right',  # bottom-right, bottom-left, top-right, top-left
-    'SHOW_BAR': None,            # None (default) = follows DEBUG, or True/False to override
-    'SHOW_HEADERS': False,       # Add DevBar-* headers to responses
+    "POSITION": "bottom-right",  # bottom-right (default), bottom-left, top-right, top-left
+    "SHOW_BAR": None,  # follows DEBUG; set True/False to override
+    "ENABLE_DEVTOOLS_DATA": None,  # follows DEBUG; set True/False to override
 }
 ```
 
 ## Response Headers
 
-When `DEVBAR = {'SHOW_HEADERS': True}`, performance metrics are added as HTTP response headers. This is useful for:
+Django DevBar adds HTTP response headers with performance metrics:
+
+- **Server-Timing** (always present) – Standard HTTP header with database, application, and total time metrics. Visible in Chrome DevTools Network tab under Timing.
+
+An additional header is included by default in DEBUG mode:
+
+- **DevBar-Data** - JSON header with comprehensive metrics including duplicate query details
+
+This is useful for:
 
 - **API endpoints** where the HTML overlay can't be displayed
 - **Automated testing** to assert performance metrics (e.g., fail CI if query count exceeds a limit)
-- **Monitoring tools** that can capture and aggregate header values
+- **Browser extensions** that need detailed duplicate query information
 
-Headers included:
+### Server-Timing format
 
-| Header | Example | Description |
-|--------|---------|-------------|
-| `DevBar-Query-Count` | `12` | Number of database queries executed |
-| `DevBar-DB-Time` | `87ms` | Total time spent in database queries |
-| `DevBar-App-Time` | `41ms` | Application time (total time minus DB time) |
-| `DevBar-Duplicates` | `3` | Number of duplicate queries detected (only present if duplicates found) |
+```
+Server-Timing: db;dur=87.50, app;dur=41.30, total;dur=128.80
+```
 
 ## Chrome Extension
 
-![Chrome DevTools extension](https://github.com/user-attachments/assets/4288f507-0bd5-4b8c-a3dc-0c4d5b93305f)
-
 View Django DevBar metrics directly in Chrome DevTools with the [official extension](https://chromewebstore.google.com/detail/django-devbar/fehcaaopchkbknbdhjadnmehiifdmeid).
-Requires `DEVBAR = {'SHOW_HEADERS': True}`.
 
 See [chrome-extension/README.md](chrome-extension/README.md) for more details.

django_devbar-0.5.0/README.md

@@ -0,0 +1,90 @@
+# django-devbar
+
+> [!WARNING]
+> This package is experimental and may introduce breaking changes in minor versions.
+
+Lightweight performance devbar for Django. Shows DB query count, query duration, application time, and detects duplicate queries with visual severity indicators.
+
+## Showcase
+
+Normal operation – showing query count, duration, and application time:
+
+![devbar example](https://github.com/amureki/django-devbar/raw/3c6118d4283c211a5d84510de52e1d5c3e5e46e4/docs/devbar-example.svg)
+
+Duplicate queries detected – severity indicator and details shown:
+
+![devbar warning example](https://github.com/amureki/django-devbar/raw/3c6118d4283c211a5d84510de52e1d5c3e5e46e4/docs/devbar-example-warning.svg)
+
+[optional] Chrome extension - showing detailed metrics in DevTools panel:
+
+[![Chrome DevTools extension](https://github.com/user-attachments/assets/9bbc41b7-3d93-46e7-aef4-9330a862b8f0)](#chrome-extension)
+
+## Motivation
+
+While [Django Debug Toolbar](https://django-debug-toolbar.readthedocs.io/) is a proven tool trusted by countless projects, django-devbar explores a different approach to development debugging:
+
+- **Minimal setup** — just add middleware, nothing else required
+- **Browser DevTools integration** — Chrome extension panel works with any response type, including JSON
+- **Zero extra dependencies** — only requires Django
+- **Lower overhead** — no extra requests to debug endpoints
+- **Non-intrusive** — HTML bar is optional; works via headers and DevTools panel alone
+
+## Installation
+
+```bash
+# Using uv (recommended)
+uv add --dev django-devbar
+
+# Or using pip
+pip install django-devbar
+```
+
+Add to your middleware as early as possible, but after any middleware that encodes the response (e.g., `GZipMiddleware`):
+
+```python
+MIDDLEWARE = [
+    "django.middleware.security.SecurityMiddleware",
+    "django_devbar.DevBarMiddleware",
+    # ...
+]
+```
+
+## Configuration
+
+All settings are optional. Configure via a `DEVBAR` dict in your Django settings:
+
+```python
+DEVBAR = {
+    "POSITION": "bottom-right",  # bottom-right (default), bottom-left, top-right, top-left
+    "SHOW_BAR": None,  # follows DEBUG; set True/False to override
+    "ENABLE_DEVTOOLS_DATA": None,  # follows DEBUG; set True/False to override
+}
+```
+
+## Response Headers
+
+Django DevBar adds HTTP response headers with performance metrics:
+
+- **Server-Timing** (always present) – Standard HTTP header with database, application, and total time metrics. Visible in Chrome DevTools Network tab under Timing.
+
+An additional header is included by default in DEBUG mode:
+
+- **DevBar-Data** - JSON header with comprehensive metrics including duplicate query details
+
+This is useful for:
+
+- **API endpoints** where the HTML overlay can't be displayed
+- **Automated testing** to assert performance metrics (e.g., fail CI if query count exceeds a limit)
+- **Browser extensions** that need detailed duplicate query information
+
+### Server-Timing format
+
+```
+Server-Timing: db;dur=87.50, app;dur=41.30, total;dur=128.80
+```
+
+## Chrome Extension
+
+View Django DevBar metrics directly in Chrome DevTools with the [official extension](https://chromewebstore.google.com/detail/django-devbar/fehcaaopchkbknbdhjadnmehiifdmeid).
+
+See [chrome-extension/README.md](chrome-extension/README.md) for more details.

{django_devbar-0.3.0 → django_devbar-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "django-devbar"
-version = "0.3.0"
+version = "0.5.0"
 description = "Lightweight performance devbar for Django"
 readme = "README.md"
 license = "MIT"

{django_devbar-0.3.0 → django_devbar-0.5.0}/src/django_devbar/conf.py

@@ -12,7 +12,7 @@ def get_config():
     return {
         "POSITION": "bottom-right",
         "SHOW_BAR": None,  # None = use settings.DEBUG
-        "SHOW_HEADERS": False,
+        "ENABLE_DEVTOOLS_DATA": None,  # None = use settings.DEBUG
         **getattr(settings, "DEVBAR", {}),
     }
 
@@ -29,5 +29,7 @@ def get_show_bar():
     return settings.DEBUG if show_bar is None else show_bar
 
 
-def get_show_headers():
-    return get_config()["SHOW_HEADERS"]
+def get_enable_devtools_data():
+    config = get_config()
+    enable = config["ENABLE_DEVTOOLS_DATA"]
+    return settings.DEBUG if enable is None else enable

{django_devbar-0.3.0 → django_devbar-0.5.0}/src/django_devbar/middleware.py

@@ -9,10 +9,11 @@ from django.template import Context, Engine
 
 from . import tracker
 from .conf import (
+    get_enable_devtools_data,
     get_position,
     get_show_bar,
-    get_show_headers,
 )
+from .tracker import format_sql, truncate_sql
 
 BODY_CLOSE_RE = re.compile(rb"</body\s*>", re.IGNORECASE)
 
@@ -41,41 +42,58 @@ class DevBarMiddleware:
         stats = tracker.get_stats()
 
         db_time = stats["duration"]
-        python_time = max(0, total_time - db_time)
+        python_time = round(max(0, total_time - db_time), 2)
 
         stats["python_time"] = python_time
-        stats["total_time"] = total_time
+        stats["total_time"] = round(total_time, 2)
 
-        level = "warn" if stats["has_duplicates"] else "ok"
+        if get_enable_devtools_data():
+            self._add_devtools_data_header(response, stats)
 
-        if get_show_headers():
-            self._add_headers(response, stats)
+        self._add_server_timing_header(response, stats)
 
         if get_show_bar() and self._can_inject(response):
-            self._inject_devbar(response, stats, level)
+            self._inject_devbar(response, stats)
 
         return response
 
-    def _add_headers(self, response, stats):
-        response["DevBar-Query-Count"] = str(stats["count"])
-        response["DevBar-DB-Time"] = f"{stats['duration']:.0f}ms"
-        response["DevBar-App-Time"] = f"{stats['python_time']:.0f}ms"
-        if stats["has_duplicates"]:
-            response["DevBar-Duplicates"] = str(len(stats["duplicate_queries"]))
-
-        # Add comprehensive JSON data for browser DevTools extension
+    def _add_devtools_data_header(self, response, stats):
+        # Abbreviated keys used to minimize DevBar-Data header size
         extension_data = {
-            "count": stats["count"],
-            "db_time": stats["duration"],
-            "app_time": stats["python_time"],
-            "total_time": stats["total_time"],
-            "has_duplicates": stats["has_duplicates"],
+            "c": stats["count"],
+            "db": round(stats["duration"], 2),
+            "app": stats["python_time"],
+            "full": stats["total_time"],
         }
-        if stats.get("duplicate_queries"):
-            extension_data["duplicates"] = stats["duplicate_queries"]
+
+        all_queries = stats.get("queries", [])
+        duplicates = stats.get("duplicate_queries", [])
+
+        if all_queries:
+            processed_queries = [
+                {
+                    "s": truncate_sql(q["sql"]),
+                    "dur": q["duration"],
+                    "dup": 1 if q["is_duplicate"] else 0,
+                }
+                for q in all_queries
+            ]
+            extension_data["q"] = processed_queries
+
+        if duplicates:
+            marked_duplicates = [{**d, "dup": 1} for d in duplicates]
+            extension_data["dup"] = marked_duplicates
 
         response["DevBar-Data"] = json.dumps(extension_data)
 
+    def _add_server_timing_header(self, response, stats):
+        parts = [
+            f"db;dur={stats['duration']:.2f}",
+            f"app;dur={stats['python_time']:.2f}",
+            f"total;dur={stats['total_time']:.2f}",
+        ]
+        response["Server-Timing"] = ", ".join(parts)
+
     def _can_inject(self, response):
         if getattr(response, "streaming", False):
             return False
@@ -86,7 +104,7 @@ class DevBarMiddleware:
             return False
         return hasattr(response, "content")
 
-    def _inject_devbar(self, response, stats, level):
+    def _inject_devbar(self, response, stats):
         content = response.content
         matches = list(BODY_CLOSE_RE.finditer(content))
         if not matches:
@@ -101,7 +119,6 @@ class DevBarMiddleware:
             Context(
                 {
                     "position": get_position(),
-                    "level": level,
                     "db_time": stats["duration"],
                     "app_time": stats["python_time"],
                     "query_count": stats["count"],
@@ -119,5 +136,8 @@ class DevBarMiddleware:
     def _build_duplicates_html(self, duplicates):
         if not duplicates:
             return ""
+        formatted_duplicates = [
+            {**dup, "sql": format_sql(dup["sql"])} for dup in duplicates
+        ]
         template = _template_engine.get_template("django_devbar/duplicates.html")
-        return template.render(Context({"duplicates": duplicates}))
+        return template.render(Context({"duplicates": formatted_duplicates}))

{django_devbar-0.3.0 → django_devbar-0.5.0}/src/django_devbar/templates/django_devbar/devbar.html

@@ -14,6 +14,7 @@
     color: #f5f5f5;
 }
 #django-devbar.level-warn { border-left: 3px solid #f59e0b; }
+#django-devbar.has-duplicates { border-left: 3px solid #f59e0b; }
 #django-devbar span { opacity: 0.7; }
 #django-devbar strong { opacity: 1; font-weight: 600; }
 #django-devbar details { display: inline; position: relative; }
@@ -85,8 +86,8 @@
 }
 @media (max-width: 640px) { #django-devbar { display: none; } }
 </style>
-<div id="django-devbar" class="level-{{ level }}">
+<div id="django-devbar"{% if duplicates_html %} class="has-duplicates"{% endif %}>
+<span>queries</span> <strong>{{ query_count }}</strong> <span>·</span>
 <span>db</span> <strong>{{ db_time|floatformat:0 }}ms</strong> <span>·</span>
-<span>app</span> <strong>{{ app_time|floatformat:0 }}ms</strong> <span>·</span>
-<span>queries</span> <strong>{{ query_count }}</strong>{{ duplicates_html|safe }}
+<span>app</span> <strong>{{ app_time|floatformat:0 }}ms</strong>{{ duplicates_html|safe }}
 </div>

django_devbar-0.5.0/src/django_devbar/tracker.py

@@ -0,0 +1,287 @@
+import re
+from contextvars import ContextVar
+from time import perf_counter
+
+SQL_KEYWORDS_RE = re.compile(
+    r"\b(SELECT|FROM|WHERE|JOIN|LEFT JOIN|RIGHT JOIN|INNER JOIN|OUTER JOIN|ON|AND|OR|ORDER BY|GROUP BY|HAVING|LIMIT|OFFSET|INSERT INTO|VALUES|UPDATE|SET|DELETE|CREATE TABLE|ALTER TABLE|DROP TABLE|DISTINCT|COUNT|SUM|AVG|MAX|MIN|UNION|EXISTS|IN|IS NULL|IS NOT NULL|LIKE|BETWEEN|CASE|WHEN|THEN|ELSE|END|ASC|DESC|AS|WITH|RECURSIVE)\b",
+    re.IGNORECASE,
+)
+
+SQL_CLAUSES_RE = re.compile(
+    r"\b(FROM|WHERE|JOIN|LEFT JOIN|RIGHT JOIN|INNER JOIN|OUTER JOIN|GROUP BY|ORDER BY|HAVING|LIMIT|OFFSET|ON|AND|OR|UNION|WITH|CASE|WHEN|THEN|ELSE)\b",
+    re.IGNORECASE,
+)
+
+_query_count: ContextVar[int] = ContextVar("query_count", default=0)
+_query_duration: ContextVar[float] = ContextVar("query_duration", default=0.0)
+_seen_queries: ContextVar[dict] = ContextVar("seen_queries", default={})
+_duplicate_log: ContextVar[list] = ContextVar("duplicate_log", default=[])
+_query_log: ContextVar[list] = ContextVar("query_log", default=[])
+
+
+def reset():
+    _query_count.set(0)
+    _query_duration.set(0.0)
+    _seen_queries.set({})
+    _duplicate_log.set([])
+    _query_log.set([])
+
+
+def get_stats():
+    duplicate_queries = _duplicate_log.get()
+    duplicate_sqls = {d["sql"] for d in duplicate_queries}
+
+    queries = _query_log.get()
+    for q in queries:
+        q["is_duplicate"] = q["sql"] in duplicate_sqls
+
+    return {
+        "count": _query_count.get(),
+        "duration": _query_duration.get(),
+        "duplicate_queries": duplicate_queries,
+        "queries": queries,
+    }
+
+
+def _hash_params(params):
+    try:
+        return hash(tuple(params)) if params else 0
+    except TypeError:
+        return hash(str(params))
+
+
+def _record(sql, params, duration):
+    _query_count.set(_query_count.get() + 1)
+    _query_duration.set(_query_duration.get() + duration)
+
+    seen = _seen_queries.get()
+    params_hash = _hash_params(params)
+
+    query_log = _query_log.get()
+    query_log.append(
+        {
+            "sql": sql,
+            "duration": round(duration, 2),
+        }
+    )
+    _query_log.set(query_log)
+
+    if sql in seen:
+        if params_hash in seen[sql]:
+            duplicates = _duplicate_log.get()
+            duplicates.append({"sql": sql, "duration": round(duration, 2)})
+        else:
+            seen[sql].add(params_hash)
+    else:
+        seen[sql] = {params_hash}
+
+
+def format_sql(sql):
+    """Highlight SQL keywords with HTML spans for visual formatting.
+
+    Escapes HTML first for security, then wraps SQL keywords in span tags.
+    Used for rendering duplicates in the injected devbar HTML.
+
+    Args:
+        sql: SQL query string
+
+    Returns:
+        Safe HTML string with keywords wrapped in spans
+    """
+    from django.utils.html import escape
+    from django.utils.safestring import mark_safe
+
+    escaped_sql = escape(sql)
+
+    def replace_keyword(match):
+        return f'<span class="sql-keyword">{match.group(0)}</span>'
+
+    highlighted = SQL_KEYWORDS_RE.sub(replace_keyword, escaped_sql)
+    return mark_safe(highlighted)
+
+
+class SQLTruncator:
+    """Handles intelligent SQL query truncation while preserving the structure."""
+
+    def __init__(self, max_length=150):
+        self.max_length = max_length
+
+    def truncate(self, sql):
+        """Intelligently truncate long SQL queries while preserving the structure.
+
+        Args:
+            sql: SQL query string
+
+        Returns:
+            Truncated SQL string with "..." at the end if shortened
+        """
+        if len(sql) <= self.max_length:
+            return sql
+
+        sql_upper = sql.upper()
+
+        if sql_upper.startswith("SELECT"):
+            result = self._truncate_select(sql, sql_upper)
+            if result:
+                return result
+
+        return self._fallback_truncate(sql)
+
+    def _truncate_select(self, sql, sql_upper):
+        """Truncate SELECT queries while preserving columns and joins."""
+        distinct_match = re.search(r"\bDISTINCT\b", sql_upper[:20])
+        has_distinct = distinct_match is not None
+        from_match = re.search(r"\bFROM\b", sql_upper)
+
+        if not from_match:
+            return None
+
+        from_pos = from_match.start()
+
+        if has_distinct:
+            distinct_end = distinct_match.end()
+            select_part = sql[distinct_end:from_pos].strip()
+        else:
+            select_part = sql[6:from_pos].strip()
+
+        first_column = self._extract_first_column(select_part)
+        select_clause = "SELECT DISTINCT" if has_distinct else "SELECT"
+
+        from_part = sql[from_pos:]
+        table_match = re.search(r'FROM\s+(["\[]?)(\w+)', from_part, re.IGNORECASE)
+
+        if not table_match:
+            return None
+
+        table_name = table_match.group(2)
+        result = f"{select_clause} {first_column} FROM {table_name}"
+
+        # Add joins if they fit
+        join_result = self._add_joins_if_fit(result, from_part)
+        if join_result:
+            return join_result
+
+        return result if len(result) <= self.max_length else None
+
+    def _extract_first_column(self, select_part):
+        """Extract the first column from SELECT clause, handling quotes and parentheses."""
+        if not select_part.strip():
+            return "..."
+        columns = self._parse_columns(select_part)
+        return columns[0] + ", ..." if columns else "..."
+
+    def _parse_columns(self, select_part):
+        """Parse columns from SELECT clause, handling complex expressions."""
+        columns = []
+        in_quotes = False
+        quote_char = None
+        in_parens = False
+        paren_depth = 0
+        current_col = ""
+
+        for i, char in enumerate(select_part):
+            if char in ('"', "'") and (i == 0 or select_part[i - 1] != "\\"):
+                if not in_quotes:
+                    in_quotes = True
+                    quote_char = char
+                elif char == quote_char:
+                    in_quotes = False
+                    quote_char = None
+                current_col += char
+            elif in_quotes:
+                current_col += char
+            elif char == "(":
+                in_parens = True
+                paren_depth += 1
+                current_col += char
+            elif char == ")":
+                paren_depth -= 1
+                if paren_depth == 0:
+                    in_parens = False
+                current_col += char
+            elif char == "," and not in_parens and not in_quotes:
+                if current_col.strip():
+                    columns.append(current_col.strip())
+                    break
+                current_col = ""
+            elif char in " \t\n" and not in_parens and not in_quotes:
+                if current_col.strip():
+                    columns.append(current_col.strip())
+                current_col = ""
+            else:
+                current_col += char
+
+        if not columns and current_col.strip():
+            columns.append(current_col.strip())
+
+        return columns
+
+    def _add_joins_if_fit(self, base_result, from_part):
+        """Add JOIN clauses to result if they fit within max_length."""
+        join_matches = re.finditer(
+            r'\b(LEFT\s+|RIGHT\s+|INNER\s+|OUTER\s+)?JOIN\s+(["\[]?)(\w+)',
+            from_part,
+            re.IGNORECASE,
+        )
+
+        result = base_result
+
+        for join_match in join_matches:
+            join_type = (join_match.group(1) or "").strip()
+            join_table = join_match.group(3)
+            new_result = (
+                f"{result} {join_type} JOIN {join_table}"
+                if join_type
+                else f"{result} JOIN {join_table}"
+            )
+            if len(new_result) <= self.max_length:
+                result = new_result
+            else:
+                break
+
+        return result if len(result) <= self.max_length else None
+
+    def _fallback_truncate(self, sql):
+        """Fallback truncation at clause boundaries or simple length limit."""
+        # First try simple length truncation
+        if len(sql) <= self.max_length:
+            return sql
+
+        # Try clause boundary truncation
+        clause_positions = [
+            (match.start(), match.group())
+            for match in SQL_CLAUSES_RE.finditer(sql[: self.max_length + 50])
+        ]
+
+        if clause_positions:
+            best_pos = self._find_best_truncate_position(clause_positions)
+            if best_pos > 0:
+                return sql[:best_pos].rstrip() + "..."
+
+        # Final fallback: simple truncation
+        return sql[: self.max_length].rstrip() + "..."
+
+    def _find_best_truncate_position(self, clause_positions):
+        """Find the best position to truncate based on clause boundaries."""
+        best_pos = 0
+        for pos, _ in clause_positions:
+            if self.max_length > pos > best_pos:
+                best_pos = pos
+
+        if best_pos > self.max_length - 30:
+            best_pos = 0
+
+        return best_pos
+
+
+def truncate_sql(sql, max_length=150):
+    truncator = SQLTruncator(max_length)
+    return truncator.truncate(sql)
+
+
+def tracking_wrapper(execute, sql, params, many, context):
+    start = perf_counter()
+    try:
+        return execute(sql, params, many, context)
+    finally:
+        _record(sql, params, (perf_counter() - start) * 1000)

django_devbar-0.3.0/README.md

@@ -1,67 +0,0 @@
-# django-devbar
-
-Lightweight performance devbar for Django. Shows DB query count, query duration, application time, and detects duplicate queries with visual severity indicators.
-
-![devbar example](https://github.com/amureki/django-devbar/raw/3c6118d4283c211a5d84510de52e1d5c3e5e46e4/docs/devbar-example.svg)
-
-![devbar warning example](https://github.com/amureki/django-devbar/raw/3c6118d4283c211a5d84510de52e1d5c3e5e46e4/docs/devbar-example-warning.svg)
-
-> **Note:** This package is experimental and may introduce breaking changes in minor versions.
-
-## Installation
-
-```bash
-# Using uv (recommended)
-uv add --dev django-devbar
-
-# Or using pip
-pip install django-devbar
-```
-
-Add to your middleware as early as possible, but after any middleware that encodes the response (e.g., `GZipMiddleware`):
-
-```python
-MIDDLEWARE = [
-    "django.middleware.security.SecurityMiddleware",
-    "django_devbar.DevBarMiddleware",
-    # ...
-]
-```
-
-## Configuration
-
-All settings are optional. Configure via a `DEVBAR` dict in your Django settings:
-
-```python
-DEVBAR = {
-    'POSITION': 'bottom-right',  # bottom-right, bottom-left, top-right, top-left
-    'SHOW_BAR': None,            # None (default) = follows DEBUG, or True/False to override
-    'SHOW_HEADERS': False,       # Add DevBar-* headers to responses
-}
-```
-
-## Response Headers
-
-When `DEVBAR = {'SHOW_HEADERS': True}`, performance metrics are added as HTTP response headers. This is useful for:
-
-- **API endpoints** where the HTML overlay can't be displayed
-- **Automated testing** to assert performance metrics (e.g., fail CI if query count exceeds a limit)
-- **Monitoring tools** that can capture and aggregate header values
-
-Headers included:
-
-| Header | Example | Description |
-|--------|---------|-------------|
-| `DevBar-Query-Count` | `12` | Number of database queries executed |
-| `DevBar-DB-Time` | `87ms` | Total time spent in database queries |
-| `DevBar-App-Time` | `41ms` | Application time (total time minus DB time) |
-| `DevBar-Duplicates` | `3` | Number of duplicate queries detected (only present if duplicates found) |
-
-## Chrome Extension
-
-![Chrome DevTools extension](https://github.com/user-attachments/assets/4288f507-0bd5-4b8c-a3dc-0c4d5b93305f)
-
-View Django DevBar metrics directly in Chrome DevTools with the [official extension](https://chromewebstore.google.com/detail/django-devbar/fehcaaopchkbknbdhjadnmehiifdmeid).
-Requires `DEVBAR = {'SHOW_HEADERS': True}`.
-
-See [chrome-extension/README.md](chrome-extension/README.md) for more details.

django_devbar-0.3.0/src/django_devbar/tracker.py

@@ -1,61 +0,0 @@
-from contextvars import ContextVar
-from time import perf_counter
-
-_query_count: ContextVar[int] = ContextVar("query_count", default=0)
-_query_duration: ContextVar[float] = ContextVar("query_duration", default=0.0)
-_seen_queries: ContextVar[dict] = ContextVar("seen_queries", default={})
-_duplicate_log: ContextVar[list] = ContextVar("duplicate_log", default=[])
-
-
-def reset():
-    _query_count.set(0)
-    _query_duration.set(0.0)
-    _seen_queries.set({})
-    _duplicate_log.set([])
-
-
-def get_stats():
-    return {
-        "count": _query_count.get(),
-        "duration": _query_duration.get(),
-        "has_duplicates": bool(_duplicate_log.get()),
-        "duplicate_queries": _duplicate_log.get(),
-    }
-
-
-def _hash_params(params):
-    try:
-        return hash(tuple(params)) if params else 0
-    except TypeError:
-        return hash(str(params))
-
-
-def _record(sql, params, duration):
-    _query_count.set(_query_count.get() + 1)
-    _query_duration.set(_query_duration.get() + duration)
-
-    seen = _seen_queries.get()
-    params_hash = _hash_params(params)
-
-    if sql in seen:
-        if params_hash in seen[sql]:
-            param_str = str(params)
-            if len(param_str) > 200:
-                param_str = param_str[:200] + "..."
-
-            duplicates = _duplicate_log.get()
-            duplicates.append(
-                {"sql": sql, "params": param_str, "duration": round(duration, 2)}
-            )
-        else:
-            seen[sql].add(params_hash)
-    else:
-        seen[sql] = {params_hash}
-
-
-def tracking_wrapper(execute, sql, params, many, context):
-    start = perf_counter()
-    try:
-        return execute(sql, params, many, context)
-    finally:
-        _record(sql, params, (perf_counter() - start) * 1000)