def process_request(self, request: HttpRequest) -> HttpResponse:
self._tracker = ClassTracker()
for cls in apps.get_models() + self.classes:
self._tracker.track_class(cls)
self._tracker.create_snapshot('before')
self.record_stats({'before': ProcessMemoryInfo()})
response = super(MemoryPanel, self).process_request(request)
self.record_stats({'after': ProcessMemoryInfo()})
self._tracker.create_snapshot('after')
stats = self._tracker.stats
stats.annotate()
self.record_stats({'stats': stats})
return response
def _check_memory(self):
if not self.pmi:
self.pmi = ProcessMemoryInfo()
self.last_vsz = self.pmi.vsz
self.initial_vsz = self.pmi.vsz
utc = datetime.datetime.utcnow()
check = self.last_time is None
if self.last_time:
diff = utc - self.last_time
if diff.seconds > 30:
check = True
if check:
self.last_time = utc
self.pmi.update()
diff = (self.pmi.vsz - self.last_vsz) / 1000
idiff = (self.pmi.vsz - self.initial_vsz) / 1000
self.total_processed += self.processed
per_message = 0
if self.total_processed:
per_message = idiff / self.total_processed
LOG.debug("%20s %6dk/%6dk ram, "
"%3d/%4d msgs @ %6dk/msg" %
(self.name, diff, idiff, self.processed,
self.total_processed, per_message))
self.last_vsz = self.pmi.vsz
self.processed = 0
def profiler_handler(req):
self._tracker.create_snapshot('before')
before = ProcessMemoryInfo()
req_before = get_memory_object(req.registry)
try:
result = handler(req)
except:
raise
finally:
after = ProcessMemoryInfo()
self._tracker.create_snapshot('after')
class_stats = self._tracker.stats
class_stats.annotate()
self.stats = dict(
before=before,
after=after,
class_stats=class_stats,
req_before=req_before,
req_after=get_memory_object(req.registry),
)
return result
def _getProcessMemory():
"""Utility function that defined the logic to get memory."""
return ProcessMemoryInfo().rss
def process_response(self, request, response):
self.record_stats({'after': ProcessMemoryInfo()})
self._tracker.create_snapshot('after')
stats = self._tracker.stats
stats.annotate()
self.record_stats({'stats': stats})
def process_request(self, request):
self._tracker = ClassTracker()
for cls in apps.get_models() + self.classes:
self._tracker.track_class(cls)
self._tracker.create_snapshot('before')
self.record_stats({'before': ProcessMemoryInfo()})
def root():
"""Get overview."""
pmi = ProcessMemoryInfo()
return dict(processinfo=pmi)
def process():
"""Get process overview."""
pmi = ProcessMemoryInfo()
threads = get_current_threads()
return dict(info=pmi, threads=threads)
def track_memory_wrapper(*args, **kwargs):
memory_info = {}
tracker = ClassTracker()
for cls in apps.get_models() + [Context, Template]:
# track all models from registered apps, plus some standard Django ones
tracker.track_class(cls)
try:
tracker.create_snapshot("before")
memory_info["before"] = ProcessMemoryInfo()
result = fn(*args, **kwargs)
memory_info["after"] = ProcessMemoryInfo()
tracker.create_snapshot("after")
memory_info["stats"] = tracker.stats
memory_info["stats"].annotate()
return result
finally:
# record a whole bunch of memory statistics...
resources = [
("resident set size", memory_info["after"].rss),
("virtual size", memory_info["after"].vsz),
]
resources.extend(memory_info["after"] - memory_info["before"])
resources = [(k, pp(v)) for k, v in resources]
resources.extend(memory_info["after"].os_specific)
# record each tracked class as of the final snapshot...
classes_stats = []
snapshot = memory_info["stats"].snapshots[-1]
for class_name in memory_info["stats"].tracked_classes:
# history is a list of tuples that is updated on every creation/deletions: (timestamp, n_instances)
history = [
n for _, n in memory_info["stats"].history[class_name]
]
if history:
classes_stats.append({
"name":
class_name,
"n_instances":
len(history),
"min_instances":
min(history),
"max_instances":
max(history),
"size":
pp(
snapshot.classes.get(class_name,
{}).get("sum", 0)),
})
if not path:
stream = sys.stdout
else:
stream = open(path, "w")
print("\nRESOURCES", file=stream)
for k, v in resources:
print(f"{k:<26}: {v:>10}", file=stream)
print("\nCLASSES", file=stream)
for class_stats in classes_stats:
print(
"{name}: created/deleted {n_instances} times for a min/max of {min_instances}/{max_instances} instances: {size:>10}"
.format(**class_stats),
file=stream,
)
stream.closed
tracker.detach_all_classes()
def process_response(self, request, response):
self._after = ProcessMemoryInfo()
self._tracker.create_snapshot('after')
def process_request(self, request):
self._tracker = ClassTracker()
for cls in get_models() + self.classes:
self._tracker.track_class(cls, keep=True)
self._tracker.create_snapshot('before')
self._before = ProcessMemoryInfo()
