To avoid duplicatekey error using silk on "production" server (probably caused by multi thread environment)

custom_silk_profiling.py

import json
from django.utils import timezone

from silk.collector import DataCollector
from silk.profiling.profiler import silk_meta_profiler
from silk import models
from silk.middleware import SilkyMiddleware
from silk.model_factory import ResponseModelFactory, Logger


class CustomResponseModelFactory(ResponseModelFactory):

    def construct_response_model(self):
        assert self.request, 'Cant construct a response model if there is no request model'
        Logger.debug('Creating response model for request model with pk %s' % self.request.pk)
        b, content = self.body()
        raw_headers = self.response._headers
        headers = {}
        for k, v in raw_headers.items():
            try:
                header, val = v
            except ValueError:
                header, val = k, v
            finally:
                headers[header] = val
        try:
            silky_response = models.Response.objects.create(request=self.request,
                                                            status_code=self.response.status_code,
                                                            encoded_headers=json.dumps(headers),
                                                            body=b)
        except Exception as e:
            Logger.error('Silk error: {}'.format(e.message))
            return None
        # Text fields are encoded as UTF-8 in Django and hence will try to coerce
        # anything to we pass to UTF-8. Some stuff like binary will fail.
        try:
            silky_response.raw_body = content
        except UnicodeDecodeError:
            Logger.debug('NYI: Saving of binary response body')  # TODO
        return silky_response


class CustomSilkyMiddleware(SilkyMiddleware):

    def _process_response(self, response):
        with silk_meta_profiler():
            collector = DataCollector()
            collector.stop_python_profiler()
            silk_request = collector.request
            if silk_request:
                silk_response = CustomResponseModelFactory(response).construct_response_model()
                if silk_response:
                    silk_response.save()
                    silk_request.end_time = timezone.now()
                    collector.finalise()
                    silk_request.save()
            else:
                Logger.error('No request model was available when processing response. Did something go wrong in process_request/process_view?')