kuzzle 2.49.1 → 2.50.0-beta.4

package/dist/lib/core/statistics/statistics.js

@@ -0,0 +1,287 @@
+"use strict";
+/*
+ * Kuzzle, a backend software, self-hostable and ready to use
+ * to power modern apps
+ *
+ * Copyright 2015-2022 Kuzzle
+ * mailto: support AT kuzzle.io
+ * website: http://kuzzle.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const kerror = __importStar(require("../../kerror"));
+const errorApiAssert = kerror.wrap("api", "assert");
+const errorStats = kerror.wrap("services", "stats");
+/**
+ * @class Statistics
+ * @param {Kuzzle} kuzzle
+ */
+class Statistics {
+    constructor() {
+        // braces force all stats keys onto a single Redis slot in cluster mode
+        this.cacheKeyPrefix = "{stats/}";
+        this.enabled = global.kuzzle.config.stats.enabled;
+        this.ttl = global.kuzzle.config.stats.ttl * 1000;
+        this.interval = global.kuzzle.config.stats.statsInterval * 1000;
+        this.lastFrame = null;
+        this.timer = null;
+        this.currentStats = {
+            completedRequests: new Map(),
+            connections: new Map(),
+            failedRequests: new Map(),
+            ongoingRequests: new Map(),
+        };
+        this.logger = global.kuzzle.log.child("core:statistics");
+    }
+    /**
+     * Start recording a new request
+     *
+     * @param {Request} request
+     */
+    startRequest(request) {
+        if (!this.enabled) {
+            return;
+        }
+        const protocol = request?.context.connection.protocol;
+        if (!protocol) {
+            return;
+        }
+        const ongoing = this.currentStats.ongoingRequests;
+        ongoing.set(protocol, (ongoing.get(protocol) || 0) + 1);
+    }
+    /**
+     * Mark an ongoing request as 'completed'
+     *
+     * @param {Request} request
+     */
+    completedRequest(request) {
+        if (!this.enabled) {
+            return;
+        }
+        const protocol = request?.context.connection.protocol;
+        if (!protocol) {
+            return;
+        }
+        const ongoing = this.currentStats.ongoingRequests;
+        const currentOngoing = ongoing.get(protocol) || 0;
+        ongoing.set(protocol, currentOngoing - 1);
+        const completed = this.currentStats.completedRequests;
+        completed.set(protocol, (completed.get(protocol) || 0) + 1);
+    }
+    /**
+     * Mark an ongoing request as 'completed'
+     *
+     * @param {Request} request
+     */
+    failedRequest(request) {
+        if (!this.enabled) {
+            return;
+        }
+        const protocol = request?.context.connection.protocol;
+        if (!protocol) {
+            return;
+        }
+        const ongoing = this.currentStats.ongoingRequests;
+        const currentOngoing = ongoing.get(protocol) || 0;
+        ongoing.set(protocol, currentOngoing - 1);
+        const failed = this.currentStats.failedRequests;
+        failed.set(protocol, (failed.get(protocol) || 0) + 1);
+    }
+    /**
+     * Register a newly created connection
+     *
+     * @param {RequestContext} requestContext
+     */
+    newConnection(requestContext) {
+        if (!this.enabled) {
+            return;
+        }
+        const protocol = requestContext.connection.protocol;
+        if (!protocol) {
+            return;
+        }
+        const connections = this.currentStats.connections;
+        connections.set(protocol, (connections.get(protocol) || 0) + 1);
+    }
+    /**
+     * Removes a connection from the statistics
+     *
+     * @param {RequestContext} requestContext
+     */
+    dropConnection(requestContext) {
+        if (!this.enabled) {
+            return;
+        }
+        const protocol = requestContext.connection.protocol;
+        if (!protocol) {
+            return;
+        }
+        const connections = this.currentStats.connections;
+        const currentConnections = connections.get(protocol);
+        if (currentConnections === undefined) {
+            return;
+        }
+        if (currentConnections === 1) {
+            connections.delete(protocol);
+        }
+        else {
+            connections.set(protocol, currentConnections - 1);
+        }
+    }
+    /**
+     * Gets stored statistics frames from a date
+     *
+     * @returns {Promise}
+     */
+    async getLastStats() {
+        if (!this.enabled) {
+            throw errorStats.get("not_available");
+        }
+        const frame = Object.assign({ timestamp: Date.now() }, this.currentStats);
+        if (!this.lastFrame) {
+            return frame;
+        }
+        const last = await global.kuzzle.ask("core:cache:internal:get", this.cacheKeyPrefix + this.lastFrame);
+        return Object.assign(frame, JSON.parse(last));
+    }
+    /**
+     * Gets the last saved statistics frame from a date
+     *
+     * @param {Request} request
+     * @returns {Promise<Object>}
+     */
+    async getStats(request) {
+        if (!this.enabled) {
+            throw errorStats.get("not_available");
+        }
+        const response = {
+            hits: [],
+            total: 0,
+        };
+        const currentDate = Date.now();
+        let startTime;
+        let stopTime;
+        if (request?.input.args?.startTime) {
+            startTime = isNaN(request.input.args.startTime)
+                ? new Date(request.input.args.startTime).getTime()
+                : request.input.args.startTime;
+        }
+        if (request?.input.args?.stopTime) {
+            stopTime = isNaN(request.input.args.stopTime)
+                ? new Date(request.input.args.stopTime).getTime()
+                : request.input.args.stopTime;
+        }
+        if (startTime !== undefined && isNaN(startTime)) {
+            throw errorApiAssert.get("invalid_argument", "startTime", "number");
+        }
+        if (stopTime !== undefined && isNaN(stopTime)) {
+            throw errorApiAssert.get("invalid_argument", "stopTime", "number");
+        }
+        if (startTime !== undefined && startTime >= currentDate) {
+            response.total = response.hits.length;
+            return response;
+        }
+        const stats = {
+            completedRequests: Object.fromEntries(this.currentStats.completedRequests),
+            connections: Object.fromEntries(this.currentStats.connections),
+            failedRequests: Object.fromEntries(this.currentStats.failedRequests),
+            ongoingRequests: Object.fromEntries(this.currentStats.ongoingRequests),
+        };
+        if (!this.lastFrame) {
+            if (!stopTime || stopTime >= currentDate) {
+                response.hits.push(Object.assign({ timestamp: currentDate }, stats));
+            }
+            response.total = response.hits.length;
+            return response;
+        }
+        const frames = await global.kuzzle.ask("core:cache:internal:searchKeys", `${this.cacheKeyPrefix}*`);
+        const regex = new RegExp(`^${this.cacheKeyPrefix}`);
+        // Statistics keys are timestamp.
+        // Ordering them guarantees stats frames to be returned in the right order
+        const values = await global.kuzzle.ask("core:cache:internal:mget", frames.sort());
+        values.forEach((v, idx) => {
+            const frameDateTime = Number(frames[idx].replace(regex, ""));
+            if ((!startTime || startTime <= frameDateTime) &&
+                (!stopTime || stopTime >= frameDateTime)) {
+                response.hits.push(Object.assign(JSON.parse(v), {
+                    timestamp: frameDateTime,
+                }));
+            }
+        });
+        response.total = response.hits.length;
+        return response;
+    }
+    /**
+     * Gets all the saved statistics
+     *
+     * @returns {Promise<Object>}
+     */
+    getAllStats() {
+        return this.getStats();
+    }
+    /**
+     * Init statistics component
+     */
+    init() {
+        if (!this.enabled) {
+            return;
+        }
+        this.timer = setInterval(async () => {
+            try {
+                await this.writeStats();
+            }
+            catch (error) {
+                this.logger.error(`Cannot write stats frame: ${error}`);
+            }
+        }, this.interval);
+        global.kuzzle.on("core:cache:internal:flushdb", () => {
+            this.lastFrame = null;
+        });
+    }
+    async writeStats() {
+        if (!this.enabled) {
+            return;
+        }
+        const stats = JSON.stringify(this.currentStats);
+        this.lastFrame = Date.now();
+        this.currentStats.completedRequests = new Map();
+        this.currentStats.failedRequests = new Map();
+        await global.kuzzle.ask("core:cache:internal:store", this.cacheKeyPrefix + this.lastFrame, stats, { ttl: this.ttl });
+    }
+}
+exports.default = Statistics;
+//# sourceMappingURL=statistics.js.map

package/dist/lib/core/storage/clientAdapter.d.ts

@@ -0,0 +1,62 @@
+export = ClientAdapter;
+/**
+ * Storage client adapter to perform validation on index/collection existence
+ * and to maintain the index/collection cache.
+ */
+declare class ClientAdapter {
+    /**
+     * @param {storeScopeEnum} scope
+     */
+    constructor(scope: storeScopeEnum);
+    es: Elasticsearch;
+    client: any;
+    scope: storeScopeEnum;
+    cache: IndexCache;
+    init(): Promise<void>;
+    createIndex(index: any, { indexCacheOnly, propagate }?: {
+        indexCacheOnly?: boolean;
+        propagate?: boolean;
+    }): Promise<void>;
+    createCollection(index: any, collection: any, opts: any, { indexCacheOnly, propagate }?: {
+        indexCacheOnly?: boolean;
+        propagate?: boolean;
+    }): Promise<void>;
+    deleteIndex(index: any): Promise<void>;
+    deleteIndexes(indexes: any): Promise<any>;
+    deleteCollection(index: any, collection: any): Promise<void>;
+    /**
+     * Populates the index cache with existing index/collection.
+     * Also checks for duplicated index names.
+     */
+    populateCache(): Promise<void>;
+    registerCollectionEvents(): void;
+    registerIndexEvents(): void;
+    registerDocumentEvents(): void;
+    registerMappingEvents(): void;
+    /**
+     * Cache update operations. These events trigger neither any actual change
+     * in the storage layer, nor kuzzle events.
+     */
+    registerCacheEvents(): void;
+    /**
+     * Load database fixtures into Kuzzle
+     *
+     * @param {String} fixturesId
+     * @returns {Promise}
+     */
+    loadFixtures(fixtures?: {}, { refresh }?: {
+        refresh?: string;
+    }): Promise<any>;
+    /**
+     * Load database mappings into Kuzzle
+     *
+     * @param {String} mappings
+     * @param {String} options rawMappings (false)
+     * - propagate (true): notify the other nodes of the cluster
+     * - indexCacheOnly (false): only update the cache, don't update the database
+     * @returns {Promise}
+     */
+    loadMappings(fixtures?: {}, options?: string): Promise<any>;
+}
+import { Elasticsearch } from "../../service/storage/Elasticsearch";
+import { IndexCache } from "./indexCache";