@hotmeshio/hotmesh 0.0.1

package/build/services/pipe/index.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pipe = void 0;
+const functions_1 = __importDefault(require("./functions"));
+class Pipe {
+    constructor(rules, jobData) {
+        this.rules = rules;
+        this.jobData = jobData;
+    }
+    isPipeType(currentRow) {
+        return !Array.isArray(currentRow) && '@pipe' in currentRow;
+    }
+    static isPipeObject(obj) {
+        return typeof obj === 'object' && obj !== null && !Array.isArray(obj) && '@pipe' in obj;
+    }
+    static resolve(unresolved, context) {
+        let pipe;
+        if (Pipe.isPipeObject(unresolved)) {
+            pipe = new Pipe(unresolved['@pipe'], context);
+        }
+        else {
+            pipe = new Pipe([[unresolved]], context);
+        }
+        return pipe.process();
+    }
+    /**
+     * loop through each PipeItem row in this Pipe, resolving and transforming line by line
+     * @returns {any} the result of the pipe
+     */
+    process() {
+        let resolved = this.processCells(this.rules[0]);
+        const len = this.rules.length;
+        for (let i = 1; i < len; i++) {
+            resolved = this.processRow(this.rules[i], resolved, []);
+        }
+        return resolved[0];
+    }
+    processRow(currentRow, resolvedPriorRow, subPipeQueue) {
+        if (this.isPipeType(currentRow)) {
+            //currentRow is a recursive subPipe
+            const subPipe = new Pipe(currentRow['@pipe'], this.jobData);
+            subPipeQueue.push(subPipe.process());
+            //return prior row as if nothing happened
+            return resolvedPriorRow;
+        }
+        else {
+            if (subPipeQueue.length > 0) {
+                //if items in subPipeQueue, flush and use as resolvedPriorRow
+                resolvedPriorRow = [...subPipeQueue];
+                subPipeQueue.length = 0;
+            }
+            else if (!resolvedPriorRow) {
+                //if no prior row, use current row as prior row
+                return [].concat(this.processCells([...currentRow]));
+            }
+            else {
+                const [functionName, ...params] = currentRow;
+                //use resolved values from prior row (n - 1) as input params to cell 1 function
+                const resolvedValue = Pipe.resolveFunction(functionName)(...resolvedPriorRow);
+                //resolve remaining cells in row and return concatenated with resolvedValue
+                return [resolvedValue].concat(this.processCells([...params]));
+            }
+        }
+    }
+    static resolveFunction(functionName) {
+        let [prefix, suffix] = functionName.split('.');
+        prefix = prefix.substring(2);
+        suffix = suffix.substring(0, suffix.length - 1);
+        const domain = functions_1.default[prefix];
+        if (!domain) {
+            throw new Error(`Unknown domain name [${functionName}]: ${prefix}`);
+        }
+        if (!domain[suffix]) {
+            throw new Error(`Unknown domain function [${functionName}]: ${prefix}.${suffix}`);
+        }
+        return domain[suffix];
+    }
+    processCells(cells) {
+        const resolved = [];
+        for (const currentCell of cells) {
+            resolved.push(this.resolveCellValue(currentCell));
+        }
+        return resolved;
+    }
+    isFunction(currentCell) {
+        return typeof currentCell === 'string' && currentCell.startsWith('{@') && currentCell.endsWith('}');
+    }
+    isMappable(currentCell) {
+        return typeof currentCell === 'string' && currentCell.startsWith('{') && currentCell.endsWith('}');
+    }
+    resolveCellValue(currentCell) {
+        if (this.isFunction(currentCell)) {
+            const fn = Pipe.resolveFunction(currentCell);
+            return fn.call();
+        }
+        else if (this.isMappable(currentCell)) {
+            return this.resolveMappableValue(currentCell);
+        }
+        else {
+            return currentCell;
+        }
+    }
+    getNestedProperty(obj, path) {
+        const pathParts = path.split('.');
+        let current = obj;
+        for (const part of pathParts) {
+            if (current === null || typeof current !== 'object' || !current.hasOwnProperty(part)) {
+                return undefined;
+            }
+            current = current[part];
+        }
+        return current;
+    }
+    resolveMappableValue(currentCell) {
+        const term = this.resolveMapTerm(currentCell);
+        return this.getNestedProperty(this.jobData, term);
+    }
+    resolveFunctionTerm(currentCell) {
+        return currentCell.substring(2, currentCell.length - 1);
+    }
+    resolveMapTerm(currentCell) {
+        return currentCell.substring(1, currentCell.length - 1);
+    }
+}
+exports.Pipe = Pipe;

package/build/services/quorum/index.d.ts

@@ -0,0 +1,34 @@
+import { EngineService } from '../engine';
+import { ILogger } from '../logger';
+import { StoreService } from '../store';
+import { SubService } from '../sub';
+import { CacheMode } from '../../types/cache';
+import { QuorumMessageCallback, SubscriptionCallback, ThrottleMessage } from '../../types/quorum';
+import { HotMeshApps, HotMeshConfig } from '../../types/hotmesh';
+import { RedisClient, RedisMulti } from '../../types/redis';
+declare class QuorumService {
+    namespace: string;
+    apps: HotMeshApps | null;
+    appId: string;
+    guid: string;
+    engine: EngineService;
+    store: StoreService<RedisClient, RedisMulti> | null;
+    subscribe: SubService<RedisClient, RedisMulti> | null;
+    logger: ILogger;
+    cacheMode: CacheMode;
+    untilVersion: string | null;
+    quorum: number | null;
+    callbacks: QuorumMessageCallback[];
+    static init(namespace: string, appId: string, guid: string, config: HotMeshConfig, engine: EngineService, logger: ILogger): Promise<QuorumService>;
+    verifyQuorumFields(config: HotMeshConfig): void;
+    initStoreChannel(store: RedisClient): Promise<void>;
+    initSubChannel(sub: RedisClient): Promise<void>;
+    subscriptionHandler(): SubscriptionCallback;
+    sayPong(appId: string, guid: string, originator: string): Promise<void>;
+    requestQuorum(delay?: number): Promise<number>;
+    pub(quorumMessage: ThrottleMessage): Promise<boolean>;
+    sub(callback: QuorumMessageCallback): Promise<void>;
+    unsub(callback: QuorumMessageCallback): Promise<void>;
+    activate(version: string, delay?: number): Promise<boolean>;
+}
+export { QuorumService };

package/build/services/quorum/index.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuorumService = void 0;
+const key_1 = require("../../modules/key");
+const utils_1 = require("../../modules/utils");
+const compiler_1 = require("../compiler");
+const redis_1 = require("../store/clients/redis");
+const ioredis_1 = require("../store/clients/ioredis");
+const ioredis_2 = require("../sub/clients/ioredis");
+const redis_2 = require("../sub/clients/redis");
+//wait time to see if quorum is reached
+const QUORUM_DELAY = 250;
+class QuorumService {
+    constructor() {
+        this.cacheMode = 'cache';
+        this.untilVersion = null;
+        this.quorum = null;
+        this.callbacks = [];
+    }
+    static async init(namespace, appId, guid, config, engine, logger) {
+        if (config.engine) {
+            const instance = new QuorumService();
+            instance.verifyQuorumFields(config);
+            instance.namespace = namespace;
+            instance.appId = appId;
+            instance.guid = guid;
+            instance.logger = logger;
+            instance.engine = engine;
+            //note: `quorum` shares/re-uses the engine's `store`/`sub` Redis clients
+            await instance.initStoreChannel(config.engine.store);
+            await instance.initSubChannel(config.engine.sub);
+            await instance.subscribe.subscribe(key_1.KeyType.QUORUM, instance.subscriptionHandler(), appId); //general quorum subscription
+            await instance.subscribe.subscribe(key_1.KeyType.QUORUM, instance.subscriptionHandler(), appId, instance.guid); //app-specific quorum subscription (used for pubsub one-time request/response)
+            instance.engine.processWebHooks();
+            instance.engine.processTimeHooks();
+            return instance;
+        }
+    }
+    verifyQuorumFields(config) {
+        if (!(0, utils_1.identifyRedisType)(config.engine.store) ||
+            !(0, utils_1.identifyRedisType)(config.engine.sub)) {
+            throw new Error('quorum config must include `store` and `sub` fields.');
+        }
+    }
+    async initStoreChannel(store) {
+        if ((0, utils_1.identifyRedisType)(store) === 'redis') {
+            this.store = new redis_1.RedisStoreService(store);
+        }
+        else {
+            this.store = new ioredis_1.IORedisStoreService(store);
+        }
+        await this.store.init(this.namespace, this.appId, this.logger);
+    }
+    async initSubChannel(sub) {
+        if ((0, utils_1.identifyRedisType)(sub) === 'redis') {
+            this.subscribe = new redis_2.RedisSubService(sub);
+        }
+        else {
+            this.subscribe = new ioredis_2.IORedisSubService(sub);
+        }
+        await this.subscribe.init(this.namespace, this.appId, this.guid, this.logger);
+    }
+    subscriptionHandler() {
+        const self = this;
+        return async (topic, message) => {
+            self.logger.debug('quorum-event-received', { topic, type: message.type });
+            if (message.type === 'activate') {
+                self.engine.setCacheMode(message.cache_mode, message.until_version);
+            }
+            else if (message.type === 'ping') {
+                this.sayPong(self.appId, self.guid, message.originator);
+            }
+            else if (message.type === 'pong' && self.guid === message.originator) {
+                self.quorum = self.quorum + 1;
+            }
+            else if (message.type === 'throttle') {
+                self.engine.throttle(message.throttle);
+            }
+            else if (message.type === 'work') {
+                self.engine.processWebHooks();
+            }
+            else if (message.type === 'job') {
+                self.engine.routeToSubscribers(message.topic, message.job);
+            }
+            //if there are any callbacks, call them
+            if (self.callbacks.length > 0) {
+                self.callbacks.forEach(cb => cb(topic, message));
+            }
+        };
+    }
+    async sayPong(appId, guid, originator) {
+        this.store.publish(key_1.KeyType.QUORUM, { type: 'pong', guid, originator }, appId);
+    }
+    async requestQuorum(delay = QUORUM_DELAY) {
+        const quorum = this.quorum;
+        this.quorum = 0;
+        await this.store.publish(key_1.KeyType.QUORUM, { type: 'ping', originator: this.guid }, this.appId);
+        await (0, utils_1.sleepFor)(delay);
+        return quorum;
+    }
+    // ************* PUB/SUB METHODS *************
+    //publish a message to the quorum
+    async pub(quorumMessage) {
+        return await this.store.publish(key_1.KeyType.QUORUM, quorumMessage, this.appId, quorumMessage.topic || quorumMessage.guid);
+    }
+    //subscribe user to quorum messages
+    async sub(callback) {
+        //the quorum is always subscribed to the `quorum` topic; just register the fn
+        this.callbacks.push(callback);
+    }
+    //unsubscribe user from quorum messages
+    async unsub(callback) {
+        //the quorum is always subscribed to the `quorum` topic; just unregister the fn
+        this.callbacks = this.callbacks.filter(cb => cb !== callback);
+    }
+    // ************* COMPILER METHODS *************
+    async activate(version, delay = QUORUM_DELAY) {
+        version = version.toString();
+        const config = await this.engine.getVID();
+        //request a quorum to activate the version
+        await this.requestQuorum(delay);
+        const q1 = await this.requestQuorum(delay);
+        const q2 = await this.requestQuorum(delay);
+        const q3 = await this.requestQuorum(delay);
+        if (q1 && q1 === q2 && q2 === q3) {
+            this.logger.info('quorum-rollcall-succeeded', { q1, q2, q3 });
+            this.store.publish(key_1.KeyType.QUORUM, { type: 'activate', cache_mode: 'nocache', until_version: version }, this.appId);
+            await new Promise(resolve => setTimeout(resolve, delay));
+            //confirm we received the activation message
+            if (this.engine.untilVersion === version) {
+                this.logger.info('quorum-activation-succeeded', { version });
+                const { id } = config;
+                const compiler = new compiler_1.CompilerService(this.store, this.logger);
+                return await compiler.activate(id, version);
+            }
+            else {
+                this.logger.error('quorum-activation-error', { version });
+                throw new Error(`UntilVersion Not Received. Version ${version} not activated`);
+            }
+        }
+        else {
+            this.logger.info('quorum-rollcall-error', { q1, q2, q3 });
+            throw new Error(`Quorum not reached. Version ${version} not activated.`);
+        }
+    }
+}
+exports.QuorumService = QuorumService;

package/build/services/reporter/index.d.ts

@@ -0,0 +1,47 @@
+import { ILogger } from '../logger';
+import { StoreService } from '../store';
+import { TriggerActivity } from '../../types/activity';
+import { AppVID } from '../../types/app';
+import { JobState } from '../../types/job';
+import { RedisClient, RedisMulti } from '../../types/redis';
+import { GetStatsOptions, StatsResponse, IdsResponse, StatsType, StatType } from '../../types/stats';
+declare class ReporterService {
+    private appVersion;
+    private logger;
+    private store;
+    static DEFAULT_GRANULARITY: string;
+    constructor(appVersion: AppVID, store: StoreService<RedisClient, RedisMulti>, logger: ILogger);
+    getStats(options: GetStatsOptions): Promise<StatsResponse>;
+    private validateOptions;
+    private generateDateTimeSets;
+    private convertRangeToMinutes;
+    private buildRedisKey;
+    private aggregateData;
+    private buildStatsResponse;
+    private handleSegments;
+    private isoTimestampFromKeyTimestamp;
+    getIds(options: GetStatsOptions, facets: string[], idRange?: [number, number]): Promise<IdsResponse>;
+    private buildIdsResponse;
+    private buildTimeSegments;
+    getUniqueFacets(data: StatsResponse): string[];
+    getTargetForKey(key: string): string;
+    getTargetForTime(key: string): string;
+    getWorkItems(options: GetStatsOptions, facets: string[]): Promise<string[]>;
+    private buildWorkerLists;
+    /**
+     * called by `trigger` activity to generate the stats that should
+     * be saved to the database. doesn't actually save the stats, but
+     * just generates the info that should be saved
+     */
+    resolveTriggerStatistics({ stats: statsConfig }: TriggerActivity, context: JobState): StatsType;
+    isGeneralMetric(metric: string): boolean;
+    isMedianMetric(metric: string): boolean;
+    isIndexMetric(metric: string): boolean;
+    resolveMetric({ metric, target }: {
+        metric: any;
+        target: any;
+    }, context: JobState): StatType;
+    isCardinalMetric(metric: string): boolean;
+    resolveTarget(metric: string, target: string, resolvedValue: string): string;
+}
+export { ReporterService };

package/build/services/reporter/index.js

@@ -0,0 +1,330 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReporterService = void 0;
+const pipe_1 = require("../pipe");
+class ReporterService {
+    constructor(appVersion, store, logger) {
+        this.appVersion = appVersion;
+        this.logger = logger;
+        this.store = store;
+    }
+    async getStats(options) {
+        this.logger.debug('reporter-getstats-started', options);
+        const { key, granularity, range, end, start } = options;
+        this.validateOptions(options);
+        const dateTimeSets = this.generateDateTimeSets(granularity, range, end, start);
+        const redisKeys = dateTimeSets.map((dateTime) => this.buildRedisKey(key, dateTime));
+        const rawData = await this.store.getJobStats(redisKeys);
+        const [count, aggregatedData] = this.aggregateData(rawData);
+        const statsResponse = this.buildStatsResponse(rawData, redisKeys, aggregatedData, count, options);
+        return statsResponse;
+    }
+    validateOptions(options) {
+        const { start, end, range } = options;
+        if (start && end && range || !start && !end && !range) {
+            throw new Error('Invalid combination of start, end, and range values. Provide either start+end, end+range, or start+range.');
+        }
+    }
+    generateDateTimeSets(granularity, range, end, start) {
+        if (!range) {
+            //pluck just a single value when no range provided
+            range = '0m';
+        }
+        const granularitiesInMinutes = {
+            '5m': 5,
+            '10m': 10,
+            '15m': 15,
+            '30m': 30,
+            '1h': 60,
+        };
+        const granularityMinutes = granularitiesInMinutes[granularity];
+        if (!granularityMinutes) {
+            throw new Error('Invalid granularity value.');
+        }
+        const rangeMinutes = this.convertRangeToMinutes(range);
+        if (rangeMinutes === null) {
+            throw new Error('Invalid range value.');
+        }
+        // If start is provided, use it. Otherwise, calculate it from the end time and range.
+        let startTime;
+        let endTime;
+        if (start) {
+            startTime = new Date(start);
+            endTime = new Date(startTime.getTime() + rangeMinutes * 60 * 1000);
+        }
+        else {
+            endTime = end === 'NOW' ? new Date() : new Date(end);
+            startTime = new Date(endTime.getTime() - rangeMinutes * 60 * 1000);
+        }
+        // Round the start time to the nearest granularity unit
+        startTime.setUTCMinutes(Math.floor(startTime.getUTCMinutes() / granularityMinutes) * granularityMinutes);
+        const dateTimeSets = [];
+        for (let time = startTime; time <= endTime; time.setUTCMinutes(time.getUTCMinutes() + granularityMinutes)) {
+            const formattedTime = [
+                time.getUTCFullYear(),
+                String(time.getUTCMonth() + 1).padStart(2, '0'),
+                String(time.getUTCDate()).padStart(2, '0'),
+                String(time.getUTCHours()).padStart(2, '0'),
+                String(time.getUTCMinutes()).padStart(2, '0'),
+            ].join('');
+            dateTimeSets.push(formattedTime);
+        }
+        return dateTimeSets;
+    }
+    convertRangeToMinutes(range) {
+        const timeUnit = range.slice(-1);
+        const value = parseInt(range.slice(0, -1), 10);
+        if (isNaN(value)) {
+            return null;
+        }
+        switch (timeUnit) {
+            case 'm':
+                return value;
+            case 'h':
+                return value * 60;
+            case 'd':
+                return value * 60 * 24;
+            default:
+                return null;
+        }
+    }
+    buildRedisKey(key, dateTime, subTarget = '') {
+        return `hmsh:${this.appVersion.id}:s:${key}:${dateTime}${subTarget ? ':' + subTarget : ''}`;
+    }
+    aggregateData(rawData) {
+        const aggregatedData = {};
+        let count = 0;
+        Object.entries(rawData).forEach(([_, data]) => {
+            for (const key in data) {
+                if (key.startsWith('count:')) {
+                    const target = key.slice('count:'.length);
+                    if (!aggregatedData[target]) {
+                        aggregatedData[target] = 0;
+                    }
+                    aggregatedData[target] += data[key];
+                }
+                else if (key === 'count') {
+                    count += data[key];
+                }
+            }
+        });
+        return [count, aggregatedData];
+    }
+    buildStatsResponse(rawData, redisKeys, aggregatedData, count, options) {
+        const measures = [];
+        const measureKeys = Object.keys(aggregatedData).filter((key) => key !== "count");
+        let segments = undefined;
+        if (options.sparse !== true) {
+            segments = this.handleSegments(rawData, redisKeys);
+        }
+        measureKeys.forEach((key) => {
+            const measure = {
+                target: key,
+                type: "count",
+                value: aggregatedData[key],
+            };
+            measures.push(measure);
+        });
+        const response = {
+            key: options.key,
+            granularity: options.granularity,
+            range: options.range,
+            end: options.end,
+            count,
+            measures: measures,
+        };
+        if (segments) {
+            response.segments = segments;
+        }
+        return response;
+    }
+    handleSegments(data, hashKeys) {
+        const segments = [];
+        hashKeys.forEach((hashKey, index) => {
+            const segmentData = [];
+            data[hashKey] && Object.entries(data[hashKey]).forEach(([key, value]) => {
+                if (key.startsWith('count:')) {
+                    const target = key.slice('count:'.length);
+                    segmentData.push({ target, type: 'count', value });
+                }
+            });
+            const isoTimestamp = this.isoTimestampFromKeyTimestamp(hashKey);
+            const count = data[hashKey] ? data[hashKey].count : 0;
+            segments.push({ count, time: isoTimestamp, measures: segmentData });
+        });
+        return segments;
+    }
+    isoTimestampFromKeyTimestamp(hashKey) {
+        const keyTimestamp = hashKey.slice(-12);
+        const year = keyTimestamp.slice(0, 4);
+        const month = keyTimestamp.slice(4, 6);
+        const day = keyTimestamp.slice(6, 8);
+        const hour = keyTimestamp.slice(8, 10);
+        const minute = keyTimestamp.slice(10, 12);
+        return `${year}-${month}-${day}T${hour}:${minute}Z`;
+    }
+    async getIds(options, facets, idRange = [0, -1]) {
+        if (!facets.length) {
+            const stats = await this.getStats(options);
+            facets = this.getUniqueFacets(stats);
+        }
+        const { key, granularity, range, end, start } = options;
+        this.validateOptions(options);
+        let redisKeys = [];
+        facets.forEach((facet) => {
+            const dateTimeSets = this.generateDateTimeSets(granularity, range, end, start);
+            redisKeys = redisKeys.concat(dateTimeSets.map((dateTime) => this.buildRedisKey(key, dateTime, `index:${facet}`)));
+        });
+        const idsData = await this.store.getJobIds(redisKeys, idRange);
+        const idsResponse = this.buildIdsResponse(idsData, options, facets);
+        return idsResponse;
+    }
+    buildIdsResponse(idsData, options, facets) {
+        const countsByFacet = {};
+        const measureKeys = Object.keys(idsData);
+        measureKeys.forEach((key) => {
+            const target = this.getTargetForKey(key);
+            const count = idsData[key].length;
+            if (countsByFacet[target]) {
+                countsByFacet[target] += count;
+            }
+            else {
+                countsByFacet[target] = count;
+            }
+        });
+        const counts = Object.entries(countsByFacet).map(([facet, count]) => ({ facet, count }));
+        const response = {
+            key: options.key,
+            facets,
+            granularity: options.granularity,
+            range: options.range,
+            start: options.start,
+            counts,
+            segments: this.buildTimeSegments(idsData),
+        };
+        return response;
+    }
+    buildTimeSegments(idsData) {
+        const measureKeys = Object.keys(idsData);
+        const timeSegments = {};
+        measureKeys.forEach((key) => {
+            const measure = {
+                type: 'ids',
+                target: this.getTargetForKey(key),
+                time: this.isoTimestampFromKeyTimestamp(this.getTargetForTime(key)),
+                count: idsData[key].length,
+                ids: idsData[key],
+            };
+            if (timeSegments[measure.time]) {
+                timeSegments[measure.time].push(measure);
+            }
+            else {
+                timeSegments[measure.time] = [measure];
+            }
+        });
+        const segments = Object.entries(timeSegments).map(([time, measures]) => ({
+            time,
+            measures,
+        }));
+        return segments;
+    }
+    getUniqueFacets(data) {
+        const targets = data.measures.map(measure => measure.target);
+        return Array.from(new Set(targets));
+    }
+    getTargetForKey(key) {
+        return key.split(':index:')[1];
+    }
+    getTargetForTime(key) {
+        return key.split(':index:')[0];
+    }
+    async getWorkItems(options, facets) {
+        if (!facets.length) {
+            const stats = await this.getStats(options);
+            facets = this.getUniqueFacets(stats);
+        }
+        const { key, granularity, range, end, start } = options;
+        this.validateOptions(options);
+        let redisKeys = [];
+        facets.forEach((facet) => {
+            const dateTimeSets = this.generateDateTimeSets(granularity, range, end, start);
+            redisKeys = redisKeys.concat(dateTimeSets.map((dateTime) => this.buildRedisKey(key, dateTime, `index:${facet}`)));
+        });
+        const idsData = await this.store.getJobIds(redisKeys, [0, 1]);
+        const workerLists = this.buildWorkerLists(idsData);
+        return workerLists;
+    }
+    buildWorkerLists(idsData) {
+        const workerLists = [];
+        for (const key in idsData) {
+            if (idsData[key].length) {
+                workerLists.push(key);
+            }
+        }
+        return workerLists;
+    }
+    /**
+     * called by `trigger` activity to generate the stats that should
+     * be saved to the database. doesn't actually save the stats, but
+     * just generates the info that should be saved
+     */
+    resolveTriggerStatistics({ stats: statsConfig }, context) {
+        const stats = {
+            general: [],
+            index: [],
+            median: []
+        };
+        stats.general.push({ metric: 'count', target: 'count', value: 1 });
+        for (const measure of statsConfig.measures) {
+            const metric = this.resolveMetric({ metric: measure.measure, target: measure.target }, context);
+            if (this.isGeneralMetric(measure.measure)) {
+                stats.general.push(metric);
+            }
+            else if (this.isMedianMetric(measure.measure)) {
+                stats.median.push(metric);
+            }
+            else if (this.isIndexMetric(measure.measure)) {
+                stats.index.push(metric);
+            }
+        }
+        return stats;
+    }
+    isGeneralMetric(metric) {
+        return metric === 'sum' || metric === 'avg' || metric === 'count';
+    }
+    isMedianMetric(metric) {
+        return metric === 'mdn';
+    }
+    isIndexMetric(metric) {
+        return metric === 'index';
+    }
+    resolveMetric({ metric, target }, context) {
+        const pipe = new pipe_1.Pipe([[target]], context);
+        const resolvedValue = pipe.process().toString();
+        const resolvedTarget = this.resolveTarget(metric, target, resolvedValue);
+        if (metric === 'index') {
+            return { metric, target: resolvedTarget, value: context.metadata.jid };
+        }
+        else if (metric === 'count') {
+            return { metric, target: resolvedTarget, value: 1 };
+        }
+        return { metric, target: resolvedTarget, value: resolvedValue };
+    }
+    isCardinalMetric(metric) {
+        return metric === 'index' || metric === 'count';
+    }
+    resolveTarget(metric, target, resolvedValue) {
+        const trimmed = target.substring(1, target.length - 1);
+        const trimmedTarget = trimmed.split('.').slice(3).join('/');
+        let resolvedTarget;
+        if (this.isCardinalMetric(metric)) {
+            resolvedTarget = `${metric}:${trimmedTarget}:${resolvedValue}`;
+        }
+        else {
+            resolvedTarget = `${metric}:${trimmedTarget}`;
+        }
+        return resolvedTarget;
+    }
+}
+exports.ReporterService = ReporterService;
+ReporterService.DEFAULT_GRANULARITY = '5m';