@observertc/observer-js 1.3.0-rc.5 → 1.3.0-rc.6

package/dist/index.mjs

@@ -7985,9 +7985,96 @@ var TrendTester = class {
   }
 };
 
-// src/sinks/InMemorySink.ts
+// src/sinks/RollingJsonlFileSink.ts
+import * as fs2 from "fs";
 import { EventEmitter as EventEmitter8 } from "events";
-var InMemorySink = class extends EventEmitter8 {
+var RollingJsonlFileSink = class extends EventEmitter8 {
+  id;
+  _options;
+  _serializeSample;
+  _stream;
+  _path;
+  _index = -1;
+  _openedAt = 0;
+  _bytes = 0;
+  _ended = false;
+  // Resolves once every file closed so far has closed and been announced, in index order: the
+  // streams close independently, so a later file could otherwise be announced before an earlier one.
+  _closing = Promise.resolve();
+  constructor(options) {
+    super();
+    this._options = options;
+    this._serializeSample = options.serializeSample ?? ((record) => JSON.stringify(record));
+    this._open();
+    this.id = options.id ?? this._path;
+  }
+  /** The file currently written to. */
+  get path() {
+    return this._path;
+  }
+  /** The index of the file currently written to. */
+  get index() {
+    return this._index;
+  }
+  get ended() {
+    return this._ended;
+  }
+  write(record) {
+    if (this._ended) return false;
+    const line = `${this._serializeSample(record)}
+`;
+    const bytes = Buffer.byteLength(line);
+    const { maxBytes, maxAgeMs } = this._options;
+    if (maxAgeMs !== void 0 && maxAgeMs <= Date.now() - this._openedAt) this.roll();
+    if (maxBytes !== void 0 && maxBytes < this._bytes + bytes) this.roll();
+    this._bytes += bytes;
+    return this._stream.write(line);
+  }
+  /** Close the current file and continue in a new one. A no-op on an empty file or an ended sink. */
+  roll() {
+    if (this._ended || this._bytes === 0) return;
+    this._closeCurrent();
+    this._open();
+  }
+  /** No more writes: emits `ended`, closes the current file (`file-closed`), then emits `close`. */
+  end() {
+    if (this._ended) return;
+    this._ended = true;
+    this.emit("ended");
+    this._closeCurrent();
+    void this._closing.then(() => {
+      this.emit("finish");
+      this.emit("close");
+    });
+  }
+  _open() {
+    ++this._index;
+    this._openedAt = Date.now();
+    this._bytes = 0;
+    this._path = this._options.path({ index: this._index, openedAt: this._openedAt });
+    const stream = fs2.createWriteStream(this._path, { flags: "a" });
+    stream.on("drain", () => this.emit("drain"));
+    stream.on("error", (err) => this.emit("error", err));
+    this._stream = stream;
+  }
+  _closeCurrent() {
+    const stream = this._stream;
+    const path = this._path;
+    const index = this._index;
+    const closed = new Promise((resolve) => {
+      stream.once("close", () => resolve());
+      stream.once("error", () => resolve());
+    });
+    this._closing = Promise.all([this._closing, closed]).then(() => {
+      this.emit("file-closed", path, index);
+    });
+    stream.end();
+  }
+};
+
+// src/sinks/InMemorySink.ts
+import { EventEmitter as EventEmitter9 } from "events";
+var InMemorySink = class extends EventEmitter9 {
   id;
   samples;
   _ended = false;
@@ -8247,6 +8334,7 @@ export {
   RTT_HISTOGRAM_NUMBER_OF_BUCKETS,
   RemoteTrackResolver,
   RemoteTrackResolverValidator,
+  RollingJsonlFileSink,
   SCORE_HISTOGRAM_BUCKET_WIDTH,
   SCORE_HISTOGRAM_NUMBER_OF_BUCKETS,
   SfuCongestionDetector,