@hotmeshio/hotmesh 0.0.8 → 0.0.9

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

@@ -1,112 +0,0 @@
-import { KeyService, PSNS } from '../../../modules/key';
-import { StreamService } from '../index';
-class IORedisStreamService extends StreamService {
-    constructor(redisClient) {
-        super(redisClient);
-    }
-    async init(namespace = 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 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;
-        }
-    }
-}
-export { IORedisStreamService };

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

@@ -1,23 +0,0 @@
-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/esm/services/stream/clients/redis.js

@@ -1,116 +0,0 @@
-import { KeyService, PSNS } from '../../../modules/key';
-import { StreamService } from '../index';
-class RedisStreamService extends StreamService {
-    constructor(redisClient) {
-        super(redisClient);
-    }
-    async init(namespace = 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 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;
-        }
-    }
-}
-export { RedisStreamService };

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

@@ -1,21 +0,0 @@
-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/esm/services/stream/index.js

@@ -1,6 +0,0 @@
-class StreamService {
-    constructor(redisClient) {
-        this.redisClient = redisClient;
-    }
-}
-export { StreamService };

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

@@ -1,20 +0,0 @@
-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/esm/services/sub/clients/ioredis.js

@@ -1,69 +0,0 @@
-import { KeyService, PSNS } from '../../../modules/key';
-import { SubService } from '../index';
-class IORedisSubService extends SubService {
-    constructor(redisClient) {
-        super(redisClient);
-    }
-    async init(namespace = 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 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);
-    }
-}
-export { IORedisSubService };

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

@@ -1,20 +0,0 @@
-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/esm/services/sub/clients/redis.js

@@ -1,60 +0,0 @@
-import { KeyService, PSNS } from '../../../modules/key';
-import { SubService } from '../index';
-class RedisSubService extends SubService {
-    constructor(redisClient) {
-        super(redisClient);
-    }
-    async init(namespace = 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 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);
-    }
-}
-export { RedisSubService };

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

@@ -1,18 +0,0 @@
-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/esm/services/sub/index.js

@@ -1,6 +0,0 @@
-class SubService {
-    constructor(redisClient) {
-        this.redisClient = redisClient;
-    }
-}
-export { SubService };

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

@@ -1,18 +0,0 @@
-/// <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/esm/services/task/index.js

@@ -1,70 +0,0 @@
-import { XSleepFor, sleepFor } from '../../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 sleepFor(0);
-                this.processTimeHooks(timeEventCallback, listKey);
-            }
-            else {
-                let sleep = 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;
-        }
-    }
-}
-export { TaskService };

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

@@ -1,49 +0,0 @@
-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 };