typeahead-client-logger 0.0.1-security → 2.532.1

package/dist/PerformanceMetrics.js

@@ -0,0 +1,212 @@
+"use strict";
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerformanceMetrics = void 0;
+var PerformanceMetrics = /** @class */ (function () {
+    function PerformanceMetrics() {
+        this.entries = [];
+        this.MAX_TRIGGER_COUNT_FOR_AGGREGATED_LOGGING = 10;
+        this.essErrorCount = 0;
+        this.TRIGGER_TYPE_FOCUS = "focus";
+        this.TRIGGER_TYPE_INPUT = "input";
+        this.errorCodes = [];
+        this.proxyRegion = "";
+    }
+    PerformanceMetrics.isStatusCodeInRange = function (statusCode, begin, end) {
+        if (isNaN(statusCode)) {
+            return false;
+        }
+        return begin <= statusCode && statusCode <= end;
+    };
+    PerformanceMetrics.prototype.logTypeaheadRequest = function (query) {
+        var triggerType = query.trim().length === 0 ? this.TRIGGER_TYPE_FOCUS : this.TRIGGER_TYPE_INPUT;
+        var request = {
+            query: query,
+            timestamp: Date.now(),
+            triggerType: triggerType,
+        };
+        this.entries.push({
+            request: request,
+            responseShown: false,
+        });
+    };
+    PerformanceMetrics.prototype.logResponse = function (response) {
+        var _a;
+        this.proxyRegion = ((_a = response === null || response === void 0 ? void 0 : response.headers) === null || _a === void 0 ? void 0 : _a.get("x-proxy-region")) || "";
+    };
+    PerformanceMetrics.prototype.logTypeaheadResponse = function (response) {
+        if (response) {
+            var query = response.q;
+            var suggestionCount = response.sr ? response.sr.length : 0;
+            var entry = this.getRequestMetricEntry(query);
+            if (entry) {
+                var responseTimestamp = Date.now();
+                entry.response = {
+                    latency: (responseTimestamp - entry.request.timestamp),
+                    query: query,
+                    suggestionCount: suggestionCount,
+                    timestamp: responseTimestamp,
+                };
+            }
+        }
+    };
+    PerformanceMetrics.prototype.logSuggestionShown = function (query) {
+        var entry = this.getResponseMetricEntry(query);
+        if (entry) {
+            entry.responseShown = true;
+        }
+    };
+    PerformanceMetrics.prototype.logError = function (statusCode, statusText) {
+        if (!PerformanceMetrics.isStatusCodeInRange(statusCode, 200, 299)) {
+            this.essErrorCount++;
+        }
+        this.errorCodes.push(statusCode);
+    };
+    PerformanceMetrics.prototype.getMetrics = function () {
+        var _a;
+        if (this.entries.length) {
+            var metric = {};
+            var entryCount = this.MAX_TRIGGER_COUNT_FOR_AGGREGATED_LOGGING < this.entries.length ?
+                this.MAX_TRIGGER_COUNT_FOR_AGGREGATED_LOGGING : this.entries.length;
+            for (var i = 0; i < entryCount; i++) {
+                var entry = this.entries[i];
+                if (entry.response) {
+                    // @ts-ignore
+                    metric["latency" + i] = entry.response.latency;
+                    if (i === 0) {
+                        metric.query0 = entry.response.query;
+                    }
+                }
+            }
+            metric.latencyMedian = this.getMedianLatency();
+            var worstLatencyMetric = this.getWorstLatencyMetric();
+            metric.queryWorst = worstLatencyMetric ?
+                (worstLatencyMetric.response && worstLatencyMetric.response.query) : undefined;
+            metric.latencyWorst = worstLatencyMetric ?
+                (worstLatencyMetric.response && worstLatencyMetric.response.latency) : undefined;
+            var last = this.entries[this.entries.length - 1];
+            metric.queryLast = last.request.query;
+            metric.latencyLast = last.response ? last.response.latency : undefined;
+            metric.totalTriggers = this.entries.length;
+            metric.totalSuccess = this.getSuccessMetrics().length;
+            metric.totalOnePlusCharTypeaheadShown =
+                this.entries.filter(function (entry) { return entry.request.query && entry.responseShown; }).length;
+            metric.onFocusTypeaheadShown = ((_a = this.getResponseMetricEntry("")) === null || _a === void 0 ? void 0 : _a.responseShown) || false;
+            if (this.essErrorCount > 0) {
+                metric.essErrorCount = this.essErrorCount;
+            }
+            if (this.errorCodes.length > 0) {
+                metric.error = this.errorCodes.join(",");
+            }
+            metric.proxyRegion = this.proxyRegion;
+            return metric;
+        }
+        return undefined;
+    };
+    PerformanceMetrics.prototype.getRequestMetricEntry = function (query) {
+        var e_1, _a;
+        try {
+            for (var _b = __values(this.entries), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var entry = _c.value;
+                if (entry.request.query === query && !entry.response) {
+                    return entry;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return undefined;
+    };
+    PerformanceMetrics.prototype.getResponseMetricEntry = function (query) {
+        var e_2, _a;
+        try {
+            for (var _b = __values(this.entries), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var entry = _c.value;
+                if (entry.request.query === query && entry.response) {
+                    return entry;
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return undefined;
+    };
+    PerformanceMetrics.prototype.getWorstLatencyMetric = function () {
+        var e_3, _a;
+        var worstLatencyMetric;
+        try {
+            for (var _b = __values(this.entries), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var entry = _c.value;
+                if (entry.response) {
+                    if (!worstLatencyMetric ||
+                        (worstLatencyMetric.response && worstLatencyMetric.response.latency < entry.response.latency)) {
+                        worstLatencyMetric = entry;
+                    }
+                }
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        return worstLatencyMetric;
+    };
+    PerformanceMetrics.prototype.latencySortFunction = function (a, b) {
+        if (a.response && b.response) {
+            return a.response.latency - b.response.latency;
+        }
+        else {
+            return a.response ? -1 : (b.response ? 1 : 0);
+        }
+    };
+    PerformanceMetrics.prototype.getMedianLatency = function () {
+        var medianLatency;
+        var successMetrics = this.getSuccessMetrics();
+        successMetrics.sort(this.latencySortFunction);
+        if (successMetrics.length) {
+            var mid = Math.floor(successMetrics.length / 2);
+            // @ts-ignore
+            var midLatency = successMetrics[mid].response.latency;
+            if (successMetrics.length % 2) {
+                medianLatency = midLatency;
+            }
+            else {
+                // @ts-ignore
+                var midMinusOneLatency = successMetrics[mid - 1].response.latency;
+                medianLatency = (midMinusOneLatency + midLatency) / 2;
+            }
+        }
+        return medianLatency;
+    };
+    PerformanceMetrics.prototype.getSuccessMetrics = function () {
+        return this.entries.filter(function (entry) {
+            return entry.response;
+        });
+    };
+    return PerformanceMetrics;
+}());
+exports.PerformanceMetrics = PerformanceMetrics;
+//# sourceMappingURL=PerformanceMetrics.js.map

package/dist/RecommendationEvent.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecommendationEvent = void 0;
+var EventName;
+(function (EventName) {
+    EventName["CLICK"] = "recommendation_module.selected";
+    EventName["SEEN"] = "recommendation_module.presented";
+})(EventName || (EventName = {}));
+var EventType;
+(function (EventType) {
+    EventType["SEEN"] = "Impression";
+    EventType["CLICK"] = "Interaction";
+})(EventType || (EventType = {}));
+var COMPONENT = "destination-typeahead-input";
+var SCHEMA_NAME = "allRecommendations";
+var RECOMMENDATION_TITLE_DEFAULT = {
+    "ALTERNATE": "People also searched",
+    "POPULAR": "Popular destinations"
+};
+var RECOMMENDATION_CATEGORIES = ["POPULAR", "ALTERNATE"];
+var RecommendationEvent = /** @class */ (function () {
+    function RecommendationEvent() {
+    }
+    RecommendationEvent.getRecommendationSeenMessage = function (response, elementName) {
+        if (response && response.sr && response.sr.length > 0) {
+            var recommendedSuggestions = response.sr.filter(function (sr) {
+                return RECOMMENDATION_CATEGORIES.includes(sr.category);
+            });
+            if (recommendedSuggestions && recommendedSuggestions.length > 0) {
+                var recommendationEvent = {
+                    eventType: EventType.SEEN,
+                    eventName: EventName.SEEN,
+                    egRecommendationResponseId: this.getEgRecommendationResponseId(response.recId),
+                    recommendationTitle: this.getRecommendationTitle(recommendedSuggestions[0].category),
+                    component: COMPONENT,
+                    componentElement: elementName,
+                    recommendations: this.getRecommendations(recommendedSuggestions)
+                };
+                return {
+                    schemaName: SCHEMA_NAME,
+                    messageContent: recommendationEvent
+                };
+            }
+        }
+        return undefined;
+    };
+    RecommendationEvent.getRecommendationClickedMessage = function (selected, response, elementName) {
+        var _a, _b;
+        if (selected && RECOMMENDATION_CATEGORIES.includes(selected.category)) {
+            var rank = selected.index;
+            if (response && response.sr && response.sr.length > 0) {
+                var recommendations = response.sr.filter(function (sr) { return sr.category === selected.category; });
+                for (var i = 0; i < recommendations.length; i++) {
+                    if (((_a = recommendations[i].essId) === null || _a === void 0 ? void 0 : _a.sourceId) === ((_b = selected.essId) === null || _b === void 0 ? void 0 : _b.sourceId)) {
+                        rank = i;
+                        break;
+                    }
+                }
+            }
+            var recommendationEvent = {
+                eventType: EventType.CLICK,
+                eventName: EventName.CLICK,
+                egRecommendationResponseId: this.getEgRecommendationResponseId(),
+                recommendationTitle: this.getRecommendationTitle(selected.category),
+                component: COMPONENT,
+                componentElement: elementName,
+                recommendations: this.getSelectedRecommendations(selected, rank)
+            };
+            return {
+                schemaName: SCHEMA_NAME,
+                messageContent: recommendationEvent
+            };
+        }
+        return undefined;
+    };
+    RecommendationEvent.getEgRecommendationResponseId = function (responseId) {
+        if (responseId) {
+            this.egRecommendationResponseId = responseId;
+        }
+        return this.egRecommendationResponseId;
+    };
+    RecommendationEvent.getRecommendationTitle = function (recommendationType) {
+        if (!this.recommendationTitle) {
+            this.recommendationTitle =
+                RECOMMENDATION_TITLE_DEFAULT[recommendationType];
+        }
+        return this.recommendationTitle;
+    };
+    RecommendationEvent.getRecommendations = function (results) {
+        var _this = this;
+        var recommendations = [];
+        var trueIndex = 0;
+        if (results && results.length > 0) {
+            results.forEach(function (resultItem) {
+                recommendations.push(_this.getRecommendation(resultItem, trueIndex));
+                trueIndex++;
+            });
+            recommendations.push();
+        }
+        return recommendations;
+    };
+    RecommendationEvent.getSelectedRecommendations = function (result, rank) {
+        var recommendations = [];
+        if (result) {
+            recommendations.push(this.getRecommendation(result, rank));
+        }
+        return recommendations;
+    };
+    RecommendationEvent.getRecommendation = function (resultItem, rank) {
+        var _a;
+        return {
+            recommendationId: (_a = resultItem.essId) === null || _a === void 0 ? void 0 : _a.sourceId,
+            rank: rank,
+            presentationDetails: {
+                name: resultItem.regionNames.primaryDisplayName
+            }
+        };
+    };
+    return RecommendationEvent;
+}());
+exports.RecommendationEvent = RecommendationEvent;
+//# sourceMappingURL=RecommendationEvent.js.map

package/dist/SystemEvent.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemEvent = exports.SystemEventLevel = void 0;
+var SystemEventLevel;
+(function (SystemEventLevel) {
+    SystemEventLevel["CRITICAL"] = "CRITICAL";
+    SystemEventLevel["ERROR"] = "ERROR";
+    SystemEventLevel["WARN"] = "WARN";
+    SystemEventLevel["INFO"] = "INFO";
+    SystemEventLevel["UNKNOWN"] = "UNKNOWN";
+})(SystemEventLevel = exports.SystemEventLevel || (exports.SystemEventLevel = {}));
+var SystemEvent = /** @class */ (function () {
+    /**
+     * Construct a new SystemEvent. This is a container for data marking a specific
+     * event in your app. Ideally the name follows the enum pattern - all uppercase,
+     * spaces replaced with underscores i.e. 'FETCH_ERROR'
+     */
+    function SystemEvent(level, name) {
+        this.level = level;
+        this.name = name;
+    }
+    /**
+     * Get a string value of this event safe for Splunk.
+     */
+    SystemEvent.prototype.toString = function () {
+        return "SystemEvent(level=" + this.level.toString() + " name=" + this.name + ")";
+    };
+    return SystemEvent;
+}());
+exports.SystemEvent = SystemEvent;
+//# sourceMappingURL=SystemEvent.js.map