@opentap/runner-client 2.25.0-alpha.1.1.11217168217 → 2.25.0

package/dist/cjs/BaseClient.js

@@ -48,8 +48,8 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseClient = void 0;
-var DTOs_1 = require("./DTOs");
 var nats_ws_1 = require("nats.ws");
+var DTOs_1 = require("./DTOs");
 var events_1 = require("events");
 var uuid_1 = require("uuid");
 var DEFAULT_TIMEOUT = 40000; // default timeout of 40 seconds
@@ -278,21 +278,22 @@ var BaseClient = /** @class */ (function () {
     /**
      * Subscribes to given subject.
      * @param subject The subject to subscribe
-     * @param options Subscription options
+     * @param jetStreamOptions Subscription options
      * @returns Subscription object
      */
-    BaseClient.prototype.createJetStreamConsumer = function (stream, subject, options) {
+    BaseClient.prototype.createJetStreamConsumer = function (stream, subject, jetStreamOptions, consumerOptions) {
         var _this = this;
+        if (jetStreamOptions === void 0) { jetStreamOptions = {}; }
+        if (consumerOptions === void 0) { consumerOptions = {}; }
         if (!this.connection) {
             throw Error('Connection is not established');
         }
-        return this.connection.jetstreamManager(__assign({}, options)).then(function (jetStreamManager) {
+        return this.connection.jetstreamManager(__assign({}, jetStreamOptions)).then(function (jetStreamManager) {
             return jetStreamManager.consumers
-                .add(stream, {
-                filter_subject: subject,
-                ack_policy: nats_ws_1.AckPolicy.None,
-            })
-                .then(function (consumerInfo) { return _this.connection.jetstream(options).consumers.get(consumerInfo.stream_name, consumerInfo.name); });
+                .add(stream, __assign(__assign({}, consumerOptions), { filter_subject: subject, ack_policy: nats_ws_1.AckPolicy.None }))
+                .then(function (consumerInfo) {
+                return _this.connection.jetstream(jetStreamOptions).consumers.get(consumerInfo.stream_name, consumerInfo.name);
+            });
         });
     };
     BaseClient.prototype.encode = function (payload) {

package/dist/cjs/SessionClient.js

@@ -61,6 +61,13 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SessionClient = void 0;
 var DTOs_1 = require("./DTOs");
@@ -340,18 +347,90 @@ var SessionClient = /** @class */ (function (_super) {
      * @param  {SubscriptionOptions} options?
      * @returns Subscription
      */
-    SessionClient.prototype.connectMetric = function (metricInfo, handler) {
+    SessionClient.prototype.connectMetric = function (metricInfo, inactiveThresholdMilliseconds, maxBatchSize, handler) {
+        var _this = this;
         return this.createJetStreamConsumer('Metrics', "M.".concat(metricInfo.subjectPostfix), {
             domain: this.runnerId,
-        }).then(function (consumer) {
-            consumer.consume({
-                callback: function (encodedMessage) {
-                    var _this = this;
-                    (function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
-                        return [2 /*return*/, handler(encodedMessage, metricInfo.type)];
-                    }); }); })();
-                },
-            });
+        }, { inactive_threshold: (0, nats_ws_1.nanos)(inactiveThresholdMilliseconds) }).then(function (consumer) {
+            // Async function here so the loop starts without blocking returning a consumer
+            (function () { return __awaiter(_this, void 0, void 0, function () {
+                var _loop_1;
+                var _this = this;
+                var e_1, _a;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            _loop_1 = function () {
+                                var consumerInfo, arraySize, metricData, messages, index, messages_1, messages_1_1, message, e_1_1;
+                                return __generator(this, function (_c) {
+                                    switch (_c.label) {
+                                        case 0: return [4 /*yield*/, consumer.info()];
+                                        case 1:
+                                            consumerInfo = _c.sent();
+                                            arraySize = Math.min(maxBatchSize, consumerInfo.num_pending);
+                                            metricData = {
+                                                encodedMetrics: new Array(arraySize),
+                                                timestamps: new Array(arraySize),
+                                            };
+                                            return [4 /*yield*/, consumer.fetch({ max_messages: arraySize })];
+                                        case 2:
+                                            messages = _c.sent();
+                                            index = 0;
+                                            _c.label = 3;
+                                        case 3:
+                                            _c.trys.push([3, 8, 9, 14]);
+                                            messages_1 = (e_1 = void 0, __asyncValues(messages));
+                                            _c.label = 4;
+                                        case 4: return [4 /*yield*/, messages_1.next()];
+                                        case 5:
+                                            if (!(messages_1_1 = _c.sent(), !messages_1_1.done)) return [3 /*break*/, 7];
+                                            message = messages_1_1.value;
+                                            // Store the message data and timestamp
+                                            metricData.encodedMetrics[index] = message.data;
+                                            metricData.timestamps[index] = message.info.timestampNanos;
+                                            // If we are at the last message or there are no more pending messages, call the handler
+                                            if (index === arraySize - 1 || message.info.pending === 0) {
+                                                (function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                                                    return [2 /*return*/, handler(metricData)];
+                                                }); }); })();
+                                                return [3 /*break*/, 7];
+                                            }
+                                            // Increment the index
+                                            index++;
+                                            _c.label = 6;
+                                        case 6: return [3 /*break*/, 4];
+                                        case 7: return [3 /*break*/, 14];
+                                        case 8:
+                                            e_1_1 = _c.sent();
+                                            e_1 = { error: e_1_1 };
+                                            return [3 /*break*/, 14];
+                                        case 9:
+                                            _c.trys.push([9, , 12, 13]);
+                                            if (!(messages_1_1 && !messages_1_1.done && (_a = messages_1.return))) return [3 /*break*/, 11];
+                                            return [4 /*yield*/, _a.call(messages_1)];
+                                        case 10:
+                                            _c.sent();
+                                            _c.label = 11;
+                                        case 11: return [3 /*break*/, 13];
+                                        case 12:
+                                            if (e_1) throw e_1.error;
+                                            return [7 /*endfinally*/];
+                                        case 13: return [7 /*endfinally*/];
+                                        case 14: return [2 /*return*/];
+                                    }
+                                });
+                            };
+                            _b.label = 1;
+                        case 1:
+                            if (!true) return [3 /*break*/, 3];
+                            return [5 /*yield**/, _loop_1()];
+                        case 2:
+                            _b.sent();
+                            return [3 /*break*/, 1];
+                        case 3: return [2 /*return*/];
+                    }
+                });
+            }); })();
             return consumer;
         });
     };

package/dist/mjs/BaseClient.d.ts

@@ -1,6 +1,6 @@
+import { ConnectionOptions, Consumer, ConsumerConfig, JetStreamOptions, NatsError, PublishOptions, Subscription, SubscriptionOptions } from 'nats.ws';
 import { DownloadTapSettingsRequest } from './requestDTOs';
 import { ComponentSettingsBase, ComponentSettingsIdentifier, ComponentSettingsListItem, DataGridControl, ErrorResponse, FileParameter, ListItemType, ProfileGroup, RepositoryPackageReference, RepositorySettingsPackageDefinition } from './DTOs';
-import { ConnectionOptions, NatsError, Subscription, SubscriptionOptions, PublishOptions, JetStreamOptions, Consumer } from 'nats.ws';
 interface BaseClientRequestOptions {
     publishOptions?: PublishOptions;
     rawResponse?: boolean;
@@ -64,10 +64,10 @@ export declare class BaseClient {
     /**
      * Subscribes to given subject.
      * @param subject The subject to subscribe
-     * @param options Subscription options
+     * @param jetStreamOptions Subscription options
      * @returns Subscription object
      */
-    protected createJetStreamConsumer(stream: string, subject: string, options: JetStreamOptions): Promise<Consumer>;
+    protected createJetStreamConsumer(stream: string, subject: string, jetStreamOptions?: Partial<JetStreamOptions>, consumerOptions?: Partial<ConsumerConfig>): Promise<Consumer>;
     protected encode(payload: any): Uint8Array;
     /**
      * Create a connection to the nats server.

package/dist/mjs/BaseClient.js

@@ -7,8 +7,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+import { AckPolicy, Empty, ErrorCode, JSONCodec, StringCodec, connect, headers, } from 'nats.ws';
 import { ComponentSettingsBase, ComponentSettingsIdentifier, ComponentSettingsListItem, DataGridControl, ErrorResponse, FileDescriptor, ListItemType, ProfileGroup, } from './DTOs';
-import { Empty, ErrorCode, JSONCodec, StringCodec, connect, headers, AckPolicy, } from 'nats.ws';
 import { EventEmitter } from 'events';
 import { v4 as uuidv4 } from 'uuid';
 const DEFAULT_TIMEOUT = 40000; // default timeout of 40 seconds
@@ -232,19 +232,16 @@ export class BaseClient {
     /**
      * Subscribes to given subject.
      * @param subject The subject to subscribe
-     * @param options Subscription options
+     * @param jetStreamOptions Subscription options
      * @returns Subscription object
      */
-    createJetStreamConsumer(stream, subject, options) {
+    createJetStreamConsumer(stream, subject, jetStreamOptions = {}, consumerOptions = {}) {
         if (!this.connection) {
             throw Error('Connection is not established');
         }
-        return this.connection.jetstreamManager(Object.assign({}, options)).then(jetStreamManager => jetStreamManager.consumers
-            .add(stream, {
-            filter_subject: subject,
-            ack_policy: AckPolicy.None,
-        })
-            .then(consumerInfo => this.connection.jetstream(options).consumers.get(consumerInfo.stream_name, consumerInfo.name)));
+        return this.connection.jetstreamManager(Object.assign({}, jetStreamOptions)).then(jetStreamManager => jetStreamManager.consumers
+            .add(stream, Object.assign(Object.assign({}, consumerOptions), { filter_subject: subject, ack_policy: AckPolicy.None }))
+            .then(consumerInfo => this.connection.jetstream(jetStreamOptions).consumers.get(consumerInfo.stream_name, consumerInfo.name)));
     }
     encode(payload) {
         if (!payload) {

package/dist/mjs/SessionClient.d.ts

@@ -1,5 +1,5 @@
-import { BreakPoints, CommonContext, CommonSettings, DataGridControl, IMetricsConfiguration, ISessionMetricInfo, Image, Interaction, ListItemType, LogList, MetricsConfiguration, OnTestPlanRun, OnTestStepRun, Parameter, RepositoryPackageDefinition, RepositoryPackageReference, Resource, Result, RunStatus, SessionEvent, SessionMetricType, Setting, TestPlan, TestRun, TestStepType, TestStepValidationError, WatchDog } from './DTOs';
-import { ConnectionOptions, Consumer, JsMsg, NatsError, Subscription, SubscriptionOptions } from 'nats.ws';
+import { BreakPoints, CommonContext, CommonSettings, DataGridControl, IMetricsConfiguration, ISessionMetricInfo, Image, Interaction, ListItemType, LogList, MetricsConfiguration, OnTestPlanRun, OnTestStepRun, Parameter, RepositoryPackageDefinition, RepositoryPackageReference, Resource, Result, RunStatus, SessionEvent, Setting, TestPlan, TestRun, TestStepType, TestStepValidationError, WatchDog } from './DTOs';
+import { ConnectionOptions, Consumer, NatsError, Subscription, SubscriptionOptions } from 'nats.ws';
 import { BaseClient } from './BaseClient';
 export declare class SessionClient extends BaseClient {
     private subscriptions;
@@ -89,7 +89,10 @@ export declare class SessionClient extends BaseClient {
      * @param  {SubscriptionOptions} options?
      * @returns Subscription
      */
-    connectMetric(metricInfo: ISessionMetricInfo, handler: (result: JsMsg | undefined, type: SessionMetricType) => void): Promise<Consumer>;
+    connectMetric(metricInfo: ISessionMetricInfo, inactiveThresholdMilliseconds: number, maxBatchSize: number, handler: (metricData: {
+        encodedMetrics: Uint8Array[];
+        timestamps: number[];
+    }) => void): Promise<Consumer>;
     /**
      * Unsubscibe from session events
      */

package/dist/mjs/SessionClient.js

@@ -7,8 +7,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
 import { BreakPoints, CommonContext, CommonSettings, DataGridControl, Image, Interaction, ListItemType, LogList, MetricsConfiguration, OnTestPlanRun, OnTestStepRun, Parameter, Result, RunStatus, SessionEvent, Setting, TestPlan, TestRun, TestStepType, TestStepValidationError, WatchDog, } from './DTOs';
-import { JSONCodec } from 'nats.ws';
+import { JSONCodec, nanos } from 'nats.ws';
 import { BaseClient } from './BaseClient';
 import { getSubjectParts } from './utils';
 export class SessionClient extends BaseClient {
@@ -282,15 +289,52 @@ export class SessionClient extends BaseClient {
      * @param  {SubscriptionOptions} options?
      * @returns Subscription
      */
-    connectMetric(metricInfo, handler) {
+    connectMetric(metricInfo, inactiveThresholdMilliseconds, maxBatchSize, handler) {
         return this.createJetStreamConsumer('Metrics', `M.${metricInfo.subjectPostfix}`, {
             domain: this.runnerId,
-        }).then(consumer => {
-            consumer.consume({
-                callback(encodedMessage) {
-                    (() => __awaiter(this, void 0, void 0, function* () { return handler(encodedMessage, metricInfo.type); }))();
-                },
-            });
+        }, { inactive_threshold: nanos(inactiveThresholdMilliseconds) }).then(consumer => {
+            // Async function here so the loop starts without blocking returning a consumer
+            (() => __awaiter(this, void 0, void 0, function* () {
+                var e_1, _a;
+                // eslint-disable-next-line no-constant-condition
+                while (true) {
+                    // Get the consumer info to determine the number of pending messages
+                    const consumerInfo = yield consumer.info();
+                    // We want to define the batch size based on how many message we will consume in the next fetch
+                    const arraySize = Math.min(maxBatchSize, consumerInfo.num_pending);
+                    // Create the object with preallocated arrays for better performance
+                    const metricData = {
+                        encodedMetrics: new Array(arraySize),
+                        timestamps: new Array(arraySize),
+                    };
+                    // Fetch the messages
+                    const messages = yield consumer.fetch({ max_messages: arraySize });
+                    // for await of doesn't return the index, so we need to keep track of it
+                    let index = 0;
+                    try {
+                        for (var messages_1 = (e_1 = void 0, __asyncValues(messages)), messages_1_1; messages_1_1 = yield messages_1.next(), !messages_1_1.done;) {
+                            const message = messages_1_1.value;
+                            // Store the message data and timestamp
+                            metricData.encodedMetrics[index] = message.data;
+                            metricData.timestamps[index] = message.info.timestampNanos;
+                            // If we are at the last message or there are no more pending messages, call the handler
+                            if (index === arraySize - 1 || message.info.pending === 0) {
+                                (() => __awaiter(this, void 0, void 0, function* () { return handler(metricData); }))();
+                                break;
+                            }
+                            // Increment the index
+                            index++;
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (messages_1_1 && !messages_1_1.done && (_a = messages_1.return)) yield _a.call(messages_1);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                }
+            }))();
             return consumer;
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opentap/runner-client",
-  "version": "2.25.0-alpha.1.1.11217168217",
+  "version": "2.25.0",
   "description": "This is the web client for the OpenTAP Runner.",
   "main": "./dist/cjs/index.js",
   "module": "./dist/mjs/index.js",