diff --git a/doc/api/perf_hooks.md b/doc/api/perf_hooks.md
index 00b52d96889c61..97bcad3464f3cb 100644
--- a/doc/api/perf_hooks.md
+++ b/doc/api/perf_hooks.md
@@ -463,6 +463,23 @@ console.log(h.percentile(50));
 console.log(h.percentile(99));
 ```
 
+## `perf_hooks.monitorEventLoopIdleness([options])`
+<!-- YAML
+added: REPLACEME
+-->
+
+* `options` {Object}
+  * `resolution` {number} The sampling rate in milliseconds. Must be greater
+    than zero. **Default:** `10`.
+* Returns: {Histogram}
+
+Creates a `Histogram` object that samples and reports the event loop idleness
+over time (time difference between IO poll start and poll end). The idleness
+will be reported in nanoseconds.
+
+The behavior of `monitorEventLoopIdleness` is identical to
+[`monitorEventLoopDelay`][] above.
+
 ### Class: `Histogram`
 <!-- YAML
 added: v11.10.0
@@ -643,3 +660,4 @@ require('some-module');
 [`timeOrigin`]: https://w3c.github.io/hr-time/#dom-performance-timeorigin
 [Async Hooks]: async_hooks.html
 [W3C Performance Timeline]: https://w3c.github.io/performance-timeline/
+[`monitorEventLoopDelay`]: #perf_hooks_perf_hooks_monitoreventloopdelay_options
diff --git a/lib/internal/histogram.js b/lib/internal/histogram.js
new file mode 100644
index 00000000000000..6deb8314a41bbb
--- /dev/null
+++ b/lib/internal/histogram.js
@@ -0,0 +1,94 @@
+'use strict';
+
+const {
+  customInspectSymbol: kInspect,
+} = require('internal/util');
+
+const { format } = require('util');
+const { Map, Symbol } = primordials;
+
+const {
+  ERR_INVALID_ARG_TYPE,
+  ERR_INVALID_ARG_VALUE,
+} = require('internal/errors').codes;
+
+const kDestroy = Symbol('kDestroy');
+const kHandle = Symbol('kHandle');
+
+// Histograms are created internally by Node.js and used to
+// record various metrics. This Histogram class provides a
+// generally read-only view of the internal histogram.
+class Histogram {
+  #handle = undefined;
+  #map = new Map();
+
+  constructor(internal) {
+    this.#handle = internal;
+  }
+
+  [kInspect]() {
+    const obj = {
+      min: this.min,
+      max: this.max,
+      mean: this.mean,
+      exceeds: this.exceeds,
+      stddev: this.stddev,
+      percentiles: this.percentiles,
+    };
+    return `Histogram ${format(obj)}`;
+  }
+
+  get min() {
+    return this.#handle ? this.#handle.min() : undefined;
+  }
+
+  get max() {
+    return this.#handle ? this.#handle.max() : undefined;
+  }
+
+  get mean() {
+    return this.#handle ? this.#handle.mean() : undefined;
+  }
+
+  get exceeds() {
+    return this.#handle ? this.#handle.exceeds() : undefined;
+  }
+
+  get stddev() {
+    return this.#handle ? this.#handle.stddev() : undefined;
+  }
+
+  percentile(percentile) {
+    if (typeof percentile !== 'number')
+      throw new ERR_INVALID_ARG_TYPE('percentile', 'number', percentile);
+
+    if (percentile <= 0 || percentile > 100)
+      throw new ERR_INVALID_ARG_VALUE.RangeError('percentile', percentile);
+
+    return this.#handle ? this.#handle.percentile(percentile) : undefined;
+  }
+
+  get percentiles() {
+    this.#map.clear();
+    if (this.#handle)
+      this.#handle.percentiles(this.#map);
+    return this.#map;
+  }
+
+  reset() {
+    if (this.#handle)
+      this.#handle.reset();
+  }
+
+  [kDestroy]() {
+    this.#handle = undefined;
+  }
+
+  get [kHandle]() { return this.#handle; }
+}
+
+module.exports = {
+  Histogram,
+  kDestroy,
+  kHandle,
+};
diff --git a/lib/perf_hooks.js b/lib/perf_hooks.js
index 267b4577ffee3d..aca58bf4884e83 100644
--- a/lib/perf_hooks.js
+++ b/lib/perf_hooks.js
@@ -3,7 +3,6 @@
 const {
   ArrayIsArray,
   Boolean,
-  Map,
   NumberIsSafeInteger,
   ObjectDefineProperties,
   ObjectDefineProperty,
@@ -13,7 +12,8 @@ const {
 } = primordials;
 
 const {
-  ELDHistogram: _ELDHistogram,
+  ELDHistogram,
+  ELIHistogram,
   PerformanceEntry,
   mark: _mark,
   clearMark: _clearMark,
@@ -52,16 +52,18 @@ const kInspect = require('internal/util').customInspectSymbol;
 
 const {
   ERR_INVALID_CALLBACK,
-  ERR_INVALID_ARG_VALUE,
   ERR_INVALID_ARG_TYPE,
   ERR_INVALID_OPT_VALUE,
   ERR_VALID_PERFORMANCE_ENTRY_TYPE,
   ERR_INVALID_PERFORMANCE_MARK
 } = require('internal/errors').codes;
 
+const {
+  Histogram,
+  kHandle,
+} = require('internal/histogram');
+
 const { setImmediate } = require('timers');
-const kHandle = Symbol('handle');
-const kMap = Symbol('map');
 const kCallback = Symbol('callback');
 const kTypes = Symbol('types');
 const kEntries = Symbol('entries');
@@ -557,50 +559,27 @@ function sortedInsert(list, entry) {
   list.splice(location, 0, entry);
 }
 
-class ELDHistogram {
-  constructor(handle) {
-    this[kHandle] = handle;
-    this[kMap] = new Map();
-  }
-
-  reset() { this[kHandle].reset(); }
+class EventLoopHistogram extends Histogram {
   enable() { return this[kHandle].enable(); }
   disable() { return this[kHandle].disable(); }
+}
 
-  get exceeds() { return this[kHandle].exceeds(); }
-  get min() { return this[kHandle].min(); }
-  get max() { return this[kHandle].max(); }
-  get mean() { return this[kHandle].mean(); }
-  get stddev() { return this[kHandle].stddev(); }
-  percentile(percentile) {
-    if (typeof percentile !== 'number') {
-      throw new ERR_INVALID_ARG_TYPE('percentile', 'number', percentile);
-    }
-    if (percentile <= 0 || percentile > 100) {
-      throw new ERR_INVALID_ARG_VALUE.RangeError('percentile',
-                                                 percentile);
-    }
-    return this[kHandle].percentile(percentile);
+function monitorEventLoopDelay(options = {}) {
+  if (typeof options !== 'object' || options === null) {
+    throw new ERR_INVALID_ARG_TYPE('options', 'Object', options);
   }
-  get percentiles() {
-    this[kMap].clear();
-    this[kHandle].percentiles(this[kMap]);
-    return this[kMap];
+  const { resolution = 10 } = options;
+  if (typeof resolution !== 'number') {
+    throw new ERR_INVALID_ARG_TYPE('options.resolution',
+                                   'number', resolution);
   }
-
-  [kInspect]() {
-    return {
-      min: this.min,
-      max: this.max,
-      mean: this.mean,
-      stddev: this.stddev,
-      percentiles: this.percentiles,
-      exceeds: this.exceeds
-    };
+  if (resolution <= 0 || !NumberIsSafeInteger(resolution)) {
+    throw new ERR_INVALID_OPT_VALUE.RangeError('resolution', resolution);
   }
+  return new EventLoopHistogram(new ELDHistogram(resolution));
 }
 
-function monitorEventLoopDelay(options = {}) {
+function monitorEventLoopIdleness(options = {}) {
   if (typeof options !== 'object' || options === null) {
     throw new ERR_INVALID_ARG_TYPE('options', 'Object', options);
   }
@@ -612,13 +591,14 @@ function monitorEventLoopDelay(options = {}) {
   if (resolution <= 0 || !NumberIsSafeInteger(resolution)) {
     throw new ERR_INVALID_OPT_VALUE.RangeError('resolution', resolution);
   }
-  return new ELDHistogram(new _ELDHistogram(resolution));
+  return new EventLoopHistogram(new ELIHistogram(resolution));
 }
 
 module.exports = {
   performance,
   PerformanceObserver,
-  monitorEventLoopDelay
+  monitorEventLoopDelay,
+  monitorEventLoopIdleness
 };
 
 ObjectDefineProperty(module.exports, 'constants', {
diff --git a/node.gyp b/node.gyp
index 9c632d383852ae..b941eff56570e4 100644
--- a/node.gyp
+++ b/node.gyp
@@ -141,6 +141,7 @@
       'lib/internal/fs/watchers.js',
       'lib/internal/http.js',
       'lib/internal/heap_utils.js',
+      'lib/internal/histogram.js',
       'lib/internal/idna.js',
       'lib/internal/inspector_async_hook.js',
       'lib/internal/js_stream_socket.js',
@@ -534,6 +535,7 @@
         'src/fs_event_wrap.cc',
         'src/handle_wrap.cc',
         'src/heap_utils.cc',
+        'src/histogram.cc',
         'src/js_native_api.h',
         'src/js_native_api_types.h',
         'src/js_native_api_v8.cc',
diff --git a/src/async_wrap.h b/src/async_wrap.h
index 33bed41a6439c5..02ee259cb4120c 100644
--- a/src/async_wrap.h
+++ b/src/async_wrap.h
@@ -36,6 +36,7 @@ namespace node {
   V(DIRHANDLE)                                                                \
   V(DNSCHANNEL)                                                               \
   V(ELDHISTOGRAM)                                                             \
+  V(ELIHISTOGRAM)                                                             \
   V(FILEHANDLE)                                                               \
   V(FILEHANDLECLOSEREQ)                                                       \
   V(FSEVENTWRAP)                                                              \
diff --git a/src/env.h b/src/env.h
index 3b577e40307640..d9c4a87ab08a6c 100644
--- a/src/env.h
+++ b/src/env.h
@@ -406,6 +406,7 @@ constexpr size_t kFsStatsBufferLength =
   V(filehandlereadwrap_template, v8::ObjectTemplate)                           \
   V(fsreqpromise_constructor_template, v8::ObjectTemplate)                     \
   V(handle_wrap_ctor_template, v8::FunctionTemplate)                           \
+  V(histogram_ctor_template, v8::ObjectTemplate)                               \
   V(http2settings_constructor_template, v8::ObjectTemplate)                    \
   V(http2stream_constructor_template, v8::ObjectTemplate)                      \
   V(http2ping_constructor_template, v8::ObjectTemplate)                        \
diff --git a/src/histogram-inl.h b/src/histogram-inl.h
index 3135041f7387a9..58911dae8f2dae 100644
--- a/src/histogram-inl.h
+++ b/src/histogram-inl.h
@@ -4,58 +4,78 @@
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
 #include "histogram.h"
+#include "base_object-inl.h"
 #include "node_internals.h"
 
 namespace node {
 
-inline Histogram::Histogram(int64_t lowest, int64_t highest, int figures) {
-  CHECK_EQ(0, hdr_init(lowest, highest, figures, &histogram_));
+void Histogram::Reset() {
+  hdr_reset(histogram_.get());
 }
 
-inline Histogram::~Histogram() {
-  hdr_close(histogram_);
+bool Histogram::Record(int64_t value) {
+  return hdr_record_value(histogram_.get(), value);
 }
 
-inline void Histogram::Reset() {
-  hdr_reset(histogram_);
+int64_t Histogram::Min() {
+  return hdr_min(histogram_.get());
 }
 
-inline bool Histogram::Record(int64_t value) {
-  return hdr_record_value(histogram_, value);
+int64_t Histogram::Max() {
+  return hdr_max(histogram_.get());
 }
 
-inline int64_t Histogram::Min() {
-  return hdr_min(histogram_);
+double Histogram::Mean() {
+  return hdr_mean(histogram_.get());
 }
 
-inline int64_t Histogram::Max() {
-  return hdr_max(histogram_);
+double Histogram::Stddev() {
+  return hdr_stddev(histogram_.get());
 }
 
-inline double Histogram::Mean() {
-  return hdr_mean(histogram_);
-}
-
-inline double Histogram::Stddev() {
-  return hdr_stddev(histogram_);
-}
-
-inline double Histogram::Percentile(double percentile) {
+double Histogram::Percentile(double percentile) {
   CHECK_GT(percentile, 0);
   CHECK_LE(percentile, 100);
-  return hdr_value_at_percentile(histogram_, percentile);
+  return static_cast<double>(
+      hdr_value_at_percentile(histogram_.get(), percentile));
 }
 
-inline void Histogram::Percentiles(std::function<void(double, double)> fn) {
+template <typename Iterator>
+void Histogram::Percentiles(Iterator&& fn) {
   hdr_iter iter;
-  hdr_iter_percentile_init(&iter, histogram_, 1);
+  hdr_iter_percentile_init(&iter, histogram_.get(), 1);
   while (hdr_iter_next(&iter)) {
     double key = iter.specifics.percentiles.percentile;
-    double value = iter.value;
+    double value = static_cast<double>(iter.value);
     fn(key, value);
   }
 }
 
+bool HistogramBase::RecordDelta() {
+  uint64_t time = uv_hrtime();
+  bool ret = true;
+  if (prev_ > 0) {
+    int64_t delta = time - prev_;
+    if (delta > 0) {
+      ret = Record(delta);
+      TraceDelta(delta);
+      if (!ret) {
+        if (exceeds_ < 0xFFFFFFFF)
+          exceeds_++;
+        TraceExceeds(delta);
+      }
+    }
+  }
+  prev_ = time;
+  return ret;
+}
+
+void HistogramBase::ResetState() {
+  Reset();
+  exceeds_ = 0;
+  prev_ = 0;
+}
+
 }  // namespace node
 
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
diff --git a/src/histogram.cc b/src/histogram.cc
new file mode 100644
index 00000000000000..c0b47ec8c7f0aa
--- /dev/null
+++ b/src/histogram.cc
@@ -0,0 +1,141 @@
+#include "histogram.h"  // NOLINT(build/include_inline)
+#include "histogram-inl.h"
+#include "memory_tracker-inl.h"
+
+namespace node {
+
+using v8::FunctionCallbackInfo;
+using v8::FunctionTemplate;
+using v8::Local;
+using v8::Map;
+using v8::Number;
+using v8::ObjectTemplate;
+using v8::String;
+using v8::Value;
+
+Histogram::Histogram(int64_t lowest, int64_t highest, int figures) {
+  hdr_histogram* histogram;
+  CHECK_EQ(0, hdr_init(lowest, highest, figures, &histogram));
+  histogram_.reset(histogram);
+}
+
+HistogramBase::HistogramBase(
+    Environment* env,
+    v8::Local<v8::Object> wrap,
+    int64_t lowest,
+    int64_t highest,
+    int figures)
+    : BaseObject(env, wrap),
+      Histogram(lowest, highest, figures) {
+  MakeWeak();
+}
+
+void HistogramBase::MemoryInfo(MemoryTracker* tracker) const {
+  tracker->TrackFieldWithSize("histogram", GetMemorySize());
+}
+
+void HistogramBase::GetMin(const FunctionCallbackInfo<Value>& args) {
+  HistogramBase* histogram;
+  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+  double value = static_cast<double>(histogram->Min());
+  args.GetReturnValue().Set(value);
+}
+
+void HistogramBase::GetMax(const FunctionCallbackInfo<Value>& args) {
+  HistogramBase* histogram;
+  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+  double value = static_cast<double>(histogram->Max());
+  args.GetReturnValue().Set(value);
+}
+
+void HistogramBase::GetMean(const FunctionCallbackInfo<Value>& args) {
+  HistogramBase* histogram;
+  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+  args.GetReturnValue().Set(histogram->Mean());
+}
+
+void HistogramBase::GetExceeds(const FunctionCallbackInfo<Value>& args) {
+  HistogramBase* histogram;
+  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+  double value = static_cast<double>(histogram->Exceeds());
+  args.GetReturnValue().Set(value);
+}
+
+void HistogramBase::GetStddev(const FunctionCallbackInfo<Value>& args) {
+  HistogramBase* histogram;
+  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+  args.GetReturnValue().Set(histogram->Stddev());
+}
+
+void HistogramBase::GetPercentile(
+    const FunctionCallbackInfo<Value>& args) {
+  HistogramBase* histogram;
+  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+  CHECK(args[0]->IsNumber());
+  double percentile = args[0].As<Number>()->Value();
+  args.GetReturnValue().Set(histogram->Percentile(percentile));
+}
+
+void HistogramBase::GetPercentiles(
+    const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  HistogramBase* histogram;
+  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+  CHECK(args[0]->IsMap());
+  Local<Map> map = args[0].As<Map>();
+  histogram->Percentiles([map,env](double key, double value) {
+    map->Set(
+        env->context(),
+        Number::New(env->isolate(), key),
+        Number::New(env->isolate(), value)).IsEmpty();
+  });
+}
+
+void HistogramBase::DoReset(const FunctionCallbackInfo<Value>& args) {
+  HistogramBase* histogram;
+  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+  histogram->ResetState();
+}
+
+BaseObjectPtr<HistogramBase> HistogramBase::New(
+    Environment* env,
+    int64_t lowest,
+    int64_t highest,
+    int figures) {
+  CHECK_LE(lowest, highest);
+  CHECK_GT(figures, 0);
+  v8::Local<v8::Object> obj;
+  auto tmpl = env->histogram_ctor_template();
+  if (!tmpl->NewInstance(env->context()).ToLocal(&obj))
+    return {};
+
+  return MakeDetachedBaseObject<HistogramBase>(
+      env, obj, lowest, highest, figures);
+}
+
+void HistogramBase::Initialize(Environment* env) {
+  // Guard against multiple initializations
+  if (!env->histogram_ctor_template().IsEmpty())
+    return;
+
+  Local<FunctionTemplate> histogram = FunctionTemplate::New(env->isolate());
+  Local<String> classname = FIXED_ONE_BYTE_STRING(env->isolate(), "Histogram");
+  histogram->SetClassName(classname);
+
+  Local<ObjectTemplate> histogramt =
+    histogram->InstanceTemplate();
+
+  histogramt->SetInternalFieldCount(1);
+  env->SetProtoMethod(histogram, "exceeds", HistogramBase::GetExceeds);
+  env->SetProtoMethod(histogram, "min", HistogramBase::GetMin);
+  env->SetProtoMethod(histogram, "max", HistogramBase::GetMax);
+  env->SetProtoMethod(histogram, "mean", HistogramBase::GetMean);
+  env->SetProtoMethod(histogram, "stddev", HistogramBase::GetStddev);
+  env->SetProtoMethod(histogram, "percentile", HistogramBase::GetPercentile);
+  env->SetProtoMethod(histogram, "percentiles", HistogramBase::GetPercentiles);
+  env->SetProtoMethod(histogram, "reset", HistogramBase::DoReset);
+
+  env->set_histogram_ctor_template(histogramt);
+}
+
+}  // namespace node
diff --git a/src/histogram.h b/src/histogram.h
index eb94af5da2a997..e92c31c4724ac6 100644
--- a/src/histogram.h
+++ b/src/histogram.h
@@ -4,15 +4,24 @@
 #if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
 
 #include "hdr_histogram.h"
+#include "base_object.h"
+#include "util.h"
+
 #include <functional>
+#include <limits>
 #include <map>
 
 namespace node {
 
+constexpr int kDefaultHistogramFigures = 3;
+
 class Histogram {
  public:
-  inline Histogram(int64_t lowest, int64_t highest, int figures = 3);
-  inline virtual ~Histogram();
+  Histogram(
+      int64_t lowest = std::numeric_limits<int64_t>::min(),
+      int64_t highest = std::numeric_limits<int64_t>::max(),
+      int figures = kDefaultHistogramFigures);
+  virtual ~Histogram() = default;
 
   inline bool Record(int64_t value);
   inline void Reset();
@@ -21,14 +30,65 @@ class Histogram {
   inline double Mean();
   inline double Stddev();
   inline double Percentile(double percentile);
-  inline void Percentiles(std::function<void(double, double)> fn);
+
+  // Iterator is a function type that takes two doubles as argument, one for
+  // percentile and one for the value at that percentile.
+  template <typename Iterator>
+  inline void Percentiles(Iterator&& fn);
 
   size_t GetMemorySize() const {
-    return hdr_get_memory_size(histogram_);
+    return hdr_get_memory_size(histogram_.get());
   }
 
  private:
-  hdr_histogram* histogram_;
+  using HistogramPointer = DeleteFnPtr<hdr_histogram, hdr_close>;
+  HistogramPointer histogram_;
+};
+
+class HistogramBase : public BaseObject, public Histogram {
+ public:
+  virtual ~HistogramBase() = default;
+
+  virtual void TraceDelta(int64_t delta) {}
+  virtual void TraceExceeds(int64_t delta) {}
+
+  inline bool RecordDelta();
+  inline void ResetState();
+
+  int64_t Exceeds() const { return exceeds_; }
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_MEMORY_INFO_NAME(HistogramBase)
+  SET_SELF_SIZE(HistogramBase)
+
+  static void GetMin(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMax(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetMean(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetExceeds(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetStddev(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetPercentile(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetPercentiles(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void DoReset(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Initialize(Environment* env);
+
+  static BaseObjectPtr<HistogramBase> New(
+      Environment* env,
+      int64_t lowest = std::numeric_limits<int64_t>::min(),
+      int64_t highest = std::numeric_limits<int64_t>::max(),
+      int figures = kDefaultHistogramFigures);
+
+  HistogramBase(
+      Environment* env,
+      v8::Local<v8::Object> wrap,
+      int64_t lowest = std::numeric_limits<int64_t>::min(),
+      int64_t highest = std::numeric_limits<int64_t>::max(),
+      int figures = kDefaultHistogramFigures);
+
+ private:
+  int64_t exceeds_ = 0;
+  uint64_t prev_ = 0;
 };
 
 }  // namespace node
diff --git a/src/node_perf.cc b/src/node_perf.cc
index 68b015f33eda49..c463b0b769c7bb 100644
--- a/src/node_perf.cc
+++ b/src/node_perf.cc
@@ -396,113 +396,158 @@ void Notify(const FunctionCallbackInfo<Value>& args) {
 }
 
 
-// Event Loop Timing Histogram
-namespace {
-static void ELDHistogramMin(const FunctionCallbackInfo<Value>& args) {
-  ELDHistogram* histogram;
-  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
-  double value = static_cast<double>(histogram->Min());
-  args.GetReturnValue().Set(value);
-}
+template <class T>
+class EventLoopHistogramBinding {
+ public:
+  static void Declare(
+      Environment* env,
+      Local<Context> context,
+      Local<Object> target,
+      Local<String> classname) {
+    Local<FunctionTemplate> t = env->NewFunctionTemplate(New);
+    t->SetClassName(classname);
+    t->InstanceTemplate()->SetInternalFieldCount(1);
+    env->SetProtoMethod(t, "exceeds", Exceeds);
+    env->SetProtoMethod(t, "min", Min);
+    env->SetProtoMethod(t, "max", Max);
+    env->SetProtoMethod(t, "mean", Mean);
+    env->SetProtoMethod(t, "stddev", Stddev);
+    env->SetProtoMethod(t, "percentile", Percentile);
+    env->SetProtoMethod(t, "percentiles", Percentiles);
+    env->SetProtoMethod(t, "enable", Enable);
+    env->SetProtoMethod(t, "disable", Disable);
+    env->SetProtoMethod(t, "reset", Reset);
+    target->Set(context, classname,
+                t->GetFunction(env->context()).ToLocalChecked()).Check();
+  }
 
-static void ELDHistogramMax(const FunctionCallbackInfo<Value>& args) {
-  ELDHistogram* histogram;
-  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
-  double value = static_cast<double>(histogram->Max());
-  args.GetReturnValue().Set(value);
-}
+ protected:
+  static void Min(const FunctionCallbackInfo<Value>& args) {
+    T* histogram;
+    ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+    double value = static_cast<double>(histogram->Min());
+    args.GetReturnValue().Set(value);
+  }
 
-static void ELDHistogramMean(const FunctionCallbackInfo<Value>& args) {
-  ELDHistogram* histogram;
-  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
-  args.GetReturnValue().Set(histogram->Mean());
-}
+  static void Max(const FunctionCallbackInfo<Value>& args) {
+    T* histogram;
+    ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+    double value = static_cast<double>(histogram->Max());
+    args.GetReturnValue().Set(value);
+  }
 
-static void ELDHistogramExceeds(const FunctionCallbackInfo<Value>& args) {
-  ELDHistogram* histogram;
-  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
-  double value = static_cast<double>(histogram->Exceeds());
-  args.GetReturnValue().Set(value);
-}
+  static void Mean(const FunctionCallbackInfo<Value>& args) {
+    T* histogram;
+    ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+    args.GetReturnValue().Set(histogram->Mean());
+  }
 
-static void ELDHistogramStddev(const FunctionCallbackInfo<Value>& args) {
-  ELDHistogram* histogram;
-  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
-  args.GetReturnValue().Set(histogram->Stddev());
-}
+  static void Exceeds(const FunctionCallbackInfo<Value>& args) {
+    T* histogram;
+    ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+    double value = static_cast<double>(histogram->Exceeds());
+    args.GetReturnValue().Set(value);
+  }
 
-static void ELDHistogramPercentile(const FunctionCallbackInfo<Value>& args) {
-  ELDHistogram* histogram;
-  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
-  CHECK(args[0]->IsNumber());
-  double percentile = args[0].As<Number>()->Value();
-  args.GetReturnValue().Set(histogram->Percentile(percentile));
-}
+  static void Stddev(const FunctionCallbackInfo<Value>& args) {
+    T* histogram;
+    ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+    args.GetReturnValue().Set(histogram->Stddev());
+  }
 
-static void ELDHistogramPercentiles(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-  ELDHistogram* histogram;
-  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
-  CHECK(args[0]->IsMap());
-  Local<Map> map = args[0].As<Map>();
-  histogram->Percentiles([&](double key, double value) {
-    map->Set(env->context(),
-             Number::New(env->isolate(), key),
-             Number::New(env->isolate(), value)).IsEmpty();
-  });
-}
+  static void Percentile(const FunctionCallbackInfo<Value>& args) {
+    T* histogram;
+    ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+    CHECK(args[0]->IsNumber());
+    double percentile = args[0].As<Number>()->Value();
+    args.GetReturnValue().Set(histogram->Percentile(percentile));
+  }
 
-static void ELDHistogramEnable(const FunctionCallbackInfo<Value>& args) {
-  ELDHistogram* histogram;
-  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
-  args.GetReturnValue().Set(histogram->Enable());
-}
+  static void Percentiles(const FunctionCallbackInfo<Value>& args) {
+    Environment* env = Environment::GetCurrent(args);
+    T* histogram;
+    ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+    CHECK(args[0]->IsMap());
+    Local<Map> map = args[0].As<Map>();
+    histogram->Percentiles([&](double key, double value) {
+      map->Set(env->context(),
+               Number::New(env->isolate(), key),
+               Number::New(env->isolate(), value)).IsEmpty();
+    });
+  }
+
+  static void Enable(const FunctionCallbackInfo<Value>& args) {
+    T* histogram;
+    ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+    args.GetReturnValue().Set(histogram->Enable());
+  }
+
+  static void Disable(const FunctionCallbackInfo<Value>& args) {
+    T* histogram;
+    ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+    args.GetReturnValue().Set(histogram->Disable());
+  }
+
+  static void Reset(const FunctionCallbackInfo<Value>& args) {
+    T* histogram;
+    ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
+    histogram->ResetState();
+  }
 
-static void ELDHistogramDisable(const FunctionCallbackInfo<Value>& args) {
-  ELDHistogram* histogram;
-  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
-  args.GetReturnValue().Set(histogram->Disable());
+  static void New(const FunctionCallbackInfo<Value>& args) {
+    Environment* env = Environment::GetCurrent(args);
+    CHECK(args.IsConstructCall());
+    int32_t resolution = args[0]->IntegerValue(env->context()).FromJust();
+    CHECK_GT(resolution, 0);
+    new T(env, args.This(), resolution);
+  }
+};
+
+EventLoopHistogram::EventLoopHistogram(int32_t resolution)
+  : Histogram(1, 3.6e12),
+    resolution_(resolution) {
 }
 
-static void ELDHistogramReset(const FunctionCallbackInfo<Value>& args) {
-  ELDHistogram* histogram;
-  ASSIGN_OR_RETURN_UNWRAP(&histogram, args.Holder());
-  histogram->ResetState();
+bool EventLoopHistogram::Enable() {
+  if (enabled_)
+    return false;
+  enabled_ = true;
+  prev_ = 0;
+  return true;
 }
 
-static void ELDHistogramNew(const FunctionCallbackInfo<Value>& args) {
-  Environment* env = Environment::GetCurrent(args);
-  CHECK(args.IsConstructCall());
-  int32_t resolution = args[0]->IntegerValue(env->context()).FromJust();
-  CHECK_GT(resolution, 0);
-  new ELDHistogram(env, args.This(), resolution);
+bool EventLoopHistogram::Disable() {
+  if (!enabled_)
+    return false;
+  enabled_ = false;
+  return true;
 }
-}  // namespace
 
 ELDHistogram::ELDHistogram(
     Environment* env,
     Local<Object> wrap,
-    int32_t resolution) : HandleWrap(env,
-                                     wrap,
-                                     reinterpret_cast<uv_handle_t*>(&timer_),
-                                     AsyncWrap::PROVIDER_ELDHISTOGRAM),
-                          Histogram(1, 3.6e12),
-                          resolution_(resolution) {
+    int32_t resolution)
+  : HandleWrap(
+      env,
+      wrap,
+      reinterpret_cast<uv_handle_t*>(&timer_),
+      AsyncWrap::PROVIDER_ELDHISTOGRAM),
+    EventLoopHistogram(resolution) {
   MakeWeak();
-  uv_timer_init(env->event_loop(), &timer_);
+  CHECK_EQ(uv_timer_init(env->event_loop(), &timer_), 0);
 }
 
 void ELDHistogram::DelayIntervalCallback(uv_timer_t* req) {
   ELDHistogram* histogram = ContainerOf(&ELDHistogram::timer_, req);
   histogram->RecordDelta();
   TRACE_COUNTER1(TRACING_CATEGORY_NODE2(perf, event_loop),
-                 "min", histogram->Min());
+                 "delay_min", histogram->Min());
   TRACE_COUNTER1(TRACING_CATEGORY_NODE2(perf, event_loop),
-                 "max", histogram->Max());
+                 "delay_max", histogram->Max());
   TRACE_COUNTER1(TRACING_CATEGORY_NODE2(perf, event_loop),
-                 "mean", histogram->Mean());
+                 "delay_mean", histogram->Mean());
   TRACE_COUNTER1(TRACING_CATEGORY_NODE2(perf, event_loop),
-                 "stddev", histogram->Stddev());
+                 "delay_stddev", histogram->Stddev());
 }
 
 bool ELDHistogram::RecordDelta() {
@@ -529,21 +574,122 @@ bool ELDHistogram::RecordDelta() {
 }
 
 bool ELDHistogram::Enable() {
-  if (enabled_ || IsHandleClosing()) return false;
-  enabled_ = true;
-  prev_ = 0;
-  uv_timer_start(&timer_,
-                 DelayIntervalCallback,
-                 resolution_,
-                 resolution_);
+  if (IsHandleClosing()) {
+    return false;
+  }
+  if (!EventLoopHistogram::Enable()) {
+    return false;
+  }
+  CHECK_EQ(uv_timer_start(
+        &timer_,
+        DelayIntervalCallback,
+        resolution_,
+        resolution_),
+      0);
   uv_unref(reinterpret_cast<uv_handle_t*>(&timer_));
   return true;
 }
 
 bool ELDHistogram::Disable() {
-  if (!enabled_ || IsHandleClosing()) return false;
-  enabled_ = false;
-  uv_timer_stop(&timer_);
+  if (IsHandleClosing()) {
+    return false;
+  }
+  if (!EventLoopHistogram::Disable()) {
+    return false;
+  }
+  CHECK_EQ(uv_timer_stop(&timer_), 0);
+  return true;
+}
+
+ELIHistogram::ELIHistogram(
+    Environment* env,
+    Local<Object> wrap,
+    int32_t resolution)
+  : HandleWrap(
+      env,
+      wrap,
+      reinterpret_cast<uv_handle_t*>(&prepare_),
+      AsyncWrap::PROVIDER_ELIHISTOGRAM),
+    EventLoopHistogram(resolution) {
+  MakeWeak();
+  CHECK_EQ(uv_prepare_init(env->event_loop(), &prepare_), 0);
+  CHECK_EQ(uv_check_init(env->event_loop(), &check_), 0);
+}
+
+void ELIHistogram::Close(Local<Value> close_callback) {
+  // HandleWrap::Close will call `uv_close()` on `prepare_` and both
+  // structures will be freed in `HandleWrap::OnClose`.
+  // Thus it is safe to call `uv_close` with `nullptr` here.
+  if (!IsHandleClosing())
+    uv_close(reinterpret_cast<uv_handle_t*>(&check_), nullptr);
+
+  HandleWrap::Close(close_callback);
+}
+
+void ELIHistogram::PrepareCallback(uv_prepare_t* handle) {
+  ELIHistogram* histogram = ContainerOf(&ELIHistogram::prepare_, handle);
+  histogram->RecordPollStart();
+}
+
+void ELIHistogram::CheckCallback(uv_check_t* handle) {
+  ELIHistogram* histogram = ContainerOf(&ELIHistogram::check_, handle);
+  histogram->RecordPollEnd();
+  TRACE_COUNTER1(TRACING_CATEGORY_NODE2(perf, event_loop),
+                 "idle_min", histogram->Min());
+  TRACE_COUNTER1(TRACING_CATEGORY_NODE2(perf, event_loop),
+                 "idle_max", histogram->Max());
+  TRACE_COUNTER1(TRACING_CATEGORY_NODE2(perf, event_loop),
+                 "idle_mean", histogram->Mean());
+  TRACE_COUNTER1(TRACING_CATEGORY_NODE2(perf, event_loop),
+                 "idle_stddev", histogram->Stddev());
+}
+
+void ELIHistogram::RecordPollStart() {
+  prev_ = uv_hrtime();
+}
+
+void ELIHistogram::RecordPollEnd() {
+  if (prev_ == 0) {
+    return;
+  }
+
+  int64_t delta = uv_hrtime() - prev_;
+  if (delta <= 0) {
+    return;
+  }
+  bool ret = Record(delta);
+  TRACE_COUNTER1(TRACING_CATEGORY_NODE2(perf, event_loop),
+                 "idle", delta);
+  if (ret) {
+    return;
+  }
+  if (exceeds_ < 0xFFFFFFFF) {
+    exceeds_++;
+  }
+  ProcessEmitWarning(
+      env(),
+      "Event loop idleness exceeded 1 hour: %" PRId64 " nanoseconds",
+      delta);
+}
+
+bool ELIHistogram::Enable() {
+  if (!EventLoopHistogram::Enable()) {
+    return false;
+  }
+  CHECK_EQ(uv_prepare_start(&prepare_, PrepareCallback), 0);
+  CHECK_EQ(uv_check_start(&check_, CheckCallback), 0);
+
+  uv_unref(reinterpret_cast<uv_handle_t*>(&prepare_));
+  uv_unref(reinterpret_cast<uv_handle_t*>(&check_));
+  return true;
+}
+
+bool ELIHistogram::Disable() {
+  if (!EventLoopHistogram::Disable()) {
+    return false;
+  }
+  CHECK_EQ(uv_prepare_stop(&prepare_), 0);
+  CHECK_EQ(uv_check_stop(&check_), 0);
   return true;
 }
 
@@ -636,23 +782,16 @@ void Initialize(Local<Object> target,
                             constants,
                             attr).ToChecked();
 
-  Local<String> eldh_classname = FIXED_ONE_BYTE_STRING(isolate, "ELDHistogram");
-  Local<FunctionTemplate> eldh =
-      env->NewFunctionTemplate(ELDHistogramNew);
-  eldh->SetClassName(eldh_classname);
-  eldh->InstanceTemplate()->SetInternalFieldCount(1);
-  env->SetProtoMethod(eldh, "exceeds", ELDHistogramExceeds);
-  env->SetProtoMethod(eldh, "min", ELDHistogramMin);
-  env->SetProtoMethod(eldh, "max", ELDHistogramMax);
-  env->SetProtoMethod(eldh, "mean", ELDHistogramMean);
-  env->SetProtoMethod(eldh, "stddev", ELDHistogramStddev);
-  env->SetProtoMethod(eldh, "percentile", ELDHistogramPercentile);
-  env->SetProtoMethod(eldh, "percentiles", ELDHistogramPercentiles);
-  env->SetProtoMethod(eldh, "enable", ELDHistogramEnable);
-  env->SetProtoMethod(eldh, "disable", ELDHistogramDisable);
-  env->SetProtoMethod(eldh, "reset", ELDHistogramReset);
-  target->Set(context, eldh_classname,
-              eldh->GetFunction(env->context()).ToLocalChecked()).Check();
+  EventLoopHistogramBinding<ELDHistogram>::Declare(
+      env,
+      context,
+      target,
+      FIXED_ONE_BYTE_STRING(env->isolate(), "ELDHistogram"));
+  EventLoopHistogramBinding<ELIHistogram>::Declare(
+      env,
+      context,
+      target,
+      FIXED_ONE_BYTE_STRING(env->isolate(), "ELIHistogram"));
 }
 
 }  // namespace performance
diff --git a/src/node_perf.h b/src/node_perf.h
index 4f5ca93f223289..a264dd649cbe94 100644
--- a/src/node_perf.h
+++ b/src/node_perf.h
@@ -147,13 +147,10 @@ class GCPerformanceEntry : public PerformanceEntry {
   PerformanceGCFlags gcflags_;
 };
 
-class ELDHistogram : public HandleWrap, public Histogram {
+class EventLoopHistogram : public Histogram {
  public:
-  ELDHistogram(Environment* env,
-               Local<Object> wrap,
-               int32_t resolution);
+  explicit EventLoopHistogram(int32_t resolution);
 
-  bool RecordDelta();
   bool Enable();
   bool Disable();
   void ResetState() {
@@ -161,7 +158,25 @@ class ELDHistogram : public HandleWrap, public Histogram {
     exceeds_ = 0;
     prev_ = 0;
   }
-  int64_t Exceeds() { return exceeds_; }
+  int64_t Exceeds() const { return exceeds_; }
+
+ protected:
+  bool enabled_ = false;
+  int32_t resolution_ = 0;
+  int64_t exceeds_ = 0;
+  uint64_t prev_ = 0;
+};
+
+// ELD = Event-Loop Delay
+class ELDHistogram : public HandleWrap, public EventLoopHistogram {
+ public:
+  ELDHistogram(Environment* env,
+               Local<Object> wrap,
+               int32_t resolution);
+
+  bool RecordDelta();
+  bool Enable();
+  bool Disable();
 
   void MemoryInfo(MemoryTracker* tracker) const override {
     tracker->TrackFieldWithSize("histogram", GetMemorySize());
@@ -173,13 +188,39 @@ class ELDHistogram : public HandleWrap, public Histogram {
  private:
   static void DelayIntervalCallback(uv_timer_t* req);
 
-  bool enabled_ = false;
-  int32_t resolution_ = 0;
-  int64_t exceeds_ = 0;
-  uint64_t prev_ = 0;
   uv_timer_t timer_;
 };
 
+// ELI = Event-Loop Idleness
+class ELIHistogram : public HandleWrap, public EventLoopHistogram {
+ public:
+  ELIHistogram(Environment* env,
+               Local<Object> wrap,
+               int32_t resolution);
+
+  void RecordPollStart();
+  void RecordPollEnd();
+
+  bool Enable();
+  bool Disable();
+
+  void MemoryInfo(MemoryTracker* tracker) const override {
+    tracker->TrackFieldWithSize("histogram", GetMemorySize());
+  }
+
+  void Close(Local<Value> close_callback) override;
+
+  SET_MEMORY_INFO_NAME(ELIHistogram)
+  SET_SELF_SIZE(ELIHistogram)
+
+ private:
+  static void PrepareCallback(uv_prepare_t* handle);
+  static void CheckCallback(uv_check_t* handle);
+
+  uv_prepare_t prepare_;
+  uv_check_t check_;
+};
+
 }  // namespace performance
 }  // namespace node
 
diff --git a/test/sequential/test-async-wrap-getasyncid.js b/test/sequential/test-async-wrap-getasyncid.js
index ab1f2110a3debc..e8c3366a39848e 100644
--- a/test/sequential/test-async-wrap-getasyncid.js
+++ b/test/sequential/test-async-wrap-getasyncid.js
@@ -51,6 +51,7 @@ const { getSystemErrorName } = require('util');
     delete providers.HTTPCLIENTREQUEST;
     delete providers.HTTPINCOMINGMESSAGE;
     delete providers.ELDHISTOGRAM;
+    delete providers.ELIHISTOGRAM;
     delete providers.SIGINTWATCHDOG;
     delete providers.WORKERHEAPSNAPSHOT;
 
diff --git a/test/sequential/test-performance-eventloop-metrics.js b/test/sequential/test-performance-eventloop-metrics.js
new file mode 100644
index 00000000000000..5d4e1d0ef4ad4c
--- /dev/null
+++ b/test/sequential/test-performance-eventloop-metrics.js
@@ -0,0 +1,73 @@
+// Flags: --expose-gc --expose-internals
+'use strict';
+
+require('../common');
+
+const assert = require('assert');
+const {
+  monitorEventLoopDelay,
+  monitorEventLoopIdleness
+} = require('perf_hooks');
+
+for (const method of [ monitorEventLoopDelay, monitorEventLoopIdleness ]) {
+  {
+    const histogram = method();
+    assert(histogram);
+    assert(histogram.enable());
+    assert(!histogram.enable());
+    histogram.reset();
+    assert(histogram.disable());
+    assert(!histogram.disable());
+  }
+
+  {
+    [null, 'a', 1, false, Infinity].forEach((i) => {
+      assert.throws(
+        () => method(i),
+        {
+          name: 'TypeError',
+          code: 'ERR_INVALID_ARG_TYPE'
+        }
+      );
+    });
+
+    [null, 'a', false, {}, []].forEach((i) => {
+      assert.throws(
+        () => method({ resolution: i }),
+        {
+          name: 'TypeError',
+          code: 'ERR_INVALID_ARG_TYPE'
+        }
+      );
+    });
+
+    [-1, 0, Infinity].forEach((i) => {
+      assert.throws(
+        () => method({ resolution: i }),
+        {
+          name: 'RangeError',
+          code: 'ERR_INVALID_OPT_VALUE'
+        }
+      );
+    });
+
+    ['a', false, {}, []].forEach((i) => {
+      assert.throws(
+        () => method().percentile(i),
+        {
+          name: 'TypeError',
+          code: 'ERR_INVALID_ARG_TYPE'
+        }
+      );
+    });
+    [-1, 0, 101].forEach((i) => {
+      assert.throws(
+        () => method().percentile(i),
+        {
+          name: 'RangeError',
+          code: 'ERR_INVALID_ARG_VALUE'
+        }
+      );
+    });
+  }
+}
diff --git a/test/sequential/test-performance-eventloopdelay.js b/test/sequential/test-performance-eventloopdelay.js
index 47c54a2543fd54..e49831b0d32bf3 100644
--- a/test/sequential/test-performance-eventloopdelay.js
+++ b/test/sequential/test-performance-eventloopdelay.js
@@ -8,97 +8,34 @@ const {
 } = require('perf_hooks');
 const { sleep } = require('internal/util');
 
-{
-  const histogram = monitorEventLoopDelay();
-  assert(histogram);
-  assert(histogram.enable());
-  assert(!histogram.enable());
-  histogram.reset();
-  assert(histogram.disable());
-  assert(!histogram.disable());
-}
-
-{
-  [null, 'a', 1, false, Infinity].forEach((i) => {
-    assert.throws(
-      () => monitorEventLoopDelay(i),
-      {
-        name: 'TypeError',
-        code: 'ERR_INVALID_ARG_TYPE'
-      }
-    );
-  });
-
-  [null, 'a', false, {}, []].forEach((i) => {
-    assert.throws(
-      () => monitorEventLoopDelay({ resolution: i }),
-      {
-        name: 'TypeError',
-        code: 'ERR_INVALID_ARG_TYPE'
-      }
-    );
-  });
-
-  [-1, 0, Infinity].forEach((i) => {
-    assert.throws(
-      () => monitorEventLoopDelay({ resolution: i }),
-      {
-        name: 'RangeError',
-        code: 'ERR_INVALID_OPT_VALUE'
-      }
-    );
-  });
-}
-
-{
-  const histogram = monitorEventLoopDelay({ resolution: 1 });
-  histogram.enable();
-  let m = 5;
-  function spinAWhile() {
-    sleep(1000);
-    if (--m > 0) {
-      setTimeout(spinAWhile, common.platformTimeout(500));
-    } else {
-      histogram.disable();
-      // The values are non-deterministic, so we just check that a value is
-      // present, as opposed to a specific value.
-      assert(histogram.min > 0);
-      assert(histogram.max > 0);
-      assert(histogram.stddev > 0);
-      assert(histogram.mean > 0);
-      assert(histogram.percentiles.size > 0);
-      for (let n = 1; n < 100; n = n + 0.1) {
-        assert(histogram.percentile(n) >= 0);
-      }
-      histogram.reset();
-      assert.strictEqual(histogram.min, 9223372036854776000);
-      assert.strictEqual(histogram.max, 0);
-      assert(Number.isNaN(histogram.stddev));
-      assert(Number.isNaN(histogram.mean));
-      assert.strictEqual(histogram.percentiles.size, 1);
-
-      ['a', false, {}, []].forEach((i) => {
-        assert.throws(
-          () => histogram.percentile(i),
-          {
-            name: 'TypeError',
-            code: 'ERR_INVALID_ARG_TYPE'
-          }
-        );
-      });
-      [-1, 0, 101].forEach((i) => {
-        assert.throws(
-          () => histogram.percentile(i),
-          {
-            name: 'RangeError',
-            code: 'ERR_INVALID_ARG_VALUE'
-          }
-        );
-      });
+const histogram = monitorEventLoopDelay({ resolution: 1 });
+histogram.enable();
+let m = 5;
+function spinAWhile() {
+  sleep(1000);
+  if (--m > 0) {
+    setTimeout(spinAWhile, common.platformTimeout(500));
+  } else {
+    histogram.disable();
+    // The values are non-deterministic, so we just check that a value is
+    // present, as opposed to a specific value.
+    assert(histogram.min > 0);
+    assert(histogram.max > 0);
+    assert(histogram.stddev > 0);
+    assert(histogram.mean > 0);
+    assert(histogram.percentiles.size > 0);
+    for (let n = 1; n < 100; n = n + 0.1) {
+      assert(histogram.percentile(n) >= 0);
     }
+    histogram.reset();
+    assert.strictEqual(histogram.min, 9223372036854776000);
+    assert.strictEqual(histogram.max, 0);
+    assert(Number.isNaN(histogram.stddev));
+    assert(Number.isNaN(histogram.mean));
+    assert.strictEqual(histogram.percentiles.size, 1);
   }
-  spinAWhile();
 }
+spinAWhile();
 
 // Make sure that the histogram instances can be garbage-collected without
 // and not just implictly destroyed when the Environment is torn down.
diff --git a/test/sequential/test-performance-eventloopidleness.js b/test/sequential/test-performance-eventloopidleness.js
new file mode 100644
index 00000000000000..7a3e38798e27c3
--- /dev/null
+++ b/test/sequential/test-performance-eventloopidleness.js
@@ -0,0 +1,48 @@
+// Flags: --expose-gc --expose-internals
+'use strict';
+
+require('../common');
+
+const assert = require('assert');
+const {
+  monitorEventLoopIdleness
+} = require('perf_hooks');
+
+const histogram = monitorEventLoopIdleness({ resolution: 1 });
+histogram.enable();
+
+const timeouts = [ 100, 200, 300, 400 ];
+
+function interrupt() {
+  const timeout = timeouts.shift();
+  if (timeout) {
+    setTimeout(interrupt, timeout);
+    return;
+  }
+
+  histogram.disable();
+
+  // We should get this from `400ms` delay above
+  assert(histogram.max >= 350 * 1000 * 1000);
+
+  // The values are non-deterministic, so we just check that a value is
+  // present, as opposed to a specific value.
+  assert(histogram.min > 0);
+  assert(histogram.stddev > 0);
+  assert(histogram.mean > 0);
+  assert(histogram.percentiles.size > 0);
+  for (let n = 1; n < 100; n = n + 0.1) {
+    assert(histogram.percentile(n) >= 0);
+  }
+  histogram.reset();
+  assert.strictEqual(histogram.min, 9223372036854776000);
+  assert.strictEqual(histogram.max, 0);
+  assert(Number.isNaN(histogram.stddev));
+  assert(Number.isNaN(histogram.mean));
+  assert.strictEqual(histogram.percentiles.size, 1);
+}
+interrupt();
+
+// Make sure that the histogram instances can be garbage-collected without
+// and not just implictly destroyed when the Environment is torn down.
+process.on('exit', global.gc);