Classe para teste de performance Django + DRF 3

view.py

# coding: utf-8
from rest_framework import viewsets
from rest_framework.response import Response
from rest_framework.authentication import TokenAuthentication, SessionAuthentication
from rest_framework.permissions import AllowAny, IsAuthenticated
import models
from rest_framework.decorators import detail_route, list_route, api_view, authentication_classes
import serializers
from django.core.signals import request_finished, request_started
import time
from django.contrib.auth.models import User
from benchmark import Formater


class PerguntaView(viewsets.ModelViewSet):
    serializer_class = serializers.PerguntaSerializer
    authentication_classes = (TokenAuthentication, SessionAuthentication,)
    permission_classes = (AllowAny,)
    queryset = models.Pergunta.objects.all()
    model = models.Pergunta

    """
    Metodo para subscrever o comportamente da classe pai
    """
    def list(self, request):

        global serializer_time
        global db_time

        """
        Consulta no banco de dados. Aqui nós estamos cronometrando tudo do Django ORM
        para baixo para o acesso de dados brutos.
        Para medir o tempo independente da serialização, vamos colocar a chamada queryset em uma lista(),
        a fim de forçá-lo a avaliar.
        """
        db_start = time.time()
        pergunta = list(models.Pergunta.objects.all()) #TODO ** modificação aqui forca lista
        db_time = time.time() - db_start

        """
        O tempo que leva para serializar instâncias do modelo em simples estrutura de dados python nativa.
        Podemos vez este como tudo o que acontece na instanciação serializer e acesso .data.
        """
        serializer_start = time.time()
        serializer = serializers.PerguntaSerializer(pergunta, many=True)
        data = serializer.data
        serializer_time = time.time() - serializer_start

        return Response(data)

    """
    Metodo responsavel por renderizar a view
    """
    def dispatch(self, request, *args, **kwargs):

        global dispatch_time
        global render_time

        dispatch_start = time.time()

        """
        Objeto Response do DRF é do tipo TemplateResponse, o que significa que o processo de
        renderização ocorre depois que a request tenha sido devolvido pela view. Para medir este tempo nós podemos
        envolver APIView.dispatch em uma superclasse que obriga ela a responder para o renderizador para antes de devolvê-lo.
        """
        ret = super(PerguntaView, self).dispatch(request, *args, **kwargs)
        render_start = time.time()
        ret.render()
        render_time = time.time() - render_start
        dispatch_time = time.time() - dispatch_start
        return ret

    """
    Metodo que inicia a cronometragem total do processo
    """
    def started(sender, **kwargs):

        global started
        started = time.time()

    """
    Metodo que finaliza a cronometragem total do processo
    """
    def finished(sender, **kwargs):

        total = time.time() - started
        api_view_time = dispatch_time - (render_time + serializer_time + db_time)
        request_response_time = total - dispatch_time

        """
        Formatação da saida
        """
        f = Formater()
        f.saida(db_time, serializer_time, request_response_time, api_view_time, render_time)

    """
    Tudo o que acontece antes ou depois que os métodos da view sejam executados.
    Isso inclui o middleware padrão, o roteamento da requisição e os outros mecanismos core que ocorrem em cada requisição.
    Podemos medir o tempo fanzendo hooks (ganchos) em sinais request_started e request_finished do Django.
    """
    request_started.connect(started)
    request_finished.connect(finished)