@autofleet/matmon 2.0.4-beta-3 → 2.0.4

package/lib/cache.js

@@ -37,7 +37,7 @@ const locking = __importStar(require("./locking"));
 const dotenv_1 = __importDefault(require("dotenv"));
 dotenv_1.default.config();
 const DEFAULT_CACHE_SIZE = 300;
-const MAX_SIZE = 1000;
+const MAX_SIZE = 100000;
 const MUTEX_MAP = {};
 const getOptions = ({ lifeTimeInSec, size = DEFAULT_CACHE_SIZE, }) => ({
     max: Math.min(size, MAX_SIZE),

package/lib/orm-cache/sequelize-adapter.js

@@ -12,15 +12,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const newrelic_1 = __importDefault(require("newrelic"));
 const logger_1 = __importDefault(require("../logger"));
 const util_1 = require("util");
 const { AF_SERVICE_NAME } = process.env;
 const ORM_CACHE_PREFIX = 'ormCache';
-const INVALIDATION_HOOKS = ['afterUpdate', 'afterDestroy'];
+const INVALIDATION_HOOKS = ['afterSave', 'afterUpdate', 'afterDestroy'];
+const BULK_HOOKS = ['beforeBulkUpdate', 'beforeBulkDestroy'];
 const generateInstanceKey = (name, id) => `${AF_SERVICE_NAME}:${ORM_CACHE_PREFIX}:${name}_${id}`;
 const generateDependencyKey = (modelName, associationName, associationId) => `${AF_SERVICE_NAME}:${ORM_CACHE_PREFIX}:${modelName}_${associationName}_${associationId}_DEPENDENCIES`;
-const getInstanceDependencyKeys = (modelOptions, instance) => newrelic_1.default.startSegment(`${ORM_CACHE_PREFIX}:getInstanceDependencyKeys`, true, () => {
+const getInstanceDependencyKeys = (modelOptions, instance) => {
     const keys = modelOptions.associations
         .filter((associationOptions) => instance[associationOptions.alias])
         .map((associationOptions) => {
@@ -41,17 +41,11 @@ const getInstanceDependencyKeys = (modelOptions, instance) => newrelic_1.default
         ];
     });
     return keys.reduce((flattenArray, array) => flattenArray.concat(array), []);
-});
+};
 const handleTransactionHook = (instance, options, func) => {
     const { transaction } = options;
     if (transaction) {
-        if (!transaction[ORM_CACHE_PREFIX]) {
-            transaction[ORM_CACHE_PREFIX] = new Set();
-        }
-        if (!transaction[ORM_CACHE_PREFIX].has(instance.id)) {
-            transaction.afterCommit(() => func(instance));
-            transaction[ORM_CACHE_PREFIX].add(instance.id);
-        }
+        transaction.afterCommit(() => func(instance));
     }
     else {
         func(instance);
@@ -66,28 +60,26 @@ class SequelizeAdapter {
         return this.ormInstance.models[modelName];
     }
     getModelDependencies(modelName) {
-        return newrelic_1.default.startSegment(`${ORM_CACHE_PREFIX}:getModelDependencies`, true, () => {
-            const { associations } = this.ormInstance.models[modelName];
-            return [
-                ...Object.keys(associations).map(association => {
-                    const sequelizeAssociation = associations[association];
-                    const associationOptions = {
-                        alias: sequelizeAssociation.as,
-                        name: sequelizeAssociation.target.name,
-                        accessKey: sequelizeAssociation.target.primaryKeyAttribute,
+        const { associations } = this.ormInstance.models[modelName];
+        return [
+            ...Object.keys(associations).map(association => {
+                const sequelizeAssociation = associations[association];
+                const associationOptions = {
+                    alias: sequelizeAssociation.as,
+                    name: sequelizeAssociation.target.name,
+                    accessKey: sequelizeAssociation.target.primaryKeyAttribute,
+                };
+                if (sequelizeAssociation.through) {
+                    const relationModel = sequelizeAssociation.through.model;
+                    associationOptions.innerAssociation = {
+                        alias: relationModel.name,
+                        name: relationModel.name,
+                        accessKey: relationModel.primaryKeyAttribute,
                     };
-                    if (sequelizeAssociation.through) {
-                        const relationModel = sequelizeAssociation.through.model;
-                        associationOptions.innerAssociation = {
-                            alias: relationModel.name,
-                            name: relationModel.name,
-                            accessKey: relationModel.primaryKeyAttribute,
-                        };
-                    }
-                    return associationOptions;
-                }),
-            ];
-        });
+                }
+                return associationOptions;
+            }),
+        ];
     }
     debug(message, payload) {
         if (this.debugMode) {
@@ -95,7 +87,7 @@ class SequelizeAdapter {
         }
     }
     injectGetWithCacheFunction(cache, modelOptions) {
-        const addDependencies = (instance) => newrelic_1.default.startSegment(`${ORM_CACHE_PREFIX}:addDependencies`, true, () => {
+        const addDependencies = (instance) => __awaiter(this, void 0, void 0, function* () {
             const dependencyKeys = getInstanceDependencyKeys(modelOptions, instance);
             const instanceKey = generateInstanceKey(modelOptions.name, instance.id);
             this.debug('Adding dependencies', { instanceKey, dependencyKeys });
@@ -125,19 +117,19 @@ class SequelizeAdapter {
         });
     }
     addInvalidationHooks(cache, modelOptions) {
-        const invalidateModelInstance = (hook, instance) => newrelic_1.default.startSegment(`${ORM_CACHE_PREFIX}:invalidateModelInstance`, true, () => {
+        const invalidateModelInstance = (instance) => __awaiter(this, void 0, void 0, function* () {
             const dependencyKeys = getInstanceDependencyKeys(modelOptions, instance);
             const instanceKey = generateInstanceKey(modelOptions.name, instance.id);
-            this.debug(`Removing dependencies (triggered by ${hook})`, { instance, instanceKey, dependencyKeys });
+            this.debug('Removing dependencies', { instance, instanceKey, dependencyKeys });
             const removeMulti = cache.getClient().multi();
             const removeMultiAsync = util_1.promisify(removeMulti.exec).bind(removeMulti);
             dependencyKeys.map(key => removeMulti.srem(key, instanceKey));
             removeMulti.del(instanceKey);
             return removeMultiAsync();
         });
-        const invalidateModelInstanceByAssociation = (hook, association, associationId) => newrelic_1.default.startSegment(`${ORM_CACHE_PREFIX}:invalidateModelInstanceByAssociation`, true, () => __awaiter(this, void 0, void 0, function* () {
+        const invalidateModelInstanceByAssociation = (association, associationId) => __awaiter(this, void 0, void 0, function* () {
             const dependentInstancesKeys = yield cache.getClient().smembersAsync(generateDependencyKey(modelOptions.name, association, associationId));
-            this.debug(`Invalidating dependent instances (triggered by ${hook})`, { dependentInstancesKeys });
+            this.debug('Invalidating dependent instances', { dependentInstancesKeys });
             const removeMulti = cache.getClient().multi();
             const removeMultiAsync = util_1.promisify(removeMulti.exec).bind(removeMulti);
             const dependenciesToRemove = yield Promise.all(dependentInstancesKeys.map((instanceKey) => __awaiter(this, void 0, void 0, function* () {
@@ -150,19 +142,22 @@ class SequelizeAdapter {
                 removeMulti.del(instanceKey);
                 return dependencyKeys;
             })));
-            this.debug(`Removing dependencies (triggered by ${hook})`, { dependentInstancesKeys, dependenciesToRemove });
+            this.debug('Removing dependencies', { dependentInstancesKeys, dependenciesToRemove });
             return removeMultiAsync();
-        }));
+        });
         const model = this.getModel(modelOptions.name);
-        INVALIDATION_HOOKS.map(hook => model.addHook(hook, (instance, options) => handleTransactionHook(instance, options, instance => invalidateModelInstance(hook, instance))));
+        INVALIDATION_HOOKS.map(hook => model.addHook(hook, (instance, options) => handleTransactionHook(instance, options, instance => invalidateModelInstance(instance))));
+        BULK_HOOKS.map(hook => model.addHook(hook, options => options.individualHook = true));
         modelOptions.associations = this.getModelDependencies(modelOptions.name);
         this.debug(`Adding Invalidations Hooks to ${modelOptions.name}'s associations`, { associations: modelOptions.associations });
         modelOptions.associations.map((associationOptions) => {
             const associationModel = this.getModel(associationOptions.name);
-            INVALIDATION_HOOKS.map(hook => associationModel.addHook(hook, (instance, options) => handleTransactionHook(instance, options, associationInstance => invalidateModelInstanceByAssociation(hook, associationOptions.name, associationInstance[associationOptions.accessKey]))));
+            INVALIDATION_HOOKS.map(hook => associationModel.addHook(hook, (instance, options) => handleTransactionHook(instance, options, associationInstance => invalidateModelInstanceByAssociation(associationOptions.name, associationInstance[associationOptions.accessKey]))));
+            BULK_HOOKS.map(hook => associationModel.addHook(hook, options => options.individualHook = true));
             if (associationOptions.innerAssociation) {
                 const innerAssociationModel = this.getModel(associationOptions.innerAssociation.name);
-                INVALIDATION_HOOKS.map(hook => innerAssociationModel.addHook(hook, (instance, options) => handleTransactionHook(instance, options, innerAssociationInstance => invalidateModelInstanceByAssociation(hook, associationOptions.innerAssociation.name, innerAssociationInstance[associationOptions.innerAssociation.accessKey]))));
+                INVALIDATION_HOOKS.map(hook => innerAssociationModel.addHook(hook, (instance, options) => handleTransactionHook(instance, options, innerAssociationInstance => invalidateModelInstanceByAssociation(associationOptions.innerAssociation.name, innerAssociationInstance[associationOptions.innerAssociation.accessKey]))));
+                BULK_HOOKS.map(hook => innerAssociationModel.addHook(hook, options => options.individualHook = true));
             }
         });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/matmon",
-  "version": "2.0.4-beta-3",
+  "version": "2.0.4",
   "description": "manage cache",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -32,7 +32,6 @@
     "bluebird": "^3.7.2",
     "dotenv": "^8.2.0",
     "lru-cache": "^6.0.0",
-    "newrelic": "^7.5.2",
     "redis": "^3.0.2",
     "redis-lock": "^0.1.4",
     "sequelize": "^6.6.2",