Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
def request(ctx, flow):
global step, ssl
print("==========")
print("GC: {}".format(gc.collect()))
print("Threads: {}".format(threading.active_count()))
step += 1
if step == 1:
all_objects = muppy.get_objects()
ssl = muppy.filter(all_objects, SSL.Connection)[0]
if step == 2:
ib = refbrowser.InteractiveBrowser(ssl, 2, str_fun, repeat=False)
del ssl # do this to unpollute view
ib.main(True)
# print("\r\n".join(str(x)[:100] for x in gc.get_referrers(ssl)))
def _get_stats():
from pympler import muppy, summary
all_objects = muppy.get_objects()
result = summary.summarize(all_objects)
result = result[0:20]
summary = '\n'.join([l for l in summary.format_(result)])
result = '%s\n\n%s' % (summary, json.dumps(result))
return result, 200, {'content-type': 'text/plain'}
def printmemory(sig, currentframe):
try:
from pympler import muppy, summary
muppy.get_objects
except ImportError:
return
all_objects = muppy.get_objects()
sum1 = summary.summarize(all_objects)
path = mempathformat % {"time": time.time(), "pid": os.getpid()}
with open(path, "w") as f:
f.write("\n".join(summary.format_(sum1, limit=50, sort="#")))
def summary_track (now):
global summary_tracker
all_objects = muppy.get_objects ()
#all_objects = muppy.filter (all_objects, Type = dict)
#for each in all_objects:
# print (each)
sum1 = summary.summarize (all_objects)
summary.print_ (sum1)
print ('-' * 79)
if summary_tracker is None:
summary_tracker = tracker.SummaryTracker ()
summary_tracker.print_diff ()
def pympler_summary():
if pympler is None:
return "pympler not installed / not enabled"
all_objects = pympler.muppy.get_objects()
summ = pympler.summary.summarize(all_objects)
pympler.summary.print_(summ)
return "Printed to console"
except ImportError:
print("WARNING: pympler not installed")
return
# from pympler.classtracker import ClassTracker
# from pympler.classtracker_stats import HtmlStats
global all_objects, obj_summary, class_tracker
if all_objects is None:
all_objects = muppy.get_objects()
obj_summary = summary.summarize(all_objects)
summary.print_(obj_summary)
# class_tracker = ClassTracker()
# class_tracker.track_class(FICSPlayer, trace=1)
# class_tracker.track_class(ICGameModel, resolution_level=2, trace=1)
else:
obj_summary2 = summary.summarize(muppy.get_objects())
diff = summary.get_diff(obj_summary, obj_summary2)
summary.print_(diff, limit=200)
def dump_objs():
global TRACKER
if TRACKER is None:
TRACKER = tracker.SummaryTracker()
with open("obj_log.txt", "a") as fp:
fp.write("Memory at {}\n".format(str(datetime.datetime.now())))
try:
all_objects = muppy.get_objects()
sum1 = summary.summarize(all_objects)
str_sum = summary.format_(sum1)
fp.write("Summary:\n")
for line in str_sum:
fp.write(" {}\n".format(line))
except Exception:
err = traceback.format_exc()
fp.write("Error: \n")
fp.write(err)
try:
str_diff = TRACKER.format_diff()
fp.write("Diff:\n")
for line in str_diff:
fp.write(" {}\n".format(line))
def create_summary(self):
"""Return a summary.
See also the notes on ignore_self in the class as well as the
initializer documentation.
"""
if not self.ignore_self:
res = summary.summarize(muppy.get_objects())
else:
# If the user requested the data required to store summaries to be
# ignored in the summaries, we need to identify all objects which
# are related to each summary stored.
# Thus we build a list of all objects used for summary storage as
# well as a dictionary which tells us how often an object is
# referenced by the summaries.
# During this identification process, more objects are referenced,
# namely int objects identifying referenced objects as well as the
# corresponding count.
# For all these objects it will be checked whether they are
# referenced from outside the monitor's scope. If not, they will be
# subtracted from the snapshot summary, otherwise they are
# included (as this indicates that they are relevant to the
# application).