@hotmeshio/hotmesh 0.0.1

package/build/services/stream/clients/ioredis.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IORedisStreamService = void 0;
+const key_1 = require("../../../modules/key");
+const index_1 = require("../index");
+class IORedisStreamService extends index_1.StreamService {
+    constructor(redisClient) {
+        super(redisClient);
+    }
+    async init(namespace = key_1.PSNS, appId, logger) {
+        this.namespace = namespace;
+        this.logger = logger;
+        this.appId = appId;
+    }
+    getMulti() {
+        return this.redisClient.multi();
+    }
+    mintKey(type, params) {
+        if (!this.namespace)
+            throw new Error('namespace not set');
+        return key_1.KeyService.mintKey(this.namespace, type, params);
+    }
+    async xgroup(command, key, groupName, id, mkStream) {
+        if (mkStream === 'MKSTREAM') {
+            try {
+                return (await this.redisClient.xgroup(command, key, groupName, id, mkStream)) === 'OK';
+            }
+            catch (err) {
+                this.logger.info(`Consumer group not created with MKSTREAM for key: ${key} and group: ${groupName}`);
+                throw err;
+            }
+        }
+        else {
+            try {
+                return (await this.redisClient.xgroup(command, key, groupName, id)) === 'OK';
+            }
+            catch (err) {
+                this.logger.info(`Consumer group not created for key: ${key} and group: ${groupName}`);
+                throw err;
+            }
+        }
+    }
+    async xadd(key, id, messageId, messageValue, multi) {
+        try {
+            return await (multi || this.redisClient).xadd(key, id, messageId, messageValue);
+        }
+        catch (err) {
+            this.logger.error(`Error publishing 'xadd'; key: ${key}`, err);
+            throw err;
+        }
+    }
+    async xreadgroup(command, groupName, consumerName, blockOption, blockTime, streamsOption, streamName, id) {
+        try {
+            //@ts-ignore
+            return await this.redisClient.xreadgroup(command, groupName, consumerName, 
+            // @ts-ignore
+            blockOption, blockTime, streamsOption, streamName, id);
+        }
+        catch (err) {
+            this.logger.error(`Error reading stream data [Stream ${streamName}] [Group ${groupName}]`, err);
+            throw err;
+        }
+    }
+    async xpending(key, group, start, end, count, consumer) {
+        try {
+            const args = [key, group];
+            if (start)
+                args.push(start);
+            if (end)
+                args.push(end);
+            if (count !== undefined)
+                args.push(count.toString());
+            if (consumer)
+                args.push(consumer);
+            try {
+                return await this.redisClient.call('XPENDING', ...args);
+            }
+            catch (err) {
+                this.logger.error('err, args', err, args);
+            }
+        }
+        catch (err) {
+            this.logger.error(`Error in retrieving pending messages for [stream ${key}], [group ${group}]`, err);
+            throw err;
+        }
+    }
+    async xclaim(key, group, consumer, minIdleTime, id, ...args) {
+        try {
+            return await this.redisClient.xclaim(key, group, consumer, minIdleTime, id, ...args);
+        }
+        catch (err) {
+            this.logger.error(`Error in claiming message with id: ${id} in group: ${group} for key: ${key}`, err);
+            throw err;
+        }
+    }
+    async xack(key, group, id, multi) {
+        try {
+            return await (multi || this.redisClient).xack(key, group, id);
+        }
+        catch (err) {
+            this.logger.error(`Error in acknowledging messages in group: ${group} for key: ${key}`, err);
+            throw err;
+        }
+    }
+    async xdel(key, id, multi) {
+        try {
+            return await (multi || this.redisClient).xdel(key, id);
+        }
+        catch (err) {
+            this.logger.error(`Error in deleting messages with id: ${id} for key: ${key}`, err);
+            throw err;
+        }
+    }
+}
+exports.IORedisStreamService = IORedisStreamService;

package/build/services/stream/clients/redis.d.ts

@@ -0,0 +1,23 @@
+import { KeyStoreParams, KeyType } from '../../../modules/key';
+import { ILogger } from '../../logger';
+import { StreamService } from '../index';
+import { RedisClientType, RedisMultiType } from '../../../types/redisclient';
+import { ReclaimedMessageType } from '../../../types/stream';
+declare class RedisStreamService extends StreamService<RedisClientType, RedisMultiType> {
+    redisClient: RedisClientType;
+    namespace: string;
+    logger: ILogger;
+    appId: string;
+    constructor(redisClient: RedisClientType);
+    init(namespace: string, appId: string, logger: ILogger): Promise<void>;
+    getMulti(): RedisMultiType;
+    mintKey(type: KeyType, params: KeyStoreParams): string;
+    xgroup(command: 'CREATE', key: string, groupName: string, id: string, mkStream?: 'MKSTREAM'): Promise<boolean>;
+    xadd(key: string, id: string, ...args: any[]): Promise<string | RedisMultiType>;
+    xreadgroup(command: 'GROUP', groupName: string, consumerName: string, blockOption: 'BLOCK' | 'COUNT', blockTime: number | string, streamsOption: 'STREAMS', streamName: string, id: string): Promise<string[][][] | null>;
+    xpending(key: string, group: string, start?: string, end?: string, count?: number, consumer?: string): Promise<[string, string, number, [string, number][]][] | [string, string, number, number]>;
+    xclaim(key: string, group: string, consumer: string, minIdleTime: number, id: string, ...args: string[]): Promise<ReclaimedMessageType>;
+    xack(key: string, group: string, id: string, multi?: RedisMultiType): Promise<number | RedisMultiType>;
+    xdel(key: string, id: string, multi?: RedisMultiType): Promise<number | RedisMultiType>;
+}
+export { RedisStreamService };

package/build/services/stream/clients/redis.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisStreamService = void 0;
+const key_1 = require("../../../modules/key");
+const index_1 = require("../index");
+class RedisStreamService extends index_1.StreamService {
+    constructor(redisClient) {
+        super(redisClient);
+    }
+    async init(namespace = key_1.PSNS, appId, logger) {
+        this.namespace = namespace;
+        this.logger = logger;
+        this.appId = appId;
+    }
+    getMulti() {
+        return this.redisClient.MULTI();
+    }
+    mintKey(type, params) {
+        if (!this.namespace)
+            throw new Error('namespace not set');
+        return key_1.KeyService.mintKey(this.namespace, type, params);
+    }
+    async xgroup(command, key, groupName, id, mkStream) {
+        const args = mkStream === 'MKSTREAM' ? ['MKSTREAM'] : [];
+        try {
+            return (await this.redisClient.sendCommand(['XGROUP', 'CREATE', key, groupName, id, ...args])) === 1;
+        }
+        catch (err) {
+            const streamType = mkStream === 'MKSTREAM' ? 'with MKSTREAM' : 'without MKSTREAM';
+            this.logger.error(`x-group-error ${streamType} for key: ${key} and group: ${groupName}`, err);
+            throw err;
+        }
+    }
+    async xadd(key, id, ...args) {
+        let multi;
+        if (typeof args[args.length - 1] !== 'string') {
+            multi = args.pop();
+        }
+        try {
+            return await (multi || this.redisClient).XADD(key, id, { [args[0]]: args[1] });
+        }
+        catch (err) {
+            this.logger.error(`Error publishing 'xadd'; key: ${key}`, err);
+            throw err;
+        }
+    }
+    async xreadgroup(command, groupName, consumerName, blockOption, blockTime, streamsOption, streamName, id) {
+        try {
+            return await this.redisClient.sendCommand(['XREADGROUP', command, groupName, consumerName, blockOption, blockTime.toString(), streamsOption, streamName, id]);
+        }
+        catch (err) {
+            this.logger.error(`Error in reading data from group: ${groupName} in stream: ${streamName}`, err);
+            throw err;
+        }
+    }
+    async xpending(key, group, start, end, count, consumer) {
+        try {
+            const args = [key, group];
+            if (start)
+                args.push(start);
+            if (end)
+                args.push(end);
+            if (count !== undefined)
+                args.push(count.toString());
+            if (consumer)
+                args.push(consumer);
+            try {
+                return await this.redisClient.sendCommand(['XPENDING', ...args]);
+            }
+            catch (err) {
+                this.logger.error('err, args', err, args);
+            }
+        }
+        catch (err) {
+            this.logger.error(`Error in retrieving pending messages for group: ${group} in key: ${key}`, err);
+            throw err;
+        }
+    }
+    async xclaim(key, group, consumer, minIdleTime, id, ...args) {
+        try {
+            return await this.redisClient.sendCommand(['XCLAIM', key, group, consumer, minIdleTime.toString(), id, ...args]);
+        }
+        catch (err) {
+            this.logger.error(`Error in claiming message with id: ${id} in group: ${group} for key: ${key}`, err);
+            throw err;
+        }
+    }
+    async xack(key, group, id, multi) {
+        try {
+            if (multi) {
+                multi.XACK(key, group, id);
+                return multi;
+            }
+            else {
+                return await this.redisClient.XACK(key, group, id);
+            }
+        }
+        catch (err) {
+            this.logger.error(`Error in acknowledging messages in group: ${group} for key: ${key}`, err);
+            throw err;
+        }
+    }
+    async xdel(key, id, multi) {
+        try {
+            if (multi) {
+                multi.XDEL(key, id);
+                return multi;
+            }
+            else {
+                return await this.redisClient.XDEL(key, id);
+            }
+        }
+        catch (err) {
+            this.logger.error(`Error in deleting messages with ids: ${id} for key: ${key}`, err);
+            throw err;
+        }
+    }
+}
+exports.RedisStreamService = RedisStreamService;

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

@@ -0,0 +1,21 @@
+import { KeyStoreParams, KeyType } from '../../modules/key';
+import { ReclaimedMessageType } from '../../types/stream';
+import { ILogger } from '../logger';
+declare abstract class StreamService<T, U> {
+    redisClient: T;
+    namespace: string;
+    logger: ILogger;
+    appId: string;
+    constructor(redisClient: T);
+    abstract init(namespace: string, appId: string, logger: ILogger): Promise<void>;
+    abstract getMulti(): U;
+    abstract mintKey(type: KeyType, params: KeyStoreParams): string;
+    abstract xgroup(command: 'CREATE', key: string, groupName: string, id: string, mkStream?: 'MKSTREAM'): Promise<boolean>;
+    abstract xadd(key: string, id: string, messageId: string, messageValue: string, multi?: U): Promise<string | U>;
+    abstract xreadgroup(command: 'GROUP', groupName: string, consumerName: string, blockOption: 'BLOCK' | 'COUNT', blockTime: number | string, streamsOption: 'STREAMS', streamName: string, id: string): Promise<string[][][] | null | unknown[]>;
+    abstract xpending(key: string, group: string, start?: string, end?: string, count?: number, consumer?: string): Promise<[string, string, number, [string, number][]][] | [string, string, number, number] | unknown[]>;
+    abstract xclaim(key: string, group: string, consumer: string, minIdleTime: number, id: string, ...args: string[]): Promise<ReclaimedMessageType>;
+    abstract xack(key: string, group: string, id: string, multi?: U): Promise<number | U>;
+    abstract xdel(key: string, id: string, multi?: U): Promise<number | U>;
+}
+export { StreamService };

package/build/services/stream/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamService = void 0;
+class StreamService {
+    constructor(redisClient) {
+        this.redisClient = redisClient;
+    }
+}
+exports.StreamService = StreamService;

package/build/services/sub/clients/ioredis.d.ts

@@ -0,0 +1,20 @@
+import { KeyStoreParams, KeyType } from '../../../modules/key';
+import { ILogger } from '../../logger';
+import { SubService } from '../index';
+import { RedisClientType, RedisMultiType } from '../../../types/ioredisclient';
+import { SubscriptionCallback } from '../../../types/quorum';
+declare class IORedisSubService extends SubService<RedisClientType, RedisMultiType> {
+    redisClient: RedisClientType;
+    namespace: string;
+    logger: ILogger;
+    appId: string;
+    constructor(redisClient: RedisClientType);
+    init(namespace: string, appId: string, engineId: string, logger: ILogger): Promise<void>;
+    getMulti(): RedisMultiType;
+    mintKey(type: KeyType, params: KeyStoreParams): string;
+    subscribe(keyType: KeyType.QUORUM, callback: SubscriptionCallback, appId: string, engineId?: string): Promise<void>;
+    unsubscribe(keyType: KeyType.QUORUM, appId: string, engineId?: string): Promise<void>;
+    psubscribe(keyType: KeyType.QUORUM, callback: SubscriptionCallback, appId: string, engineId?: string): Promise<void>;
+    punsubscribe(keyType: KeyType.QUORUM, appId: string, engineId?: string): Promise<void>;
+}
+export { IORedisSubService };

package/build/services/sub/clients/ioredis.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IORedisSubService = void 0;
+const key_1 = require("../../../modules/key");
+const index_1 = require("../index");
+class IORedisSubService extends index_1.SubService {
+    constructor(redisClient) {
+        super(redisClient);
+    }
+    async init(namespace = key_1.PSNS, appId, engineId, logger) {
+        this.namespace = namespace;
+        this.logger = logger;
+        this.appId = appId;
+    }
+    getMulti() {
+        return this.redisClient.multi();
+    }
+    mintKey(type, params) {
+        if (!this.namespace)
+            throw new Error('namespace not set');
+        return key_1.KeyService.mintKey(this.namespace, type, params);
+    }
+    async subscribe(keyType, callback, appId, engineId) {
+        const self = this;
+        const topic = this.mintKey(keyType, { appId, engineId });
+        await this.redisClient.subscribe(topic, (err) => {
+            if (err) {
+                self.logger.error(`Error subscribing to: ${topic}`, err);
+            }
+        });
+        this.redisClient.on('message', (channel, message) => {
+            if (channel === topic) {
+                try {
+                    const payload = JSON.parse(message);
+                    callback(topic, payload);
+                }
+                catch (e) {
+                    self.logger.error(`Error parsing message: ${message}`, e);
+                }
+            }
+        });
+    }
+    async unsubscribe(keyType, appId, engineId) {
+        const topic = this.mintKey(keyType, { appId, engineId });
+        await this.redisClient.unsubscribe(topic);
+    }
+    async psubscribe(keyType, callback, appId, engineId) {
+        const self = this;
+        const topic = this.mintKey(keyType, { appId, engineId });
+        await this.redisClient.psubscribe(topic, (err) => {
+            if (err) {
+                self.logger.error(`Error subscribing to: ${topic}`, err);
+            }
+        });
+        this.redisClient.on('pmessage', (pattern, channel, message) => {
+            if (pattern === topic) {
+                try {
+                    const payload = JSON.parse(message);
+                    callback(channel, payload);
+                }
+                catch (e) {
+                    self.logger.error(`Error parsing message: ${message}`, e);
+                }
+            }
+        });
+    }
+    async punsubscribe(keyType, appId, engineId) {
+        const topic = this.mintKey(keyType, { appId, engineId });
+        await this.redisClient.punsubscribe(topic);
+    }
+}
+exports.IORedisSubService = IORedisSubService;

package/build/services/sub/clients/redis.d.ts

@@ -0,0 +1,20 @@
+import { KeyStoreParams, KeyType } from '../../../modules/key';
+import { ILogger } from '../../logger';
+import { SubService } from '../index';
+import { RedisClientType, RedisMultiType } from '../../../types/redisclient';
+import { SubscriptionCallback } from '../../../types/quorum';
+declare class RedisSubService extends SubService<RedisClientType, RedisMultiType> {
+    redisClient: RedisClientType;
+    namespace: string;
+    logger: ILogger;
+    appId: string;
+    constructor(redisClient: RedisClientType);
+    init(namespace: string, appId: string, engineId: string, logger: ILogger): Promise<void>;
+    getMulti(): RedisMultiType;
+    mintKey(type: KeyType, params: KeyStoreParams): string;
+    subscribe(keyType: KeyType.QUORUM, callback: SubscriptionCallback, appId: string, engineId?: string): Promise<void>;
+    unsubscribe(keyType: KeyType.QUORUM, appId: string, engineId?: string): Promise<void>;
+    psubscribe(keyType: KeyType.QUORUM, callback: SubscriptionCallback, appId: string, engineId?: string): Promise<void>;
+    punsubscribe(keyType: KeyType.QUORUM, appId: string, engineId?: string): Promise<void>;
+}
+export { RedisSubService };

package/build/services/sub/clients/redis.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisSubService = void 0;
+const key_1 = require("../../../modules/key");
+const index_1 = require("../index");
+class RedisSubService extends index_1.SubService {
+    constructor(redisClient) {
+        super(redisClient);
+    }
+    async init(namespace = key_1.PSNS, appId, engineId, logger) {
+        this.namespace = namespace;
+        this.logger = logger;
+        this.appId = appId;
+    }
+    getMulti() {
+        const multi = this.redisClient.MULTI();
+        return multi;
+    }
+    mintKey(type, params) {
+        if (!this.namespace)
+            throw new Error('namespace not set');
+        return key_1.KeyService.mintKey(this.namespace, type, params);
+    }
+    async subscribe(keyType, callback, appId, engineId) {
+        if (this.redisClient) {
+            const self = this;
+            const topic = this.mintKey(keyType, { appId, engineId });
+            await this.redisClient.subscribe(topic, (message) => {
+                try {
+                    const payload = JSON.parse(message);
+                    callback(topic, payload);
+                }
+                catch (e) {
+                    self.logger.error(`Error parsing message: ${message}`, e);
+                }
+            });
+        }
+    }
+    async unsubscribe(keyType, appId, engineId) {
+        const topic = this.mintKey(keyType, { appId, engineId });
+        await this.redisClient.unsubscribe(topic);
+    }
+    async psubscribe(keyType, callback, appId, engineId) {
+        if (this.redisClient) {
+            const self = this;
+            const topic = this.mintKey(keyType, { appId, engineId });
+            await this.redisClient.pSubscribe(topic, (message, channel) => {
+                try {
+                    const payload = JSON.parse(message);
+                    callback(channel, payload);
+                }
+                catch (e) {
+                    self.logger.error(`Error parsing message: ${message}`, e);
+                }
+            });
+        }
+    }
+    async punsubscribe(keyType, appId, engineId) {
+        const topic = this.mintKey(keyType, { appId, engineId });
+        await this.redisClient.pUnsubscribe(topic);
+    }
+}
+exports.RedisSubService = RedisSubService;

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

@@ -0,0 +1,18 @@
+import { KeyStoreParams, KeyType } from '../../modules/key';
+import { ILogger } from '../logger';
+import { SubscriptionCallback } from '../../types/quorum';
+declare abstract class SubService<T, U> {
+    redisClient: T;
+    namespace: string;
+    logger: ILogger;
+    appId: string;
+    constructor(redisClient: T);
+    abstract init(namespace: string, appId: string, engineId: string, logger: ILogger): Promise<void>;
+    abstract getMulti(): U;
+    abstract mintKey(type: KeyType, params: KeyStoreParams): string;
+    abstract subscribe(keyType: KeyType.QUORUM, callback: SubscriptionCallback, appId: string, engineId?: string): Promise<void>;
+    abstract unsubscribe(keyType: KeyType.QUORUM, appId: string, engineId?: string): Promise<void>;
+    abstract psubscribe(keyType: KeyType.QUORUM, callback: SubscriptionCallback, appId: string, engineId?: string): Promise<void>;
+    abstract punsubscribe(keyType: KeyType.QUORUM, appId: string, engineId?: string): Promise<void>;
+}
+export { SubService };

package/build/services/sub/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubService = void 0;
+class SubService {
+    constructor(redisClient) {
+        this.redisClient = redisClient;
+    }
+}
+exports.SubService = SubService;

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

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import { ILogger } from '../logger';
+import { StoreService } from '../store';
+import { RedisClient, RedisMulti } from '../../types/redis';
+import { HookInterface } from '../../types/hook';
+declare class TaskService {
+    store: StoreService<RedisClient, RedisMulti>;
+    logger: ILogger;
+    cleanupTimeout: NodeJS.Timeout | null;
+    constructor(store: StoreService<RedisClient, RedisMulti>, logger: ILogger);
+    processWebHooks(hookEventCallback: HookInterface): Promise<void>;
+    enqueueWorkItems(keys: string[]): Promise<void>;
+    registerJobForCleanup(jobId: string, inSeconds?: number): Promise<void>;
+    registerTimeHook(jobId: string, activityId: string, type: 'sleep' | 'expire' | 'cron', inSeconds?: number, multi?: RedisMulti): Promise<void>;
+    processTimeHooks(timeEventCallback: (jobId: string, activityId: string) => Promise<void>, listKey?: string): Promise<void>;
+    cancelCleanup(): void;
+}
+export { TaskService };

package/build/services/task/index.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskService = void 0;
+const utils_1 = require("../../modules/utils");
+//system timer granularity limit (task queues organize)
+const FIDELITY_SECONDS = 15; //note: this can be reduced using 'watch' or scout role
+//default resolution/fidelity when expiring
+const EXPIRATION_FIDELITY_SECONDS = 60;
+class TaskService {
+    constructor(store, logger) {
+        this.cleanupTimeout = null;
+        this.logger = logger;
+        this.store = store;
+    }
+    async processWebHooks(hookEventCallback) {
+        const workItemKey = await this.store.getActiveTaskQueue();
+        if (workItemKey) {
+            const [topic, sourceKey, ...sdata] = workItemKey.split('::');
+            const data = JSON.parse(sdata.join('::'));
+            const destinationKey = `${sourceKey}:processed`;
+            const jobId = await this.store.processTaskQueue(sourceKey, destinationKey);
+            if (jobId) {
+                await hookEventCallback(topic, { ...data, id: jobId });
+                //todo: do final checksum count (values are tracked in the stats hash)
+            }
+            else {
+                await this.store.deleteProcessedTaskQueue(workItemKey, sourceKey, destinationKey);
+            }
+            setImmediate(() => this.processWebHooks(hookEventCallback));
+        }
+    }
+    async enqueueWorkItems(keys) {
+        await this.store.addTaskQueues(keys);
+    }
+    async registerJobForCleanup(jobId, inSeconds = EXPIRATION_FIDELITY_SECONDS) {
+        if (inSeconds > -1) {
+            await this.store.expireJob(jobId, inSeconds);
+        }
+    }
+    async registerTimeHook(jobId, activityId, type, inSeconds = FIDELITY_SECONDS, multi) {
+        const awakenTimeSlot = Math.floor((Date.now() + inSeconds * 1000) / (FIDELITY_SECONDS * 1000)) * (FIDELITY_SECONDS * 1000); //n second awaken groups
+        await this.store.registerTimeHook(jobId, activityId, type, awakenTimeSlot, multi);
+    }
+    //todo: need 'scout' role in quorum to check for this and then alert the quorum to get to work
+    async processTimeHooks(timeEventCallback, listKey) {
+        try {
+            const job = await this.store.getNextTimeJob(listKey);
+            if (job) {
+                const [listKey, jobId, activityId] = job;
+                await timeEventCallback(jobId, activityId);
+                await (0, utils_1.sleepFor)(0);
+                this.processTimeHooks(timeEventCallback, listKey);
+            }
+            else {
+                let sleep = (0, utils_1.XSleepFor)(FIDELITY_SECONDS * 1000);
+                this.cleanupTimeout = sleep.timerId;
+                await sleep.promise;
+                this.processTimeHooks(timeEventCallback);
+            }
+        }
+        catch (err) {
+            //todo: retry connect to redis
+            this.logger.error('task-process-timehooks-error', err);
+        }
+    }
+    cancelCleanup() {
+        if (this.cleanupTimeout !== undefined) {
+            clearTimeout(this.cleanupTimeout);
+            this.cleanupTimeout = undefined;
+        }
+    }
+}
+exports.TaskService = TaskService;

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

@@ -0,0 +1,49 @@
+import { ActivityMetadata, ActivityType, Consumes } from '../../types/activity';
+import { JobState } from '../../types/job';
+import { StringAnyType, StringScalarType, StringStringType } from '../../types/serializer';
+import { StreamData, StreamRole } from '../../types/stream';
+import { Span, Context } from '../../types/telemetry';
+declare class TelemetryService {
+    span: Span;
+    jobSpan: Span;
+    config: ActivityType;
+    traceId: string | null;
+    spanId: string | null;
+    appId: string;
+    metadata: ActivityMetadata;
+    context: JobState;
+    leg: number;
+    constructor(appId: string, config?: ActivityType, metadata?: ActivityMetadata, context?: JobState);
+    getJobParentSpanId(): string | undefined;
+    getActivityParentSpanId(leg: number): string | undefined;
+    getTraceId(): string | undefined;
+    startJobSpan(): TelemetryService;
+    startActivitySpan(leg?: number): TelemetryService;
+    startStreamSpan(data: StreamData, role: StreamRole): TelemetryService;
+    startSpan(traceId: string, spanId: string, spanName: string, attributes: StringScalarType): Span;
+    mapActivityAttributes(): void;
+    setActivityAttributes(attributes: StringScalarType): void;
+    setStreamAttributes(attributes: StringScalarType): void;
+    setJobAttributes(attributes: StringScalarType): void;
+    endJobSpan(): void;
+    endActivitySpan(): void;
+    endStreamSpan(): void;
+    endSpan(span: Span): void;
+    getParentSpanContext(): undefined | Context;
+    getSpanAttrs(leg: number): StringAnyType;
+    getStreamSpanAttrs(input: StreamData): StringAnyType;
+    setTelemetryContext(span: Span, leg: number): void;
+    setActivityError(message: string): void;
+    setStreamError(message: string): void;
+    /**
+     * Adds the paths (HGET) necessary to restore telemetry state for an activity
+     * @param consumes
+     * @param config
+     * @param metadata
+     * @param leg
+     */
+    static addTargetTelemetryPaths(consumes: Consumes, config: ActivityType, metadata: ActivityMetadata, leg: number): void;
+    static bindJobTelemetryToState(state: StringStringType, config: ActivityType, context: JobState): void;
+    static bindActivityTelemetryToState(state: StringAnyType, config: ActivityType, metadata: ActivityMetadata, context: JobState, leg: number): void;
+}
+export { TelemetryService };