11012795394

Committed 24 Sep 2024 11:26AM UTC coverage: 90.779% (+0.3%) from 90.503%

Build # 11012795394

Build Type

Pull #1921

github

Committed by

hectorgomezv

Commit Message

Add comment

Pull Request Pull Request #1921: Aggregate event logs for unsupported chains

Run Details

2559 of 3193 branches covered (80.14%)

Branch coverage included in aggregate %.

26 of 26 new or added lines in 3 files covered. (100.0%)

4 existing lines in 1 file now uncovered.

8329 of 8801 relevant lines covered (94.64%)

446.59 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.53

/src/datasources/cache/redis.cache.service.ts

import { Inject, Injectable, OnModuleDestroy } from '@nestjs/common';
import { RedisClientType } from '@/datasources/cache/cache.module';
import { ICacheService } from '@/datasources/cache/cache.service.interface';
import { CacheDir } from '@/datasources/cache/entities/cache-dir.entity';
import { ICacheReadiness } from '@/domain/interfaces/cache-readiness.interface';
import { ILoggingService, LoggingService } from '@/logging/logging.interface';
import { IConfigurationService } from '@/config/configuration.service.interface';
import { CacheKeyPrefix } from '@/datasources/cache/constants';

@Injectable()
export class RedisCacheService
  implements ICacheService, ICacheReadiness, OnModuleDestroy
{
  private readonly quitTimeoutInSeconds: number = 2;
  private readonly defaultExpirationTimeInSeconds: number;

  constructor(
    @Inject('RedisClient') private readonly client: RedisClientType,
    @Inject(LoggingService) private readonly loggingService: ILoggingService,
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
    @Inject(CacheKeyPrefix) private readonly keyPrefix: string,
  ) {
    this.defaultExpirationTimeInSeconds =
      this.configurationService.getOrThrow<number>(
        'expirationTimeInSeconds.default',
      );
  }

  async ping(): Promise<unknown> {
    return this.client.ping();
  }

  async getCounter(key: string): Promise<number | null> {
    const keyWithPrefix = this._prefixKey(key);
    const value = await this.client.get(keyWithPrefix);
    return value ? Number(value) : null;
  }

  async hSet(
    cacheDir: CacheDir,
    value: string,
    expireTimeSeconds: number | undefined,
  ): Promise<void> {
    if (!expireTimeSeconds || expireTimeSeconds <= 0) {
      return;
    }

    const key = this._prefixKey(cacheDir.key);

    try {
      await this.client.hSet(key, cacheDir.field, value);
      // NX - Set expiry only when the key has no expiry
      // See https://redis.io/commands/expire/
      await this.client.expire(key, expireTimeSeconds, 'NX');
    } catch (error) {
      await this.client.hDel(key, cacheDir.field);
      throw error;
    }
  }

  async hGet(cacheDir: CacheDir): Promise<string | undefined> {
    const key = this._prefixKey(cacheDir.key);
    return await this.client.hGet(key, cacheDir.field);
  }

  async deleteByKey(key: string): Promise<number> {
    const keyWithPrefix = this._prefixKey(key);
    // see https://redis.io/commands/unlink/
    const result = await this.client.unlink(keyWithPrefix);
    await this.hSet(
      new CacheDir(`invalidationTimeMs:${key}`, ''),
      Date.now().toString(),
      this.defaultExpirationTimeInSeconds,
    );
    return result;
  }

  async increment(
    cacheKey: string,
    expireTimeSeconds: number | undefined,
  ): Promise<number> {
    const transaction = this.client.multi().incr(cacheKey);
    if (expireTimeSeconds !== undefined && expireTimeSeconds > 0) {
      transaction.expire(cacheKey, expireTimeSeconds, 'NX');
    }
    const [incrRes] = await transaction.get(cacheKey).exec();
    return Number(incrRes);
  }

  async setCounter(
    key: string,
    value: number,
    expireTimeSeconds: number,
  ): Promise<void> {
    await this.client.set(key, value, { EX: expireTimeSeconds, NX: true });
  }

  /**
   * Constructs a prefixed key string.
   *
   * This function takes a key string as an input and prefixes it with `this.keyPrefix`.
   * If `this.keyPrefix` is empty, it returns the original key without any prefix.
   *
   * @param key - The original key string that needs to be prefixed.
   * @returns A string that combines `this.keyPrefix` and the original `key` with a hyphen.
   *          If `this.keyPrefix` is empty, the original `key` is returned without any modification.
   * @private
   */
  private _prefixKey(key: string): string {
    if (this.keyPrefix.length === 0) {
      return key;
    }

    return `${this.keyPrefix}-${key}`;
  }

  /**
   * Closes the connection to Redis when the module associated with this service
   * is destroyed. This tries to gracefully close the connection. If the Redis
   * instance is not responding it invokes {@link forceQuit}.
   */
  async onModuleDestroy(): Promise<void> {
    this.loggingService.info('Closing Redis connection');
    const forceQuitTimeout = setTimeout(() => {
      this.forceQuit.bind(this);
    }, this.quitTimeoutInSeconds * 1000);
    await this.client.quit();
    clearTimeout(forceQuitTimeout);
    this.loggingService.info('Redis connection closed');
  }

  /**
   * Forces the closing of the Redis connection associated with this service.
   */
  private async forceQuit(): Promise<void> {
    this.loggingService.warn('Forcing Redis connection close');
    await this.client.disconnect();
    this.loggingService.warn('Redis connection closed');
  }
}

1	import { Inject, Injectable, OnModuleDestroy } from '@nestjs/common';	106✔
2	import { RedisClientType } from '@/datasources/cache/cache.module';
3	import { ICacheService } from '@/datasources/cache/cache.service.interface';
4	import { CacheDir } from '@/datasources/cache/entities/cache-dir.entity';	106✔
5	import { ICacheReadiness } from '@/domain/interfaces/cache-readiness.interface';
6	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	106✔
7	import { IConfigurationService } from '@/config/configuration.service.interface';	106✔
8	import { CacheKeyPrefix } from '@/datasources/cache/constants';	106✔
9
10	@Injectable()
11	export class RedisCacheService	106✔
12	implements ICacheService, ICacheReadiness, OnModuleDestroy
13	{
14	private readonly quitTimeoutInSeconds: number = 2;	44✔
15	private readonly defaultExpirationTimeInSeconds: number;
16
17	constructor(
18	@Inject('RedisClient') private readonly client: RedisClientType,	44✔
19	@Inject(LoggingService) private readonly loggingService: ILoggingService,	44✔
20	@Inject(IConfigurationService)
21	private readonly configurationService: IConfigurationService,	44✔
22	@Inject(CacheKeyPrefix) private readonly keyPrefix: string,	44✔
23	) {
24	this.defaultExpirationTimeInSeconds =	44✔
25	this.configurationService.getOrThrow<number>(
26	'expirationTimeInSeconds.default',
27	);
28	}
29
30	async ping(): Promise<unknown> {
31	return this.client.ping();	2✔
32	}
33
34	async getCounter(key: string): Promise<number \| null> {
35	const keyWithPrefix = this._prefixKey(key);	4✔
36	const value = await this.client.get(keyWithPrefix);	4✔
37	return value ? Number(value) : null;	4!
38	}
39
40	async hSet(
41	cacheDir: CacheDir,
42	value: string,
43	expireTimeSeconds: number \| undefined,
44	): Promise<void> {
45	if (!expireTimeSeconds \|\| expireTimeSeconds <= 0) {	302✔
46	return;	4✔
47	}
48
49	const key = this._prefixKey(cacheDir.key);	298✔
50
51	try {	298✔
52	await this.client.hSet(key, cacheDir.field, value);	298✔
53	// NX - Set expiry only when the key has no expiry
54	// See https://redis.io/commands/expire/
55	await this.client.expire(key, expireTimeSeconds, 'NX');	298✔
56	} catch (error) {
57	await this.client.hDel(key, cacheDir.field);	2✔
58	throw error;	2✔
59	}
60	}
61
62	async hGet(cacheDir: CacheDir): Promise<string \| undefined> {
63	const key = this._prefixKey(cacheDir.key);	74✔
64	return await this.client.hGet(key, cacheDir.field);	74✔
65	}
66
67	async deleteByKey(key: string): Promise<number> {
68	const keyWithPrefix = this._prefixKey(key);	276✔
69	// see https://redis.io/commands/unlink/
70	const result = await this.client.unlink(keyWithPrefix);	276✔
71	await this.hSet(	276✔
72	new CacheDir(`invalidationTimeMs:${key}`, ''),
73	Date.now().toString(),
74	this.defaultExpirationTimeInSeconds,
75	);
76	return result;	276✔
77	}
78
79	async increment(
80	cacheKey: string,
81	expireTimeSeconds: number \| undefined,
82	): Promise<number> {
83	const transaction = this.client.multi().incr(cacheKey);	18✔
84	if (expireTimeSeconds !== undefined && expireTimeSeconds > 0) {	18✔
85	transaction.expire(cacheKey, expireTimeSeconds, 'NX');	2✔
86	}
87	const [incrRes] = await transaction.get(cacheKey).exec();	18✔
88	return Number(incrRes);	18✔
89	}
90
91	async setCounter(
92	key: string,
93	value: number,
94	expireTimeSeconds: number,
95	): Promise<void> {
96	await this.client.set(key, value, { EX: expireTimeSeconds, NX: true });	4✔
97	}
98
99	/**
100	* Constructs a prefixed key string.
101	*
102	* This function takes a key string as an input and prefixes it with `this.keyPrefix`.
103	* If `this.keyPrefix` is empty, it returns the original key without any prefix.
104	*
105	* @param key - The original key string that needs to be prefixed.
106	* @returns A string that combines `this.keyPrefix` and the original `key` with a hyphen.
107	* If `this.keyPrefix` is empty, the original `key` is returned without any modification.
108	* @private
109	*/
110	private _prefixKey(key: string): string {
111	if (this.keyPrefix.length === 0) {	652✔
112	return key;	16✔
113	}
114
115	return `${this.keyPrefix}-${key}`;	636✔
116	}
117
118	/**
119	* Closes the connection to Redis when the module associated with this service
120	* is destroyed. This tries to gracefully close the connection. If the Redis
121	* instance is not responding it invokes {@link forceQuit}.
122	*/
123	async onModuleDestroy(): Promise<void> {
124	this.loggingService.info('Closing Redis connection');	18✔
125	const forceQuitTimeout = setTimeout(() => {	18✔
UNCOV 126	this.forceQuit.bind(this);	×
127	}, this.quitTimeoutInSeconds * 1000);
128	await this.client.quit();	18✔
129	clearTimeout(forceQuitTimeout);	18✔
130	this.loggingService.info('Redis connection closed');	18✔
131	}
132
133	/**
134	* Forces the closing of the Redis connection associated with this service.
135	*/
136	private async forceQuit(): Promise<void> {
UNCOV 137	this.loggingService.warn('Forcing Redis connection close');	×
UNCOV 138	await this.client.disconnect();	×
UNCOV 139	this.loggingService.warn('Redis connection closed');	×
140	}
141	}

safe-global / safe-client-gateway / 11012795394

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous