@datadog/pprof 0.3.0 → 0.5.1

package/bindings/test/code-event-record.test.cc

@@ -0,0 +1,81 @@
+#include <unordered_map>
+#include <sstream>
+
+#include "code-event-record.test.hh"
+#include "../code-event-record.hh"
+
+void test_code_event_record(Tap& t) {
+  t.plan(19);
+
+  auto isolate = v8::Isolate::GetCurrent();
+
+  auto record = new dd::CodeEventRecord(
+      isolate, 1234, 0, 5678, 1, 2, "a", "b", "c");
+  record->SetScriptId(123);
+
+  // Type helpers
+  auto Str = [isolate](v8::Local<v8::Value> val) -> std::string {
+    return *v8::String::Utf8Value(isolate, val);
+  };
+
+  auto Int = [](v8::Local<v8::Value> val) -> int64_t {
+    return val.As<v8::Integer>()->Value();
+  };
+
+  t.equal(123, Int(record->GetScriptId(isolate)), "script id");
+  t.equal(1234, Int(record->GetAddress(isolate)), "address");
+  t.equal(0, Int(record->GetPreviousAddress(isolate)), "previous address");
+  t.equal(5678, Int(record->GetSize(isolate)), "size");
+  t.equal(1, Int(record->GetLine(isolate)), "line");
+  t.equal(2, Int(record->GetColumn(isolate)), "column");
+  t.equal("a", Str(record->GetComment(isolate)), "comment");
+  t.equal("b", Str(record->GetFunctionName(isolate)), "function name");
+  t.equal("c", Str(record->GetScriptName(isolate)), "script name");
+
+  auto same = new dd::CodeEventRecord(
+      isolate, 1234, 0, 5678, 1, 2, "a", "b", "c");
+  same->SetScriptId(123);
+  t.ok(record->Equal(same), "should be equal to itself");
+
+  using TestPair = std::pair<dd::CodeEventRecord*, dd::CodeEventRecord*>;
+  std::unordered_map<std::string, TestPair> non_matching = {
+    {"id",
+      {new dd::CodeEventRecord(isolate, 1, 1, 1, 1, 1, "a", "a", "a"),
+        new dd::CodeEventRecord(isolate, 1, 1, 1, 1, 1, "a", "a", "a")}},
+    {"address",
+      {new dd::CodeEventRecord(isolate, 1, 1, 1, 1, 1, "a", "a", "a"),
+        new dd::CodeEventRecord(isolate, 2, 1, 1, 1, 1, "a", "a", "a")}},
+    {"previousAddress",
+      {new dd::CodeEventRecord(isolate, 1, 1, 1, 1, 1, "a", "a", "a"),
+        new dd::CodeEventRecord(isolate, 1, 2, 1, 1, 1, "a", "a", "a")}},
+    {"size",
+      {new dd::CodeEventRecord(isolate, 1, 1, 1, 1, 1, "a", "a", "a"),
+        new dd::CodeEventRecord(isolate, 1, 1, 2, 1, 1, "a", "a", "a")}},
+    {"line",
+      {new dd::CodeEventRecord(isolate, 1, 1, 1, 1, 1, "a", "a", "a"),
+        new dd::CodeEventRecord(isolate, 1, 1, 1, 2, 1, "a", "a", "a")}},
+    {"column",
+      {new dd::CodeEventRecord(isolate, 1, 1, 1, 1, 1, "a", "a", "a"),
+        new dd::CodeEventRecord(isolate, 1, 1, 1, 1, 2, "a", "a", "a")}},
+    {"comment",
+      {new dd::CodeEventRecord(isolate, 1, 1, 1, 1, 1, "a", "a", "a"),
+        new dd::CodeEventRecord(isolate, 1, 1, 1, 1, 1, "b", "a", "a")}},
+    {"functionName",
+      {new dd::CodeEventRecord(isolate, 1, 1, 1, 1, 1, "a", "a", "a"),
+        new dd::CodeEventRecord(isolate, 1, 1, 1, 1, 1, "a", "b", "a")}},
+    {"scriptName",
+      {new dd::CodeEventRecord(isolate, 1, 1, 1, 1, 1, "a", "a", "a"),
+        new dd::CodeEventRecord(isolate, 1, 1, 1, 1, 1, "a", "a", "b")}}
+  };
+
+  // Script Id is not a constructor argument
+  non_matching["id"].second->SetScriptId(123);
+
+  for (const auto& pair : non_matching) {
+    auto name = pair.first;
+    auto test = pair.second;
+    std::ostringstream s;
+    s << "should not have equal " << name;
+    t.not_ok(test.first->Equal(test.second), s.str());
+  }
+}

package/bindings/test/code-event-record.test.hh

@@ -0,0 +1,5 @@
+#pragma once
+
+#include "tap.h"
+
+void test_code_event_record(Tap& t);

package/bindings/test/code-map.test.cc

@@ -0,0 +1,77 @@
+#include "code-map.test.hh"
+#include "../code-map.hh"
+
+void test_code_map(Tap& t) {
+  t.plan(11);
+
+  auto isolate = v8::Isolate::GetCurrent();
+
+  // Lookup in an empty map should return nullptr
+  {
+    dd::CodeMap map(isolate);
+    t.equal(map.Lookup(1234), nullptr, "should not find record in empty map");
+  }
+
+  auto record = std::make_shared<dd::CodeEventRecord>(
+    isolate, 1234, 0, 5678, 1, 2, "fn");
+
+  // Lookup with record at matching address should return record
+  {
+    dd::CodeMap map(isolate, {
+      { 1234, record }
+    });
+
+    t.ok(record->Equal(map.Lookup(1234).get()), "should find record by exact address");
+  }
+
+  // Lookup with address in size range of matching record should return record
+  {
+    dd::CodeMap map(isolate, {
+      { 1234, record }
+    });
+
+    t.ok(record->Equal(map.Lookup(2000).get()), "should find record in size range");
+  }
+
+  // Lookup with address outside size range should return nullptr
+  {
+    dd::CodeMap map(isolate, {
+      { 1234, record }
+    });
+
+    t.equal(map.Lookup(1000), nullptr, "should not find record below size range");
+    t.equal(map.Lookup(9001), nullptr, "should not find record above size range");
+  }
+
+  // Add a new record
+  {
+    dd::CodeMap map(isolate);
+    map.Add(1234, record);
+
+    t.ok(record->Equal(map.Lookup(1234).get()), "should find record after added");
+  }
+
+  // Remove an existing record
+  {
+    dd::CodeMap map(isolate, {
+      { 1234, record }
+    });
+    map.Remove(1234);
+
+    t.ok(!map.Lookup(1234), "should not find record after removal");
+  }
+
+  {
+    dd::CodeMap map(isolate);
+    t.equal((int)map.Entries().size(), 0, "should be empty before enabling");
+
+    map.Enable();
+    t.ok((int)map.Entries().size() > 0, "should not be empty after enabled");
+
+    map.Disable();
+    t.equal((int)map.Entries().size(), 0, "should be empty after disabling");
+
+    map.Enable();
+    t.ok((int)map.Entries().size() > 0, "should refill if enabled again");
+  }
+}

package/bindings/test/code-map.test.hh

@@ -0,0 +1,5 @@
+#pragma once
+
+#include "tap.h"
+
+void test_code_map(Tap& t);

package/bindings/test/cpu-time.test.cc

@@ -0,0 +1,30 @@
+#include "cpu-time.test.hh"
+#include "../cpu-time.hh"
+
+void test_cpu_time(Tap& t) {
+  t.plan(3);
+
+  dd::CpuTime cpu_time({
+    2, // tv_sec
+    1, // tv_nsec
+  });
+
+  int64_t diff = cpu_time.Diff({
+    4,  // tv_sec
+    3, // tv_nsec
+  });
+
+  t.equal(diff, 2000000002, "should compute time diff correctly");
+
+  struct timespec now = cpu_time.Now();
+  t.ok(
+    now.tv_nsec > 0 || now.tv_sec > 0,
+    "should get the current cpu time"
+  );
+
+  struct timespec now2 = cpu_time.Now();
+  t.ok(
+    now2.tv_nsec >= now.tv_nsec && now2.tv_sec >= now.tv_sec,
+    "should have current time after previous check"
+  );
+}

package/bindings/test/cpu-time.test.hh

@@ -0,0 +1,5 @@
+#pragma once
+
+#include "tap.h"
+
+void test_cpu_time(Tap& t);

package/bindings/test/location.test.cc

@@ -0,0 +1,39 @@
+#include "location.test.hh"
+#include "../location.hh"
+
+void test_location(Tap& t) {
+  t.plan(9);
+
+  auto isolate = v8::Isolate::GetCurrent();
+
+  auto record = std::make_shared<dd::CodeEventRecord>(
+      isolate, 1234, 0, 5678, 1, 2, "a", "b", "c");
+  record->SetScriptId(123);
+
+  auto obj = dd::Location::New(isolate, record)->handle();
+
+  // Type helpers
+  auto Get = [isolate](v8::Local<v8::Object> obj, std::string key)
+    -> v8::Local<v8::Value> {
+    auto context = isolate->GetCurrentContext();
+    return obj->Get(context, Nan::New(key).ToLocalChecked()).ToLocalChecked();
+  };
+
+  auto Str = [isolate](v8::Local<v8::Value> val) -> std::string {
+    return *v8::String::Utf8Value(isolate, val);
+  };
+
+  auto Int = [](v8::Local<v8::Value> val) -> int64_t {
+    return val.As<v8::Integer>()->Value();
+  };
+
+  t.equal(123, Int(Get(obj, "scriptId")), "script id");
+  t.equal(1234, Int(Get(obj, "address")), "address");
+  t.equal(0, Int(Get(obj, "previousAddress")), "previous address");
+  t.equal(5678, Int(Get(obj, "size")), "size");
+  t.equal(1, Int(Get(obj, "line")), "line");
+  t.equal(2, Int(Get(obj, "column")), "column");
+  t.equal("a", Str(Get(obj, "comment")), "comment");
+  t.equal("b", Str(Get(obj, "functionName")), "function name");
+  t.equal("c", Str(Get(obj, "scriptName")), "script name");
+}

package/bindings/test/location.test.hh

@@ -0,0 +1,5 @@
+#pragma once
+
+#include "tap.h"
+
+void test_location(Tap& t);

package/bindings/test/profilers/cpu.test.cc

@@ -0,0 +1,88 @@
+#include "cpu.test.hh"
+#include "../../profilers/cpu.hh"
+#include "../../location.hh"
+
+void test_labels(Tap& t) {
+  t.plan(2);
+
+  auto context = Nan::GetCurrentContext();
+  dd::CpuProfiler cpu;
+
+  t.ok(cpu.GetLabels()->IsUndefined(),
+    "should be undefined before setting");
+
+  auto labels = Nan::New<v8::Number>(1);
+  cpu.SetLabels(labels);
+
+  t.ok(cpu.GetLabels()->Equals(context, labels).ToChecked(),
+    "should match given labels value after setting");
+}
+
+void test_samples(Tap& t) {
+  t.plan(9);
+
+  auto isolate = v8::Isolate::GetCurrent();
+
+  dd::CpuProfiler cpu;
+
+  // Empty state
+  t.equal(0U, cpu.GetSampleCount(),
+    "no processed samples before capture");
+  t.ok(!cpu.GetLastSample(),
+    "no unprocessed sample after capture");
+
+  // Set labels to verify they get attached to captured samples
+  auto labels = Nan::New<v8::Number>(1);
+  cpu.SetLabels(labels);
+  cpu.CaptureSample(isolate);
+
+  t.equal(0U, cpu.GetSampleCount(),
+    "no processed samples after capture");
+  t.ok(cpu.GetLastSample(),
+    "has unprocessed sample after capture");
+  t.equal(labels, cpu.GetLastSample()->GetLabels(isolate),
+    "should have given labels on unprocessed sample after capture");
+
+  // Make a synthetic sample to set as the "last sample"
+  auto label_wrap = std::make_shared<dd::LabelWrap>(labels);
+  std::vector<uintptr_t> frames = {1234};
+  uint64_t cpu_time = 12345;
+
+  std::unique_ptr<dd::Sample> sample(
+    new dd::Sample(isolate, label_wrap, frames, cpu_time));
+
+  auto record = std::make_shared<dd::CodeEventRecord>(
+    isolate, 1234, 0, 5678, 1, 2, "fnA");
+
+  auto map = dd::CodeMap::For(isolate);
+  map->Clear();
+  map->Add(1234, record);
+
+  cpu.SetLastSample(std::move(sample));
+  cpu.ProcessSample();
+
+  t.equal(1U, cpu.GetSampleCount(),
+    "has processed sample after capture/process");
+
+  auto samples = cpu.GetSamples();
+  t.equal(1U, samples->Length(),
+    "should have one processed sample in samples array");
+
+  auto firstSample = Nan::Get(samples, 0).ToLocalChecked().As<v8::Object>();
+  auto locations = Nan::Get(firstSample, Nan::New("locations").ToLocalChecked())
+      .ToLocalChecked().As<v8::Array>();
+  t.equal(1U, locations->Length(),
+    "should have one symbolized stack frame");
+
+  auto location = Nan::ObjectWrap::Unwrap<dd::Location>(
+      Nan::Get(locations, 0).ToLocalChecked().As<v8::Object>());
+  t.equal(location->GetCodeEventRecord(), record,
+    "symbolization of processed sample should match expected code record");
+}
+
+void test_profilers_cpu_profiler(Tap& t) {
+  t.plan(2);
+
+  t.test("labels", test_labels);
+  t.test("samples", test_samples);
+}

package/bindings/test/profilers/cpu.test.hh

@@ -0,0 +1,5 @@
+#pragma once
+
+#include "../tap.h"
+
+void test_profilers_cpu_profiler(Tap& t);

package/bindings/test/sample.test.cc

@@ -0,0 +1,128 @@
+#include <sstream>
+
+#include "sample.test.hh"
+#include "../sample.hh"
+
+#include "../location.hh"
+
+void test_locations(Tap& t, v8::MaybeLocal<v8::Value> maybe_locations,
+                    std::vector<uintptr_t> frames,
+                    std::shared_ptr<dd::CodeMap> map) {
+  size_t n = frames.size();
+  t.plan(n + 3);
+
+  v8::Local<v8::Value> locations_value;
+  t.ok(
+    maybe_locations.ToLocal(&locations_value),
+    "location set should not be empty"
+  );
+  t.ok(
+    locations_value->IsArray(),
+    "location set should be an array"
+  );
+  v8::Local<v8::Array> locations = locations_value.As<v8::Array>();
+  t.equal(
+    (uint32_t) n,
+    locations->Length(),
+    "length should match the number of frames"
+  );
+
+  for (size_t i = 0; i < n; i++) {
+    std::ostringstream name("location #", std::ios_base::ate);
+    name << i;
+
+    auto record = map->Lookup(frames[n - i - 1]);
+    auto location = Nan::Get(locations, i)
+      .ToLocalChecked()
+      .As<v8::Object>();
+
+    auto wrap = Nan::ObjectWrap::Unwrap<dd::Location>(location);
+
+    t.equal(record, wrap->GetCodeEventRecord(), name.str());
+  }
+}
+
+void test_sample_to_object(Tap& t, v8::MaybeLocal<v8::Value> maybe_sample,
+                           std::vector<uintptr_t> frames,
+                           std::shared_ptr<dd::CodeMap> map,
+                           v8::Local<v8::Value> labels,
+                           uint64_t cpu_time) {
+  t.plan(4);
+  auto isolate = v8::Isolate::GetCurrent();
+  auto context = isolate->GetCurrentContext();
+
+  auto propIs = [=](v8::Local<v8::Object> object, std::string name,
+                    v8::Local<v8::Value> value) -> bool {
+    auto key = Nan::New(name).ToLocalChecked();
+    auto prop = object->Get(context, key).ToLocalChecked();
+    return prop->Equals(context, value).ToChecked();
+  };
+
+  v8::Local<v8::Value> sample_value;
+  t.ok(
+    maybe_sample.ToLocal(&sample_value),
+    "should unwrap sample object"
+  );
+  v8::Local<v8::Object> sample_object = sample_value.As<v8::Object>();
+  t.ok(
+    propIs(sample_object, "labels", labels),
+    "should have expected labels"
+  );
+  t.ok(
+    propIs(sample_object, "cpuTime", Nan::New<v8::Number>(cpu_time)),
+    "should have expected cpuTime"
+  );
+
+  auto locations = sample_object->Get(context,
+    Nan::New("locations").ToLocalChecked());
+
+  t.test("sample.locations", [=](Tap& t) {
+    test_locations(t, locations, frames, map);
+  });
+}
+
+void test_sample(Tap& t) {
+  t.plan(5);
+
+  auto isolate = v8::Isolate::GetCurrent();
+  auto context = isolate->GetCurrentContext();
+
+  auto labels = v8::Number::New(isolate, 9876);
+  auto label_wrap = std::make_shared<dd::LabelWrap>(labels);
+  std::vector<uintptr_t> frames = {1234, 2345};
+  uint64_t cpu_time = 12345;
+
+  dd::Sample* sample = new dd::Sample(isolate, label_wrap, frames, cpu_time);
+
+  t.ok(sample->GetLabels(isolate)->Equals(context, labels).ToChecked(),
+      "sample->Labels() should return supplied labels");
+  t.equal(sample->GetFrames(), frames,
+      "sample->GetFrames() should return supplied frames");
+
+  // Before symbolization, Locations() and ToObject() should be empty
+  t.equal(0u, sample->GetLocations(isolate)->Length(),
+      "location set should be empty before symbolizing");
+
+  // Do symbolization
+  auto recordA = std::make_shared<dd::CodeEventRecord>(
+    isolate, 1234, 0, 5678, 1, 2, "fnA");
+  auto recordB = std::make_shared<dd::CodeEventRecord>(
+    isolate, 2345, 0, 5678, 3, 4, "fnB");
+
+  auto map = dd::CodeMap::For(isolate);
+  map->Clear();
+  map->Add(1234, recordA);
+  map->Add(2345, recordB);
+
+  sample->Symbolize(map);
+
+  // After symbolization, Locations() should return a location array
+  t.test("sample->GetLocations()", [=](Tap& t) {
+    test_locations(t, sample->GetLocations(isolate), frames, map);
+  });
+
+  // After symbolization, ToObject() should return a valid sample object
+  t.test("sample->ToObject()", [=](Tap& t) {
+    test_sample_to_object(t, sample->ToObject(isolate), frames, map, labels, cpu_time);
+  });
+}

package/bindings/test/sample.test.hh

@@ -0,0 +1,5 @@
+#pragma once
+
+#include "tap.h"
+
+void test_sample(Tap& t);