| | """ |
| | Application Profiler |
| | ==================== |
| | |
| | This module provides a middleware that profiles each request with the |
| | :mod:`cProfile` module. This can help identify bottlenecks in your code |
| | that may be slowing down your application. |
| | |
| | .. autoclass:: ProfilerMiddleware |
| | |
| | :copyright: 2007 Pallets |
| | :license: BSD-3-Clause |
| | """ |
| | import os.path |
| | import sys |
| | import time |
| | import typing as t |
| | from pstats import Stats |
| |
|
| | try: |
| | from cProfile import Profile |
| | except ImportError: |
| | from profile import Profile |
| |
|
| | if t.TYPE_CHECKING: |
| | from _typeshed.wsgi import StartResponse |
| | from _typeshed.wsgi import WSGIApplication |
| | from _typeshed.wsgi import WSGIEnvironment |
| |
|
| |
|
| | class ProfilerMiddleware: |
| | """Wrap a WSGI application and profile the execution of each |
| | request. Responses are buffered so that timings are more exact. |
| | |
| | If ``stream`` is given, :class:`pstats.Stats` are written to it |
| | after each request. If ``profile_dir`` is given, :mod:`cProfile` |
| | data files are saved to that directory, one file per request. |
| | |
| | The filename can be customized by passing ``filename_format``. If |
| | it is a string, it will be formatted using :meth:`str.format` with |
| | the following fields available: |
| | |
| | - ``{method}`` - The request method; GET, POST, etc. |
| | - ``{path}`` - The request path or 'root' should one not exist. |
| | - ``{elapsed}`` - The elapsed time of the request. |
| | - ``{time}`` - The time of the request. |
| | |
| | If it is a callable, it will be called with the WSGI ``environ`` |
| | dict and should return a filename. |
| | |
| | :param app: The WSGI application to wrap. |
| | :param stream: Write stats to this stream. Disable with ``None``. |
| | :param sort_by: A tuple of columns to sort stats by. See |
| | :meth:`pstats.Stats.sort_stats`. |
| | :param restrictions: A tuple of restrictions to filter stats by. See |
| | :meth:`pstats.Stats.print_stats`. |
| | :param profile_dir: Save profile data files to this directory. |
| | :param filename_format: Format string for profile data file names, |
| | or a callable returning a name. See explanation above. |
| | |
| | .. code-block:: python |
| | |
| | from werkzeug.middleware.profiler import ProfilerMiddleware |
| | app = ProfilerMiddleware(app) |
| | |
| | .. versionchanged:: 0.15 |
| | Stats are written even if ``profile_dir`` is given, and can be |
| | disable by passing ``stream=None``. |
| | |
| | .. versionadded:: 0.15 |
| | Added ``filename_format``. |
| | |
| | .. versionadded:: 0.9 |
| | Added ``restrictions`` and ``profile_dir``. |
| | """ |
| |
|
| | def __init__( |
| | self, |
| | app: "WSGIApplication", |
| | stream: t.IO[str] = sys.stdout, |
| | sort_by: t.Iterable[str] = ("time", "calls"), |
| | restrictions: t.Iterable[t.Union[str, int, float]] = (), |
| | profile_dir: t.Optional[str] = None, |
| | filename_format: str = "{method}.{path}.{elapsed:.0f}ms.{time:.0f}.prof", |
| | ) -> None: |
| | self._app = app |
| | self._stream = stream |
| | self._sort_by = sort_by |
| | self._restrictions = restrictions |
| | self._profile_dir = profile_dir |
| | self._filename_format = filename_format |
| |
|
| | def __call__( |
| | self, environ: "WSGIEnvironment", start_response: "StartResponse" |
| | ) -> t.Iterable[bytes]: |
| | response_body: t.List[bytes] = [] |
| |
|
| | def catching_start_response(status, headers, exc_info=None): |
| | start_response(status, headers, exc_info) |
| | return response_body.append |
| |
|
| | def runapp() -> None: |
| | app_iter = self._app( |
| | environ, t.cast("StartResponse", catching_start_response) |
| | ) |
| | response_body.extend(app_iter) |
| |
|
| | if hasattr(app_iter, "close"): |
| | app_iter.close() |
| |
|
| | profile = Profile() |
| | start = time.time() |
| | profile.runcall(runapp) |
| | body = b"".join(response_body) |
| | elapsed = time.time() - start |
| |
|
| | if self._profile_dir is not None: |
| | if callable(self._filename_format): |
| | filename = self._filename_format(environ) |
| | else: |
| | filename = self._filename_format.format( |
| | method=environ["REQUEST_METHOD"], |
| | path=environ["PATH_INFO"].strip("/").replace("/", ".") or "root", |
| | elapsed=elapsed * 1000.0, |
| | time=time.time(), |
| | ) |
| | filename = os.path.join(self._profile_dir, filename) |
| | profile.dump_stats(filename) |
| |
|
| | if self._stream is not None: |
| | stats = Stats(profile, stream=self._stream) |
| | stats.sort_stats(*self._sort_by) |
| | print("-" * 80, file=self._stream) |
| | path_info = environ.get("PATH_INFO", "") |
| | print(f"PATH: {path_info!r}", file=self._stream) |
| | stats.print_stats(*self._restrictions) |
| | print(f"{'-' * 80}\n", file=self._stream) |
| |
|
| | return [body] |
| |
|
