def __attrs_post_init__(self):
r = recorder.Recorder(
max_events={
# Allow to store up to 10 threads for 60 seconds at 100 Hz
stack.StackSampleEvent: 10 * 60 * 100,
stack.StackExceptionSampleEvent: 10 * 60 * 100,
# This can generate one event every 0.1s if 100% are taken — though we take 5% by default.
# = (60 seconds / 0.1 seconds)
memory.MemorySampleEvent: int(60 / 0.1),
# (default buffer size / interval) * export interval
memalloc.MemoryAllocSampleEvent: int((64 / 0.5) * 60),
},
default_max_events=int(os.environ.get("DD_PROFILING_MAX_EVENTS", recorder.Recorder._DEFAULT_MAX_EVENTS)),
)
if formats.asbool(os.environ.get("DD_PROFILING_MEMALLOC", "false")):
mem_collector = memalloc.MemoryCollector(r)
else:
mem_collector = memory.MemoryCollector(r)
self._collectors = [
stack.StackCollector(r, tracer=self.tracer),
mem_collector,
exceptions.UncaughtExceptionCollector(r),
threading.LockCollector(r),
]
exporters = self._build_default_exporters(self.service, self.env, self.version)
if exporters:
self._scheduler = scheduler.Scheduler(recorder=r, exporters=exporters)
def _build_default_collectors():
r = recorder.Recorder()
return [
stack.StackCollector(r),
memory.MemoryCollector(r),
exceptions.UncaughtExceptionCollector(r),
threading.LockCollector(r),
]
def _test_memory_ignore(ignore):
r = recorder.Recorder()
# Start a stack collector so it allocates memory
with stack.StackCollector(r):
r = recorder.Recorder()
c = memory.MemoryCollector(r, ignore_profiler=ignore, capture_pct=100)
while not r.events[memory.MemorySampleEvent]:
c.collect()
_ = _alloc()
events = r.events[memory.MemorySampleEvent]
files = {
frame.filename
for event in events for trace in event.snapshot.traces
for frame in trace.traceback
}
return files
def _test_memory_ignore(ignore):
r = recorder.Recorder()
# Start a stack collector so it allocates memory
with stack.StackCollector(r) as sc:
r = recorder.Recorder()
c = memory.MemoryCollector(r, ignore_profiler=ignore, capture_pct=100)
with c as mc:
while not r.events[memory.MemorySampleEvent]:
_ = object()
# Allow gevent to switch to the memory collector thread
time.sleep(0)
sc.join()
mc.join()
events = r.events[memory.MemorySampleEvent]
files = {frame.filename for event in events for trace in event.snapshot.traces for frame in trace.traceback}
return files
def __attrs_post_init__(self):
r = self._recorder = recorder.Recorder(
max_events={
# Allow to store up to 10 threads for 60 seconds at 100 Hz
stack.StackSampleEvent:
10 * 60 * 100,
stack.StackExceptionSampleEvent:
10 * 60 * 100,
# This can generate one event every 0.1s if 100% are taken — though we take 5% by default.
# = (60 seconds / 0.1 seconds)
memory.MemorySampleEvent:
int(60 / 0.1),
# (default buffer size / interval) * export interval
memalloc.MemoryAllocSampleEvent:
int((memalloc.MemoryCollector._DEFAULT_MAX_EVENTS /
memalloc.MemoryCollector._DEFAULT_INTERVAL) * 60),
# Do not limit the heap sample size as the number of events is relative to allocated memory anyway
memalloc.MemoryHeapSampleEvent:
None,
},
default_max_events=int(
os.environ.get("DD_PROFILING_MAX_EVENTS",
recorder.Recorder._DEFAULT_MAX_EVENTS)),
)
if formats.asbool(os.environ.get("DD_PROFILING_MEMALLOC", "true")):
mem_collector = memalloc.MemoryCollector(r)
else:
mem_collector = memory.MemoryCollector(r)
self._collectors = [
stack.StackCollector(r, tracer=self.tracer),
mem_collector,
threading.LockCollector(r, tracer=self.tracer),
]
exporters = self._build_default_exporters(self.tracer, self.url,
self.tags, self.service,
self.env, self.version)
if exporters:
self._scheduler = scheduler.Scheduler(
recorder=r,
exporters=exporters,
before_flush=self._collectors_snapshot)
def _build_default_collectors(tracer):
r = recorder.Recorder(
max_events={
# Allow to store up to 10 threads for 60 seconds at 100 Hz
stack.StackSampleEvent:
10 * 60 * 100,
stack.StackExceptionSampleEvent:
10 * 60 * 100,
# This can generate one event every 0.1s if 100% are taken — though we take 5% by default.
# = (60 seconds / 0.1 seconds)
memory.MemorySampleEvent:
int(60 / 0.1),
},
default_max_events=int(
os.environ.get("DD_PROFILING_MAX_EVENTS",
recorder.Recorder._DEFAULT_MAX_EVENTS)),
)
return [
stack.StackCollector(r, tracer=tracer),
memory.MemoryCollector(r),
exceptions.UncaughtExceptionCollector(r),
threading.LockCollector(r),
]
def test_memory_alloc_speed_patched(benchmark, pct):
r = recorder.Recorder()
with memory.MemoryCollector(r, capture_pct=pct):
benchmark(_alloc)
def test_max_capture_over():
r = recorder.Recorder()
with pytest.raises(ValueError):
memory.MemoryCollector(r, capture_pct=200)
