adjust percentile timer record method

Add the ability to pass process.hrtime() directly to the record method,
because this is the simplest way to record latency durations. This keeps
the usage similar to timers.

Author: copperlight

package.json

@@ -1,6 +1,6 @@
 {
   "name": "nflx-spectator",
-  "version": "3.0.2",
+  "version": "3.0.3",
   "license": "Apache-2.0",
   "homepage": "https://github.com/Netflix/spectator-js",
   "author": "Netflix Telemetry Engineering <[email protected]>",

src/meter/percentile_timer.ts

@@ -17,9 +17,28 @@ export class PercentileTimer extends Meter {
         super(id, writer, "T");
     }
 
-    record(seconds: number): Promise<void> {
-        if (seconds >= 0) {
-            const line = `${this._meter_type_symbol}:${this._id.spectatord_id}:${seconds}`
+    /**
+     * @param {number|number[]} seconds
+     *     Number of seconds, which may be fractional, or an array of two numbers [seconds, nanoseconds],
+     *     which is the return value from process.hrtime(), and serves as a convenient means of recording
+     *     latency durations.
+     *
+     *     start = process.hrtime();
+     *     // do work
+     *     registry.pct_timer("eventLatency").record(process.hrtime(start));
+     *
+     */
+    record(seconds: number | number[]): Promise<void> {
+        let elapsed: number;
+
+        if (seconds instanceof Array) {
+            elapsed = seconds[0] + (seconds[1] / 1e9);
+        } else {
+            elapsed = seconds;
+        }
+
+        if (elapsed >= 0) {
+            const line = `${this._meter_type_symbol}:${this._id.spectatord_id}:${elapsed}`;
             return this._writer.write(line);
         } else {
             return new Promise((resolve: (value: void | PromiseLike<void>) => void): void => {

test/meter/percentile_timer.test.ts

@@ -1,5 +1,5 @@
 import {assert} from "chai";
-import {Id, MemoryWriter, PercentileTimer} from "../../src/index.js";
+import {Id, MemoryWriter, PercentileTimer, Timer} from "../../src/index.js";
 import {describe, it} from "node:test";
 
 describe("PercentileTimer Tests", (): void => {
@@ -28,4 +28,28 @@ describe("PercentileTimer Tests", (): void => {
         t.record(0);
         assert.equal("T:percentile_timer:0", writer.last_line());
     });
+
+    it("record latency from hrtime", (): void => {
+        let nanos: number = 0;
+        let round: number = 1;
+        const f: NodeJS.HRTime = process.hrtime;
+        Object.defineProperty(process, "hrtime", {
+            get(): () => [number, number] {
+                return (): [number, number] => {
+                    nanos += round * 1e6;  // 1ms lag first time, 2ms second time, etc.
+                    ++round;
+                    return [0, nanos];
+                };
+            }
+        });
+
+        const start: [number, number] = process.hrtime();
+
+        const t = new PercentileTimer(tid, new MemoryWriter());
+        const writer = t.writer() as MemoryWriter;
+        t.record(process.hrtime(start));  // two calls to hrtime = 1ms + 2ms = 3ms
+        assert.equal("T:percentile_timer:0.003", writer.last_line());
+
+        Object.defineProperty(process, "hrtime", f);
+    });
 });