From f908ef53894803c2bf0128a8d360b8a33cba2f97 Mon Sep 17 00:00:00 2001
From: Denis Araujo da Silva <denis.silva@vtex.com>
Date: Thu, 11 Dec 2025 14:10:36 -0300
Subject: [PATCH] Fix lint issues with tslint --fix

---
 .gitignore                                    |   1 +
 src/HttpClient/middlewares/cache.ts           |   2 +-
 .../request/HttpAgentSingleton.test.ts        |   2 +-
 src/HttpClient/typings.ts                     |   2 +-
 src/axios.d.ts                                | 216 +++++++++---------
 src/caches/MultilayeredCache.ts               |   2 +-
 src/clients/apps/MessagesGraphQL.ts           |   6 +-
 src/clients/apps/catalogGraphQL/product.ts    |   2 +-
 src/constants.test.ts                         |  18 +-
 src/constants.ts                              |   8 +-
 src/metrics/DiagnosticsMetrics.test.ts        |   8 +-
 src/metrics/DiagnosticsMetrics.ts             |   2 +-
 src/metrics/MetricsAccumulator.ts             |   2 +-
 src/responses.ts                              |   2 +-
 src/service/logger/client.ts                  |  36 +--
 src/service/logger/logger.ts                  |  48 ++--
 src/service/metrics/client.ts                 |  38 +--
 .../metrics/instruments/hostMetrics.ts        |  34 +--
 src/service/metrics/metrics.ts                |  46 ++--
 .../metrics/otelRequestMetricsMiddleware.ts   |   2 +-
 src/service/telemetry/client.ts               |  72 +++---
 src/service/worker/index.ts                   |   2 +-
 src/service/worker/runtime/events/index.ts    |   4 +-
 .../graphql/schema/messagesLoaderV2.ts        |  12 +-
 .../graphql/schema/schemaDirectives/Auth.ts   |   4 +-
 .../schema/schemaDirectives/Metric.test.ts    |  30 +--
 src/service/worker/runtime/http/index.ts      |   4 +-
 .../http/middlewares/rateLimit.test.ts        |   2 +-
 src/service/worker/runtime/method.ts          |   4 +-
 src/service/worker/runtime/typings.ts         |   4 +-
 src/service/worker/runtime/utils/compose.ts   |   4 +-
 src/utils/buildFullPath.ts                    |  12 +-
 src/utils/renameBy.ts                         |   2 +-
 src/utils/time.ts                             |   2 +-
 34 files changed, 315 insertions(+), 320 deletions(-)

diff --git a/.gitignore b/.gitignore
index 6987a533e..3d513abc9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -40,3 +40,4 @@ lib/
 
 package-lock.json
 yarn-error.log
+.cursor/
diff --git a/src/HttpClient/middlewares/cache.ts b/src/HttpClient/middlewares/cache.ts
index 673831b54..7fee31f2d 100644
--- a/src/HttpClient/middlewares/cache.ts
+++ b/src/HttpClient/middlewares/cache.ts
@@ -155,7 +155,7 @@ export const cacheMiddleware = ({ type, storage, asyncSet }: CacheOptions) => {
       if (cachedEtag && validateStatus(response.status as number)) {
         ctx.config.headers = {
           ...ctx.config.headers,
-          'if-none-match': cachedEtag
+          'if-none-match': cachedEtag,
         }
         ctx.config.validateStatus = validateStatus
       }
diff --git a/src/HttpClient/middlewares/request/HttpAgentSingleton.test.ts b/src/HttpClient/middlewares/request/HttpAgentSingleton.test.ts
index 172a26aad..b044bb909 100644
--- a/src/HttpClient/middlewares/request/HttpAgentSingleton.test.ts
+++ b/src/HttpClient/middlewares/request/HttpAgentSingleton.test.ts
@@ -10,7 +10,7 @@ jest.mock('../../../HttpClient/agents', () => ({
 }))
 
 describe('HttpAgentSingleton', () => {
-  let recordedGaugeCalls: Map<string, Array<{ value: number; attributes?: any }>>
+  let recordedGaugeCalls: Map<string, { value: number; attributes?: any }[]>
 
   beforeEach(() => {
     // Reset call tracking
diff --git a/src/HttpClient/typings.ts b/src/HttpClient/typings.ts
index 275452203..7cf2d3ef2 100644
--- a/src/HttpClient/typings.ts
+++ b/src/HttpClient/typings.ts
@@ -123,7 +123,7 @@ export interface InstanceOptions {
    * @memberof InstanceOptions
    */
   params?: Record<string, string>
-  middlewares?: Array<Middleware<MiddlewareContext>>
+  middlewares?: Middleware<MiddlewareContext>[]
   verbose?: boolean
   name?: string
   serverTimings?: Record<string, string>
diff --git a/src/axios.d.ts b/src/axios.d.ts
index fc1a9a18c..cb5539cf8 100644
--- a/src/axios.d.ts
+++ b/src/axios.d.ts
@@ -1,27 +1,23 @@
 declare module 'axios/index' {}
 
 declare module 'axios' {
-  export interface AxiosTransformer {
-    (data: any, headers?: any): any;
-  }
+  export type AxiosTransformer = (data: any, headers?: any) => any
 
-  export interface AxiosAdapter {
-    (config: AxiosRequestConfig): AxiosPromise<any>;
-  }
+  export type AxiosAdapter = (config: AxiosRequestConfig) => AxiosPromise<any>
 
   export interface AxiosBasicCredentials {
-    username: string;
-    password: string;
+    username: string
+    password: string
   }
 
   export interface AxiosProxyConfig {
-    host: string;
-    port: number;
+    host: string
+    port: number
     auth?: {
       username: string;
       password: string;
-    };
-    protocol?: string;
+    }
+    protocol?: string
   }
 
   export type Method =
@@ -33,7 +29,7 @@ declare module 'axios' {
     | 'put' | 'PUT'
     | 'patch' | 'PATCH'
     | 'link' | 'LINK'
-    | 'unlink' | 'UNLINK';
+    | 'unlink' | 'UNLINK'
 
   export type ResponseType =
     | 'arraybuffer'
@@ -41,79 +37,79 @@ declare module 'axios' {
     | 'document'
     | 'json'
     | 'text'
-    | 'stream';
+    | 'stream'
 
   // Tipos de cabeçalho
-  export type RawAxiosRequestHeaders = Record<string, any>;
-  export type RawAxiosResponseHeaders = Record<string, any>;
+  export type RawAxiosRequestHeaders = Record<string, any>
+  export type RawAxiosResponseHeaders = Record<string, any>
   export interface AxiosHeaders extends Record<string, any> {
-    set(headerName: string, value: string): AxiosHeaders;
-    get(headerName: string): string | undefined;
-    delete(headerName: string): boolean;
-    clear(): AxiosHeaders;
-    toJSON(): Record<string, any>;
-    [key: string]: any;
+    set(headerName: string, value: string): AxiosHeaders
+    get(headerName: string): string | undefined
+    delete(headerName: string): boolean
+    clear(): AxiosHeaders
+    toJSON(): Record<string, any>
+    [key: string]: any
   }
 
   export interface AxiosRequestConfig {
-    url?: string;
-    method?: Method;
-    baseURL?: string;
-    transformRequest?: AxiosTransformer | AxiosTransformer[];
-    transformResponse?: AxiosTransformer | AxiosTransformer[];
-    headers?: RawAxiosRequestHeaders;
-    params?: any;
-    paramsSerializer?: (params: any) => string;
-    data?: any;
-    timeout?: number;
-    timeoutErrorMessage?: string;
-    withCredentials?: boolean;
-    adapter?: AxiosAdapter;
-    auth?: AxiosBasicCredentials;
-    responseType?: ResponseType;
-    responseEncoding?: string;
-    xsrfCookieName?: string;
-    xsrfHeaderName?: string;
-    onUploadProgress?: (progressEvent: any) => void;
-    onDownloadProgress?: (progressEvent: any) => void;
-    maxContentLength?: number;
-    maxBodyLength?: number;
-    validateStatus?: (status: number) => boolean;
-    maxRedirects?: number;
-    socketPath?: string | null;
-    httpAgent?: any;
-    httpsAgent?: any;
-    proxy?: AxiosProxyConfig | false;
-    cancelToken?: CancelToken;
-    decompress?: boolean;
-    transitional?: any;
-    signal?: any;
-    insecureHTTPParser?: boolean;
-    [key: string]: any; // Para permitir qualquer propriedade adicional
+    url?: string
+    method?: Method
+    baseURL?: string
+    transformRequest?: AxiosTransformer | AxiosTransformer[]
+    transformResponse?: AxiosTransformer | AxiosTransformer[]
+    headers?: RawAxiosRequestHeaders
+    params?: any
+    paramsSerializer?: (params: any) => string
+    data?: any
+    timeout?: number
+    timeoutErrorMessage?: string
+    withCredentials?: boolean
+    adapter?: AxiosAdapter
+    auth?: AxiosBasicCredentials
+    responseType?: ResponseType
+    responseEncoding?: string
+    xsrfCookieName?: string
+    xsrfHeaderName?: string
+    onUploadProgress?: (progressEvent: any) => void
+    onDownloadProgress?: (progressEvent: any) => void
+    maxContentLength?: number
+    maxBodyLength?: number
+    validateStatus?: (status: number) => boolean
+    maxRedirects?: number
+    socketPath?: string | null
+    httpAgent?: any
+    httpsAgent?: any
+    proxy?: AxiosProxyConfig | false
+    cancelToken?: CancelToken
+    decompress?: boolean
+    transitional?: any
+    signal?: any
+    insecureHTTPParser?: boolean
+    [key: string]: any // Para permitir qualquer propriedade adicional
   }
 
   export interface InternalAxiosRequestConfig extends AxiosRequestConfig {
-    headers: AxiosHeaders | RawAxiosRequestHeaders;
-    [key: string]: any; // Para permitir propriedades adicionais como 'tracing'
+    headers: AxiosHeaders | RawAxiosRequestHeaders
+    [key: string]: any // Para permitir propriedades adicionais como 'tracing'
   }
 
   export interface AxiosResponse<T = any> {
-    data: T;
-    status: number;
-    statusText: string;
-    headers: RawAxiosResponseHeaders;
-    config: AxiosRequestConfig;
-    request?: any;
+    data: T
+    status: number
+    statusText: string
+    headers: RawAxiosResponseHeaders
+    config: AxiosRequestConfig
+    request?: any
   }
 
   // Define AxiosError como uma classe para fazer instanceof funcionar
   export class AxiosError<T = any> extends Error {
-    config: AxiosRequestConfig;
-    code?: string;
-    request?: any;
-    response?: AxiosResponse<T>;
-    isAxiosError: boolean;
-    status?: number;
+    config: AxiosRequestConfig
+    code?: string
+    request?: any
+    response?: AxiosResponse<T>
+    isAxiosError: boolean
+    status?: number
 
     constructor(
       message?: string,
@@ -123,7 +119,7 @@ declare module 'axios' {
       response?: AxiosResponse<T>
     );
 
-    toJSON(): object;
+    toJSON(): object
 
     // Métodos estáticos para criar instâncias de AxiosError
     static from<T = any>(
@@ -133,76 +129,72 @@ declare module 'axios' {
       request?: any,
       response?: AxiosResponse<T>,
       customProps?: Record<string, any>
-    ): AxiosError<T>;
+    ): AxiosError<T>
   }
 
   export interface AxiosPromise<T = any> extends Promise<AxiosResponse<T>> {
   }
 
-  export interface CancelStatic {
-    new (message?: string): Cancel;
-  }
+  export type CancelStatic = new (message?: string) => Cancel
 
   export interface Cancel {
-    message: string;
+    message: string
   }
 
-  export interface Canceler {
-    (message?: string): void;
-  }
+  export type Canceler = (message?: string) => void
 
   export interface CancelTokenStatic {
-    new (executor: (cancel: Canceler) => void): CancelToken;
-    source(): CancelTokenSource;
+    new (executor: (cancel: Canceler) => void): CancelToken
+    source(): CancelTokenSource
   }
 
   export interface CancelToken {
-    promise: Promise<Cancel>;
-    reason?: Cancel;
-    throwIfRequested(): void;
+    promise: Promise<Cancel>
+    reason?: Cancel
+    throwIfRequested(): void
   }
 
   export interface CancelTokenSource {
-    token: CancelToken;
-    cancel: Canceler;
+    token: CancelToken
+    cancel: Canceler
   }
 
   export interface AxiosInterceptorManager<V> {
-    use(onFulfilled?: (value: V) => V | Promise<V>, onRejected?: (error: any) => any): number;
-    eject(id: number): void;
-    clear(): void;
+    use(onFulfilled?: (value: V) => V | Promise<V>, onRejected?: (error: any) => any): number
+    eject(id: number): void
+    clear(): void
   }
 
   export interface AxiosInstance {
-    (config: AxiosRequestConfig): AxiosPromise;
-    (url: string, config?: AxiosRequestConfig): AxiosPromise;
-    defaults: AxiosRequestConfig;
+    (config: AxiosRequestConfig): AxiosPromise
+    (url: string, config?: AxiosRequestConfig): AxiosPromise
+    defaults: AxiosRequestConfig
     interceptors: {
       request: AxiosInterceptorManager<AxiosRequestConfig>;
       response: AxiosInterceptorManager<AxiosResponse>;
-    };
-    getUri(config?: AxiosRequestConfig): string;
-    request<T = any, R = AxiosResponse<T>>(config: AxiosRequestConfig): Promise<R>;
-    get<T = any, R = AxiosResponse<T>>(url: string, config?: AxiosRequestConfig): Promise<R>;
-    delete<T = any, R = AxiosResponse<T>>(url: string, config?: AxiosRequestConfig): Promise<R>;
-    head<T = any, R = AxiosResponse<T>>(url: string, config?: AxiosRequestConfig): Promise<R>;
-    options<T = any, R = AxiosResponse<T>>(url: string, config?: AxiosRequestConfig): Promise<R>;
-    post<T = any, R = AxiosResponse<T>>(url: string, data?: any, config?: AxiosRequestConfig): Promise<R>;
-    put<T = any, R = AxiosResponse<T>>(url: string, data?: any, config?: AxiosRequestConfig): Promise<R>;
-    patch<T = any, R = AxiosResponse<T>>(url: string, data?: any, config?: AxiosRequestConfig): Promise<R>;
+    }
+    getUri(config?: AxiosRequestConfig): string
+    request<T = any, R = AxiosResponse<T>>(config: AxiosRequestConfig): Promise<R>
+    get<T = any, R = AxiosResponse<T>>(url: string, config?: AxiosRequestConfig): Promise<R>
+    delete<T = any, R = AxiosResponse<T>>(url: string, config?: AxiosRequestConfig): Promise<R>
+    head<T = any, R = AxiosResponse<T>>(url: string, config?: AxiosRequestConfig): Promise<R>
+    options<T = any, R = AxiosResponse<T>>(url: string, config?: AxiosRequestConfig): Promise<R>
+    post<T = any, R = AxiosResponse<T>>(url: string, data?: any, config?: AxiosRequestConfig): Promise<R>
+    put<T = any, R = AxiosResponse<T>>(url: string, data?: any, config?: AxiosRequestConfig): Promise<R>
+    patch<T = any, R = AxiosResponse<T>>(url: string, data?: any, config?: AxiosRequestConfig): Promise<R>
   }
 
   export interface AxiosStatic extends AxiosInstance {
-    create(config?: AxiosRequestConfig): AxiosInstance;
-    Cancel: CancelStatic;
-    CancelToken: CancelTokenStatic;
-    isCancel(value: any): boolean;
-    all<T>(values: (T | Promise<T>)[]): Promise<T[]>;
-    spread<T, R>(callback: (...args: T[]) => R): (array: T[]) => R;
-    isAxiosError(payload: any): payload is AxiosError;
+    create(config?: AxiosRequestConfig): AxiosInstance
+    Cancel: CancelStatic
+    CancelToken: CancelTokenStatic
+    isCancel(value: any): boolean
+    all<T>(values: (T | Promise<T>)[]): Promise<T[]>
+    spread<T, R>(callback: (...args: T[]) => R): (array: T[]) => R
+    isAxiosError(payload: any): payload is AxiosError
   }
 
-  const axios: AxiosStatic;
+  const axios: AxiosStatic
 
   export const AxiosError: {
     new <T = any>(
@@ -231,7 +223,7 @@ declare module 'axios' {
       response?: AxiosResponse<T>,
       customProps?: Record<string, any>
     ): AxiosError<T>;
-  };
+  }
 
-  export default axios;
+  export default axios
 }
diff --git a/src/caches/MultilayeredCache.ts b/src/caches/MultilayeredCache.ts
index 9ec1337cd..075b82d41 100644
--- a/src/caches/MultilayeredCache.ts
+++ b/src/caches/MultilayeredCache.ts
@@ -7,7 +7,7 @@ export class MultilayeredCache <K, V> implements CacheLayer<K, V>{
   private hits = 0
   private total = 0
 
-  constructor (private caches: Array<CacheLayer<K, V>>) {}
+  constructor (private caches: CacheLayer<K, V>[]) {}
 
   public get = async (key: K, fetcher?: () => Promise<FetchResult<V>>): Promise<V | void> => {
     let value: V | void = undefined
diff --git a/src/clients/apps/MessagesGraphQL.ts b/src/clients/apps/MessagesGraphQL.ts
index 630305188..df29a1867 100644
--- a/src/clients/apps/MessagesGraphQL.ts
+++ b/src/clients/apps/MessagesGraphQL.ts
@@ -5,7 +5,7 @@ import { IOContext } from '../../service/worker/runtime/typings'
 import { AppGraphQLClient } from './AppGraphQLClient'
 
 export interface IndexedByFrom {
-  messages: Array<Omit<Message, 'from'>>
+  messages: Omit<Message, 'from'>[]
   from: string
 }
 
@@ -82,9 +82,9 @@ export class MessagesGraphQL extends AppGraphQLClient {
   public translateV2 (args: TranslateInput, tracingConfig?: RequestTracingConfig) {
     const { indexedByFrom, ...rest } = args
 
-    const allMessages: Array<{from: string, message: Omit<Message, 'from'>}> = indexedByFrom.reduce((acc, {from, messages}) => {
+    const allMessages: {from: string, message: Omit<Message, 'from'>}[] = indexedByFrom.reduce((acc, {from, messages}) => {
       return acc.concat(messages.map(message => ({from, message})))
-    }, [] as Array<{from: string, message: Omit<Message, 'from'>}>)
+    }, [] as {from: string, message: Omit<Message, 'from'>}[])
 
     const batchedMessages = splitEvery(MAX_BATCH_SIZE, allMessages)
     const metric = 'messages-translate-v2'
diff --git a/src/clients/apps/catalogGraphQL/product.ts b/src/clients/apps/catalogGraphQL/product.ts
index dd81a53de..850ebaaa8 100644
--- a/src/clients/apps/catalogGraphQL/product.ts
+++ b/src/clients/apps/catalogGraphQL/product.ts
@@ -47,5 +47,5 @@ export interface Product {
   supplierId?: string
   showWithoutStock: boolean
   score?: number
-  salesChannel?: Array<{ id: string }>
+  salesChannel?: { id: string }[]
 }
diff --git a/src/constants.test.ts b/src/constants.test.ts
index c4bc3096c..b036f71b2 100644
--- a/src/constants.test.ts
+++ b/src/constants.test.ts
@@ -278,7 +278,7 @@ describe('constants', () => {
         { vendor: 'vtex', expected: false },
         { vendor: 'gocommerce', expected: false },
         { vendor: 'other', expected: true },
-        { vendor: undefined, expected: true }
+        { vendor: undefined, expected: true },
       ]
 
       testCases.forEach(({ vendor, expected }) => {
@@ -286,7 +286,7 @@ describe('constants', () => {
           VENDOR: vendor,
           IS_THIRD_PARTY() {
             return 'vtex' !== this.VENDOR && 'gocommerce' !== this.VENDOR
-          }
+          },
         }
         expect(mockApp.IS_THIRD_PARTY()).toBe(expected)
       })
@@ -371,7 +371,7 @@ describe('constants', () => {
         PRODUCTION,
         INSPECT_DEBUGGER_PORT,
         cancellableMethods,
-        LOG_CLIENT_INIT_TIMEOUT_MS
+        LOG_CLIENT_INIT_TIMEOUT_MS,
       }
 
       // Environment-based constants that can be undefined in test environment
@@ -439,7 +439,7 @@ describe('constants', () => {
       const requiredAttributes = [
         'VTEX_ACCOUNT_NAME',
         'VTEX_IO_WORKSPACE_NAME', 'VTEX_IO_WORKSPACE_TYPE',
-        'VTEX_IO_APP_ID', 'VTEX_IO_APP_AUTHOR_TYPE'
+        'VTEX_IO_APP_ID', 'VTEX_IO_APP_AUTHOR_TYPE',
       ]
 
       requiredAttributes.forEach(attr => {
@@ -545,7 +545,7 @@ describe('constants', () => {
           [SEGMENT_HEADER]: 'segment-token',
           [SESSION_HEADER]: 'session-token',
           [ACCOUNT_HEADER]: 'account-name',
-          [WORKSPACE_HEADER]: 'master'
+          [WORKSPACE_HEADER]: 'master',
         }
 
         expect(headers['x-vtex-tenant']).toBe('example-value')
@@ -568,7 +568,7 @@ describe('constants', () => {
           TENANT_HEADER: tenant,
           BINDING_HEADER: binding,
           LOCALE_HEADER: locale,
-          SEGMENT_HEADER: segment
+          SEGMENT_HEADER: segment,
         } = constants
 
         expect(tenant).toBeDefined()
@@ -602,7 +602,7 @@ describe('constants', () => {
           HeaderKeys.SEGMENT,
           HeaderKeys.SESSION,
           HeaderKeys.PRODUCT,
-          HeaderKeys.LOCALE
+          HeaderKeys.LOCALE,
         ]
 
         expect(varyHeaderValues).toEqual(expectedVaryHeaders)
@@ -629,7 +629,7 @@ describe('constants', () => {
           [SEGMENT_HEADER]: mockSegmentToken,
           [SESSION_HEADER]: mockSessionToken,
           [ACCOUNT_HEADER]: 'vtexstore',
-          [WORKSPACE_HEADER]: 'master'
+          [WORKSPACE_HEADER]: 'master',
         }
 
         expect(requestHeaders['x-vtex-binding']).toBe(JSON.stringify(mockBinding))
@@ -655,7 +655,7 @@ describe('constants', () => {
         const incomingHeaders: Record<string, string> = {
           'x-vtex-tenant': 'es-AR',
           'x-vtex-binding': '{"locale":"es-AR"}',
-          'x-vtex-account': 'mystore'
+          'x-vtex-account': 'mystore',
         }
 
         expect(incomingHeaders[TENANT_HEADER]).toBe('es-AR')
diff --git a/src/constants.ts b/src/constants.ts
index 6cdb680fd..67f238b76 100644
--- a/src/constants.ts
+++ b/src/constants.ts
@@ -50,7 +50,7 @@ export const HeaderKeys = {
   VTEX_IO_CALLER: 'x-vtex-io-caller',
   VTEX_APP_SERVICE: 'x-vtex-app-service',
   VTEX_APP_KEY: 'x-vtex-app-key',
-  VTEX_RETRY_COUNT: 'x-vtex-retry-count'
+  VTEX_RETRY_COUNT: 'x-vtex-retry-count',
 }
 
 export const AttributeKeys = {
@@ -188,8 +188,8 @@ export const cancellableMethods = new Set(['GET', 'OPTIONS', 'HEAD'])
 export const LOG_CLIENT_INIT_TIMEOUT_MS = 5000
 export const METRIC_CLIENT_INIT_TIMEOUT_MS = 5000
 
-export const OTEL_EXPORTER_OTLP_ENDPOINT = process.env.OTEL_EXPORTER_OTLP_ENDPOINT as string;
+export const OTEL_EXPORTER_OTLP_ENDPOINT = process.env.OTEL_EXPORTER_OTLP_ENDPOINT as string
 
-export const DK_APP_ID = process.env.NODE_VTEX_API_DK_APP_ID as string || "apps-team";
+export const DK_APP_ID = process.env.NODE_VTEX_API_DK_APP_ID as string || 'apps-team'
 
-export const DIAGNOSTICS_TELEMETRY_ENABLED = process.env.VTEX_DIAGNOSTICS_TELEMETRY_ENABLED === 'true';
\ No newline at end of file
+export const DIAGNOSTICS_TELEMETRY_ENABLED = process.env.VTEX_DIAGNOSTICS_TELEMETRY_ENABLED === 'true'
\ No newline at end of file
diff --git a/src/metrics/DiagnosticsMetrics.test.ts b/src/metrics/DiagnosticsMetrics.test.ts
index 90fc8f5f8..9020d3eb5 100644
--- a/src/metrics/DiagnosticsMetrics.test.ts
+++ b/src/metrics/DiagnosticsMetrics.test.ts
@@ -17,9 +17,9 @@ import { getMetricClient } from '../service/metrics/client'
 describe('DiagnosticsMetrics', () => {
   let diagnosticsMetrics: DiagnosticsMetrics
   let mockMetricsClient: Types.MetricClient
-  let recordedHistogramCalls: Array<{ value: number; attributes?: any }>
-  let recordedCounterCalls: Map<string, Array<{ value: number; attributes?: any }>>
-  let recordedGaugeCalls: Map<string, Array<{ value: number; attributes?: any }>>
+  let recordedHistogramCalls: { value: number; attributes?: any }[]
+  let recordedCounterCalls: Map<string, { value: number; attributes?: any }[]>
+  let recordedGaugeCalls: Map<string, { value: number; attributes?: any }[]>
 
   beforeEach(() => {
     // Reset call tracking
@@ -102,7 +102,7 @@ describe('DiagnosticsMetrics', () => {
      *   - Instance was created successfully (no exception thrown)
      *   - Error was logged to console (operational visibility)
      *   - metricsClient remains undefined (all record methods will no-op)
-     * */
+     */
     it('should handle initialization errors gracefully', async () => {
       
       // Mock the getMetricClient (which is a Jest mock) to return an error
diff --git a/src/metrics/DiagnosticsMetrics.ts b/src/metrics/DiagnosticsMetrics.ts
index 35d09c217..0ba65a7b2 100644
--- a/src/metrics/DiagnosticsMetrics.ts
+++ b/src/metrics/DiagnosticsMetrics.ts
@@ -103,7 +103,7 @@ export class DiagnosticsMetrics {
 
         this.metricsClient = await Promise.race([
           getMetricClient(),
-          timeoutPromise
+          timeoutPromise,
         ])
 
         // Create the single latency histogram after client is ready
diff --git a/src/metrics/MetricsAccumulator.ts b/src/metrics/MetricsAccumulator.ts
index 9d42bb358..8fd5acd60 100644
--- a/src/metrics/MetricsAccumulator.ts
+++ b/src/metrics/MetricsAccumulator.ts
@@ -58,7 +58,7 @@ export class MetricsAccumulator {
   // Tracked cache instances
   private cacheMap: Record<string, GetStats>
 
-  private onFlushMetrics: Array<() => Metric | Metric[]>
+  private onFlushMetrics: (() => Metric | Metric[])[]
 
   constructor() {
     this.metricsMillis = {}
diff --git a/src/responses.ts b/src/responses.ts
index d1f235cf8..67bca3c63 100644
--- a/src/responses.ts
+++ b/src/responses.ts
@@ -72,7 +72,7 @@ export interface HouseKeeperState {
   infra: string[]
   edition: string[]
  runtimes: string[]
-  apps: Array<{id: string, source: string}>
+  apps: {id: string, source: string}[]
 }
 
 export interface HouseKeeperUpdates extends HouseKeeperState {
diff --git a/src/service/logger/client.ts b/src/service/logger/client.ts
index c307d89b7..1f1cf5a21 100644
--- a/src/service/logger/client.ts
+++ b/src/service/logger/client.ts
@@ -1,37 +1,37 @@
-import { Types } from '@vtex/diagnostics-nodejs';
-import { initializeTelemetry } from '../telemetry';
+import { Types } from '@vtex/diagnostics-nodejs'
+import { initializeTelemetry } from '../telemetry'
 
-let client: Types.LogClient | undefined;
-let isInitializing = false;
-let initPromise: Promise<Types.LogClient> | undefined = undefined;
+let client: Types.LogClient | undefined
+let isInitializing = false
+let initPromise: Promise<Types.LogClient> | undefined = undefined
 
 export async function getLogClient(): Promise<Types.LogClient> {
 
   if (client) {
-    return client;
+    return client
   }
 
   if (initPromise) {
-    return initPromise;
+    return initPromise
   }
 
-  isInitializing = true;
-  initPromise = initializeClient();
+  isInitializing = true
+  initPromise = initializeClient()
 
-  return initPromise;
+  return initPromise
 }
 
 async function initializeClient(): Promise<Types.LogClient> {
   try {
-    const { logsClient } = await initializeTelemetry();
-    client = logsClient;
-    initPromise = undefined;
-    return logsClient;
+    const { logsClient } = await initializeTelemetry()
+    client = logsClient
+    initPromise = undefined
+    return logsClient
   } catch (error) {
-    console.error('Failed to initialize logs client:', error);
-    initPromise = undefined;
-    throw error;
+    console.error('Failed to initialize logs client:', error)
+    initPromise = undefined
+    throw error
   } finally {
-    isInitializing = false;
+    isInitializing = false
   }
 }
diff --git a/src/service/logger/logger.ts b/src/service/logger/logger.ts
index d4f45f9da..802d524c9 100644
--- a/src/service/logger/logger.ts
+++ b/src/service/logger/logger.ts
@@ -1,7 +1,7 @@
 import { APP, LOG_CLIENT_INIT_TIMEOUT_MS, AttributeKeys } from '../../constants'
 import { cleanError } from '../../utils/error'
 import { cleanLog } from '../../utils/log'
-import { Types } from '@vtex/diagnostics-nodejs';
+import { Types } from '@vtex/diagnostics-nodejs'
 import { LoggerContext, LogLevel, TracingState } from './loggerTypes'
 import { getLogClient } from './client'
 
@@ -32,33 +32,33 @@ export class Logger {
       }
     }
 
-    this.initLogClient();
+    this.initLogClient()
   }
 
   private initLogClient(): Promise<Types.LogClient | undefined> {
     if (this.clientInitPromise) {
-      return this.clientInitPromise;
+      return this.clientInitPromise
     }
 
     this.clientInitPromise = (async () => {
       try {
         const timeoutPromise = new Promise<never>((_, reject) => {
-          setTimeout(() => reject(new Error('Log client initialization timeout')), LOG_CLIENT_INIT_TIMEOUT_MS);
-        });
+          setTimeout(() => reject(new Error('Log client initialization timeout')), LOG_CLIENT_INIT_TIMEOUT_MS)
+        })
 
         this.logClient = await Promise.race([
           getLogClient(),
-          timeoutPromise
-        ]);
+          timeoutPromise,
+        ])
 
-        return this.logClient;
+        return this.logClient
       } catch (error) {
-        console.error('Failed to initialize log client:', error);
-        return undefined;
+        console.error('Failed to initialize log client:', error)
+        return undefined
       }
-    })();
+    })()
 
-    return this.clientInitPromise;
+    return this.clientInitPromise
   }
 
   public debug = (message: any) =>
@@ -101,7 +101,7 @@ export class Logger {
       Object.assign(inflatedLog, {
         '__SKIDDER_TOPIC_1': `skidder.vendor.${APP.VENDOR}`,
         '__SKIDDER_TOPIC_2': `skidder.app.${APP.VENDOR}.${APP.NAME}`,
-      });
+      })
     }
 
     console.log(JSON.stringify(inflatedLog))
@@ -117,25 +117,25 @@ export class Logger {
 
     if (this.logClient) {
       try {
-        let logMessage = typeof data === 'string' ? data : JSON.stringify(data)
+        const logMessage = typeof data === 'string' ? data : JSON.stringify(data)
         switch (level) {
           case LogLevel.Debug:
-            this.logClient.debug(logMessage, diagnosticsLog);
-            break;
+            this.logClient.debug(logMessage, diagnosticsLog)
+            break
           case LogLevel.Info:
-            this.logClient.info(logMessage, diagnosticsLog);
-            break;
+            this.logClient.info(logMessage, diagnosticsLog)
+            break
           case LogLevel.Warn:
-            this.logClient.warn(logMessage, diagnosticsLog);
-            break;
+            this.logClient.warn(logMessage, diagnosticsLog)
+            break
           case LogLevel.Error:
-            this.logClient.error(logMessage, diagnosticsLog);
-            break;
+            this.logClient.error(logMessage, diagnosticsLog)
+            break
           default:
-            this.logClient.info(logMessage, diagnosticsLog);
+            this.logClient.info(logMessage, diagnosticsLog)
         }
       } catch (e) {
-        console.error('Error using diagnostics client for logging:', e);
+        console.error('Error using diagnostics client for logging:', e)
       }
     }
 
diff --git a/src/service/metrics/client.ts b/src/service/metrics/client.ts
index eaabd27dc..475134eec 100644
--- a/src/service/metrics/client.ts
+++ b/src/service/metrics/client.ts
@@ -1,46 +1,46 @@
-import { Types } from "@vtex/diagnostics-nodejs";
-import { initializeTelemetry } from '../telemetry';
+import { Types } from '@vtex/diagnostics-nodejs'
+import { initializeTelemetry } from '../telemetry'
 
 class MetricClientSingleton {
-  private static instance: MetricClientSingleton | undefined;
-  private client: Types.MetricClient | undefined;
-  private initPromise: Promise<Types.MetricClient> | undefined;
+  private static instance: MetricClientSingleton | undefined
+  private client: Types.MetricClient | undefined
+  private initPromise: Promise<Types.MetricClient> | undefined
 
   private constructor() {}
 
   public static getInstance(): MetricClientSingleton {
     if (!MetricClientSingleton.instance) {
-      MetricClientSingleton.instance = new MetricClientSingleton();
+      MetricClientSingleton.instance = new MetricClientSingleton()
     }
-    return MetricClientSingleton.instance;
+    return MetricClientSingleton.instance
   }
 
   public async getClient(): Promise<Types.MetricClient> {
     if (this.client) {
-      return this.client;
+      return this.client
     }
 
     if (this.initPromise) {
-      return this.initPromise;
+      return this.initPromise
     }
 
-    this.initPromise = this.initializeClient();
+    this.initPromise = this.initializeClient()
 
-    return this.initPromise;
+    return this.initPromise
   }
 
   private async initializeClient(): Promise<Types.MetricClient> {
     try {
-      const { metricsClient } = await initializeTelemetry();
-      this.client = metricsClient;
-      this.initPromise = undefined;
-      return metricsClient;
+      const { metricsClient } = await initializeTelemetry()
+      this.client = metricsClient
+      this.initPromise = undefined
+      return metricsClient
     } catch (error) {
-      console.error('Failed to initialize metrics client:', error);
-      this.initPromise = undefined;
-      throw error;
+      console.error('Failed to initialize metrics client:', error)
+      this.initPromise = undefined
+      throw error
     }
   }
 }
 
-export const getMetricClient = () => MetricClientSingleton.getInstance().getClient();
+export const getMetricClient = () => MetricClientSingleton.getInstance().getClient()
diff --git a/src/service/metrics/instruments/hostMetrics.ts b/src/service/metrics/instruments/hostMetrics.ts
index 0851c1096..18f19860d 100644
--- a/src/service/metrics/instruments/hostMetrics.ts
+++ b/src/service/metrics/instruments/hostMetrics.ts
@@ -1,41 +1,43 @@
-import { InstrumentationBase, InstrumentationConfig } from "@opentelemetry/instrumentation";
-import { MeterProvider } from '@opentelemetry/api';
-import { HostMetrics } from "@opentelemetry/host-metrics";
+import { InstrumentationBase, InstrumentationConfig } from '@opentelemetry/instrumentation'
+import { MeterProvider } from '@opentelemetry/api'
+import { HostMetrics } from '@opentelemetry/host-metrics'
 
 interface HostMetricsInstrumentationConfig extends InstrumentationConfig {
-  name?: string;
-  meterProvider?: MeterProvider;
+  name?: string
+  meterProvider?: MeterProvider
 }
 
 export class HostMetricsInstrumentation extends InstrumentationBase<HostMetricsInstrumentationConfig> {
-  private hostMetrics?: HostMetrics;
+  private hostMetrics?: HostMetrics
 
   constructor(config: HostMetricsInstrumentationConfig = {}) {
-    const instrumentation_name = config.name || 'host-metrics-instrumentation';
-    const instrumentation_version = '1.0.0';
-    super(instrumentation_name, instrumentation_version, config);
+    const instrumentationName = config.name || 'host-metrics-instrumentation'
+    const instrumentationVersion = '1.0.0'
+    super(instrumentationName, instrumentationVersion, config)
   }
 
-  init(): void {}
+  init(): void {
+    // No initialization needed for this instrumentation
+  }
 
   enable(): void {
     if (!this._config.meterProvider) {
-      throw new Error('MeterProvider is required for HostMetricsInstrumentation');
+      throw new Error('MeterProvider is required for HostMetricsInstrumentation')
     }
 
     this.hostMetrics = new HostMetrics({
       meterProvider: this._config.meterProvider,
       name: this._config.name || 'host-metrics',
-    });
+    })
 
-    this.hostMetrics.start();
-    console.debug('HostMetricsInstrumentation enabled');
+    this.hostMetrics.start()
+    console.debug('HostMetricsInstrumentation enabled')
   }
 
   disable(): void {
     if (this.hostMetrics) {
-      this.hostMetrics = undefined;
-      console.debug('HostMetricsInstrumentation disabled');
+      this.hostMetrics = undefined
+      console.debug('HostMetricsInstrumentation disabled')
     }
   }
 }
diff --git a/src/service/metrics/metrics.ts b/src/service/metrics/metrics.ts
index b5b5fbc7d..bcdc35ce0 100644
--- a/src/service/metrics/metrics.ts
+++ b/src/service/metrics/metrics.ts
@@ -18,7 +18,7 @@ const createOtelConcurrentRequestsInstrument = async (): Promise<Types.Gauge> =>
   const metricsClient = await getMetricClient()
   return metricsClient.createGauge('io_http_requests_current', {
     description: 'The current number of requests in course.',
-    unit: '1'
+    unit: '1',
   })
 }
 
@@ -26,7 +26,7 @@ const createOtelRequestsTimingsInstrument = async (): Promise<Types.Histogram> =
   const metricsClient = await getMetricClient()
   return metricsClient.createHistogram('runtime_http_requests_duration_milliseconds', {
     description: 'The incoming http requests total duration.',
-    unit: 'ms'
+    unit: 'ms',
   })
 }
 
@@ -34,7 +34,7 @@ const createOtelTotalRequestsInstrument = async (): Promise<Types.Counter> => {
   const metricsClient = await getMetricClient()
   return metricsClient.createCounter('runtime_http_requests_total', {
     description: 'The total number of HTTP requests.',
-    unit: '1'
+    unit: '1',
   })
 }
 
@@ -42,7 +42,7 @@ const createOtelRequestsResponseSizesInstrument = async (): Promise<Types.Histog
   const metricsClient = await getMetricClient()
   return metricsClient.createHistogram('runtime_http_response_size_bytes', {
     description: 'The outgoing response sizes (only applicable when the response isn\'t a stream).',
-    unit: 'bytes'
+    unit: 'bytes',
   })
 }
 
@@ -50,44 +50,44 @@ const createOtelTotalAbortedRequestsInstrument = async (): Promise<Types.Counter
   const metricsClient = await getMetricClient()
   return metricsClient.createCounter('runtime_http_aborted_requests_total', {
     description: 'The total number of HTTP requests aborted.',
-    unit: '1'
+    unit: '1',
   })
 }
 
 class OtelInstrumentsSingleton {
-  private static instance: OtelInstrumentsSingleton | undefined;
-  private instruments: OtelRequestInstruments | undefined;
-  private initializingPromise: Promise<OtelRequestInstruments> | undefined;
+  private static instance: OtelInstrumentsSingleton | undefined
+  private instruments: OtelRequestInstruments | undefined
+  private initializingPromise: Promise<OtelRequestInstruments> | undefined
 
   private constructor() {}
 
   public static getInstance(): OtelInstrumentsSingleton {
     if (!OtelInstrumentsSingleton.instance) {
-      OtelInstrumentsSingleton.instance = new OtelInstrumentsSingleton();
+      OtelInstrumentsSingleton.instance = new OtelInstrumentsSingleton()
     }
-    return OtelInstrumentsSingleton.instance;
+    return OtelInstrumentsSingleton.instance
   }
 
   public async getInstruments(): Promise<OtelRequestInstruments> {
     if (this.instruments) {
-      return this.instruments;
+      return this.instruments
     }
 
     if (this.initializingPromise) {
-      return this.initializingPromise;
+      return this.initializingPromise
     }
 
-    this.initializingPromise = this.initializeInstruments();
+    this.initializingPromise = this.initializeInstruments()
 
     try {
-      this.instruments = await this.initializingPromise;
-      return this.instruments;
+      this.instruments = await this.initializingPromise
+      return this.instruments
     } catch (error) {
-      console.error('Failed to initialize OTel instruments:', error);
-      this.initializingPromise = undefined;
-      throw error;
+      console.error('Failed to initialize OTel instruments:', error)
+      this.initializingPromise = undefined
+      throw error
     } finally {
-      this.initializingPromise = undefined;
+      this.initializingPromise = undefined
     }
   }
 
@@ -97,13 +97,13 @@ class OtelInstrumentsSingleton {
       requestTimings,
       totalRequests,
       responseSizes,
-      abortedRequests
+      abortedRequests,
     ] = await Promise.all([
       createOtelConcurrentRequestsInstrument(),
       createOtelRequestsTimingsInstrument(),
       createOtelTotalRequestsInstrument(),
       createOtelRequestsResponseSizesInstrument(),
-      createOtelTotalAbortedRequestsInstrument()
+      createOtelTotalAbortedRequestsInstrument(),
     ])
 
     return {
@@ -111,9 +111,9 @@ class OtelInstrumentsSingleton {
       requestTimings,
       totalRequests,
       responseSizes,
-      abortedRequests
+      abortedRequests,
     }
   }
 }
 
-export const getOtelInstruments = () => OtelInstrumentsSingleton.getInstance().getInstruments();
+export const getOtelInstruments = () => OtelInstrumentsSingleton.getInstance().getInstruments()
diff --git a/src/service/metrics/otelRequestMetricsMiddleware.ts b/src/service/metrics/otelRequestMetricsMiddleware.ts
index 7ebb453b1..bd0cda448 100644
--- a/src/service/metrics/otelRequestMetricsMiddleware.ts
+++ b/src/service/metrics/otelRequestMetricsMiddleware.ts
@@ -17,7 +17,7 @@ export const addOtelRequestMetricsMiddleware = () => {
             () => reject(new Error('Timeout waiting for OpenTelemetry instruments initialization')),
             INSTRUMENTS_INITIALIZATION_TIMEOUT
           )
-        )
+        ),
       ])
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error)
diff --git a/src/service/telemetry/client.ts b/src/service/telemetry/client.ts
index 59b8a23ab..e79a7af32 100644
--- a/src/service/telemetry/client.ts
+++ b/src/service/telemetry/client.ts
@@ -5,32 +5,32 @@ import {
   Logs,
   Metrics,
   Traces,
-} from '@vtex/diagnostics-nodejs';
-import { APP, OTEL_EXPORTER_OTLP_ENDPOINT, DK_APP_ID, DIAGNOSTICS_TELEMETRY_ENABLED, WORKSPACE, PRODUCTION, AttributeKeys } from '../../constants';
-import { TelemetryClient } from '@vtex/diagnostics-nodejs/dist/telemetry';
-import { KoaInstrumentation } from '@opentelemetry/instrumentation-koa';
-import { HostMetricsInstrumentation } from '../metrics/instruments/hostMetrics';
+} from '@vtex/diagnostics-nodejs'
+import { APP, OTEL_EXPORTER_OTLP_ENDPOINT, DK_APP_ID, DIAGNOSTICS_TELEMETRY_ENABLED, WORKSPACE, PRODUCTION, AttributeKeys } from '../../constants'
+import { TelemetryClient } from '@vtex/diagnostics-nodejs/dist/telemetry'
+import { KoaInstrumentation } from '@opentelemetry/instrumentation-koa'
+import { HostMetricsInstrumentation } from '../metrics/instruments/hostMetrics'
 
-const APPLICATION_ID = APP.ID || 'vtex-io-app';
+const APPLICATION_ID = APP.ID || 'vtex-io-app'
 
 interface TelemetryClients {
-  logsClient: Logs.LogClient;
-  metricsClient: Metrics.MetricsClient;
-  tracesClient: Traces.TraceClient;
+  logsClient: Logs.LogClient
+  metricsClient: Metrics.MetricsClient
+  tracesClient: Traces.TraceClient
 }
 
 class TelemetryClientSingleton {
-  private static instance: TelemetryClientSingleton;
-  private telemetryClients: TelemetryClients | undefined;
-  private initializationPromise: Promise<TelemetryClients> | undefined = undefined;
+  private static instance: TelemetryClientSingleton
+  private telemetryClients: TelemetryClients | undefined
+  private initializationPromise: Promise<TelemetryClients> | undefined = undefined
 
   private constructor() {}
 
   public static getInstance(): TelemetryClientSingleton {
     if (!TelemetryClientSingleton.instance) {
-      TelemetryClientSingleton.instance = new TelemetryClientSingleton();
+      TelemetryClientSingleton.instance = new TelemetryClientSingleton()
     }
-    return TelemetryClientSingleton.instance;
+    return TelemetryClientSingleton.instance
   }
 
   private initializeTracesClient = async (telemetryClient: TelemetryClient) =>
@@ -38,7 +38,7 @@ class TelemetryClientSingleton {
       exporter: Exporters.CreateExporter(Exporters.CreateTracesExporterConfig({
         endpoint: OTEL_EXPORTER_OTLP_ENDPOINT,
       }), 'otlp'),
-    });
+    })
 
   private initializeMetricsClient = async (telemetryClient: TelemetryClient) =>
     await telemetryClient.newMetricsClient({
@@ -47,7 +47,7 @@ class TelemetryClientSingleton {
         interval: 60,
         timeoutSeconds: 60,
       }), 'otlp'),
-    });
+    })
 
   private initializeLogsClient = async (telemetryClient: TelemetryClient) =>
     await telemetryClient.newLogsClient({
@@ -55,7 +55,7 @@ class TelemetryClientSingleton {
         endpoint: OTEL_EXPORTER_OTLP_ENDPOINT,
       }), 'otlp'),
       loggerName: `node-vtex-api-${APPLICATION_ID}`,
-    });
+    })
 
   private async initializeTelemetryClients(): Promise<TelemetryClients> {
 
@@ -75,16 +75,16 @@ class TelemetryClientSingleton {
             [AttributeKeys.VTEX_IO_WORKSPACE_TYPE]: PRODUCTION.toString(),
           },
         }
-      );
+      )
 
       const [tracesClient, metricsClient, logsClient] = await Promise.all([
         this.initializeTracesClient(telemetryClient),
         this.initializeMetricsClient(telemetryClient),
         this.initializeLogsClient(telemetryClient),
-      ]);
+      ])
 
       if (DIAGNOSTICS_TELEMETRY_ENABLED) {
-        console.log(`Telemetry enabled for app: ${APP.ID} (vendor: ${APP.VENDOR})`);
+        console.log(`Telemetry enabled for app: ${APP.ID} (vendor: ${APP.VENDOR})`)
         
         const instrumentations = [
           ...Instrumentation.CommonInstrumentations.minimal(),
@@ -93,50 +93,50 @@ class TelemetryClientSingleton {
             name: 'host-metrics-instrumentation',
             meterProvider: metricsClient.provider(),
           }),
-        ];
+        ]
 
-        telemetryClient.registerInstrumentations(instrumentations);
+        telemetryClient.registerInstrumentations(instrumentations)
       }
 
       const clients: TelemetryClients = {
         logsClient,
         metricsClient,
         tracesClient,
-      };
+      }
 
-      this.telemetryClients = clients;
-      return clients;
+      this.telemetryClients = clients
+      return clients
     } catch (error) {
-      console.error('Failed to initialize telemetry clients:', error);
-      throw error;
+      console.error('Failed to initialize telemetry clients:', error)
+      throw error
     } finally {
-      this.initializationPromise = undefined;
+      this.initializationPromise = undefined
     }
   }
 
   public async getTelemetryClients(): Promise<TelemetryClients> {
     if (this.telemetryClients) {
-      return this.telemetryClients;
+      return this.telemetryClients
     }
 
     if (this.initializationPromise) {
-      return this.initializationPromise;
+      return this.initializationPromise
     }
 
-    this.initializationPromise = this.initializeTelemetryClients();
-    return this.initializationPromise;
+    this.initializationPromise = this.initializeTelemetryClients()
+    return this.initializationPromise
   }
 
   public reset(): void {
-    this.telemetryClients = undefined;
-    this.initializationPromise = undefined;
+    this.telemetryClients = undefined
+    this.initializationPromise = undefined
   }
 }
 
 export async function initializeTelemetry(): Promise<TelemetryClients> {
-  return TelemetryClientSingleton.getInstance().getTelemetryClients();
+  return TelemetryClientSingleton.getInstance().getTelemetryClients()
 }
 
 export function resetTelemetry(): void {
-  TelemetryClientSingleton.getInstance().reset();
+  TelemetryClientSingleton.getInstance().reset()
 }
diff --git a/src/service/worker/index.ts b/src/service/worker/index.ts
index f1a8ac607..08c6a91e7 100644
--- a/src/service/worker/index.ts
+++ b/src/service/worker/index.ts
@@ -1,4 +1,4 @@
-import { Instrumentation } from '@vtex/diagnostics-nodejs';
+import { Instrumentation } from '@vtex/diagnostics-nodejs'
 import { request } from 'http'
 import Koa from 'koa'
 import compress from 'koa-compress'
diff --git a/src/service/worker/runtime/events/index.ts b/src/service/worker/runtime/events/index.ts
index 4ad110fc2..51941b76f 100644
--- a/src/service/worker/runtime/events/index.ts
+++ b/src/service/worker/runtime/events/index.ts
@@ -22,7 +22,7 @@ import { eventContextMiddleware } from './middlewares/context'
 export const createEventHandler = <T extends IOClients, U extends RecorderState, V extends ParamsContext>(
   clientsConfig: ClientsConfig<T>,
   eventId: string,
-  handler: EventHandler<T, U> | Array<EventHandler<T, U>>,
+  handler: EventHandler<T, U> | EventHandler<T, U>[],
   serviceEvent: ServiceEvent  | undefined,
   globalLimiter: TokenBucket | undefined
 ) => {
@@ -43,7 +43,7 @@ export const createEventHandler = <T extends IOClients, U extends RecorderState,
   return compose(pipeline)
 }
 
-function contextAdapter<T extends IOClients, U extends RecorderState, V extends ParamsContext> (middlewares: Array<EventHandler<T, U>>) {
+function contextAdapter<T extends IOClients, U extends RecorderState, V extends ParamsContext> (middlewares: EventHandler<T, U>[]) {
   return  async function  middlewareCascade(ctx: ServiceContext<T, U, V>) {
     const ctxEvent = {
       body: (ctx.state as any).body,
diff --git a/src/service/worker/runtime/graphql/schema/messagesLoaderV2.ts b/src/service/worker/runtime/graphql/schema/messagesLoaderV2.ts
index 6dc9ddf7a..154412948 100644
--- a/src/service/worker/runtime/graphql/schema/messagesLoaderV2.ts
+++ b/src/service/worker/runtime/graphql/schema/messagesLoaderV2.ts
@@ -10,13 +10,13 @@ import { IOClients } from './../../../../../clients/IOClients'
 
 type Indexed<X> = [number, X]
 
-const sortByContentAndFrom = (indexedMessages: Array<Indexed<Message>>) => sortBy(
+const sortByContentAndFrom = (indexedMessages: Indexed<Message>[]) => sortBy(
   ([_, {content, from}]) => `__from:${from}__content:${content}`,
   indexedMessages
 )
 
 // O(n) counting sort implementation
-const sortByIndex = (indexedTranslations: Array<Indexed<string>>) => indexedTranslations.reduce(
+const sortByIndex = (indexedTranslations: Indexed<string>[]) => indexedTranslations.reduce(
   (acc, [index, data]) => {
     acc[index] = data
     return acc
@@ -47,7 +47,7 @@ const indexMessagesByFrom = (messages:  Message[]) => messages.reduce(
 
 const toPairs = <T>(x: T[]) => x.map((xx, it) => [it, xx] as Indexed<T>)
 
-const splitIndex = <T>(indexed: Array<Indexed<T>>) => indexed.reduce(
+const splitIndex = <T>(indexed: Indexed<T>[]) => indexed.reduce(
   (acc, [index, data]) => {
     acc[0].push(index)
     acc[1].push(data)
@@ -56,7 +56,7 @@ const splitIndex = <T>(indexed: Array<Indexed<T>>) => indexed.reduce(
   [[] as number[], [] as T[]] as [number[], T[]]
 )
 
-const filterFromEqualsTo = (indexedMessages: Array<Indexed<Message>>, to: string) => indexedMessages.reduce(
+const filterFromEqualsTo = (indexedMessages: Indexed<Message>[], to: string) => indexedMessages.reduce(
   (acc, indexed) => {
     const [index, { content, from }] = indexed
     if (to === from.toLowerCase() || !content) {
@@ -67,8 +67,8 @@ const filterFromEqualsTo = (indexedMessages: Array<Indexed<Message>>, to: string
     return acc
   },
   {
-    original: [] as Array<Indexed<string>>,
-    toTranslate: [] as Array<Indexed<Message>>,
+    original: [] as Indexed<string>[],
+    toTranslate: [] as Indexed<Message>[],
   }
 )
 
diff --git a/src/service/worker/runtime/graphql/schema/schemaDirectives/Auth.ts b/src/service/worker/runtime/graphql/schema/schemaDirectives/Auth.ts
index 6dd8dd862..5a187a1b1 100644
--- a/src/service/worker/runtime/graphql/schema/schemaDirectives/Auth.ts
+++ b/src/service/worker/runtime/graphql/schema/schemaDirectives/Auth.ts
@@ -69,7 +69,7 @@ async function auth (ctx: ServiceContext, authArgs: AuthDirectiveArgs): Promise<
 }
 
 function parseArgs (authArgs: AuthDirectiveArgs): AuthDirectiveArgs {
-  if (authArgs.scope == 'PUBLIC') {
+  if (authArgs.scope === 'PUBLIC') {
     return authArgs
   }
 
@@ -84,7 +84,7 @@ export class Auth extends SchemaDirectiveVisitor {
     const {resolve = defaultFieldResolver} = field
     field.resolve = async (root, args, ctx, info) => {
       const authArgs = parseArgs(this.args as AuthDirectiveArgs)
-      if (!authArgs.scope || authArgs.scope == 'PRIVATE') {
+      if (!authArgs.scope || authArgs.scope === 'PRIVATE') {
         await auth(ctx, authArgs)
       }
       return resolve(root, args, ctx, info)
diff --git a/src/service/worker/runtime/graphql/schema/schemaDirectives/Metric.test.ts b/src/service/worker/runtime/graphql/schema/schemaDirectives/Metric.test.ts
index 4243b6ec8..4b0b2e283 100644
--- a/src/service/worker/runtime/graphql/schema/schemaDirectives/Metric.test.ts
+++ b/src/service/worker/runtime/graphql/schema/schemaDirectives/Metric.test.ts
@@ -42,15 +42,15 @@ describe('Metric Schema Directive', () => {
     // Simulate what the Metric directive does
     const wrappedResolver = async (root: any, args: any, ctx: any, info: any) => {
       let failedToResolve = false
-      let result: any = null
+      let resolverResult: any = null
       let ellapsed: [number, number] = [0, 0]
 
       try {
         const start = process.hrtime()
-        result = await mockResolver(root, args, ctx, info)
+        resolverResult = await mockResolver(root, args, ctx, info)
         ellapsed = process.hrtime(start)
       } catch (error) {
-        result = error
+        resolverResult = error
         failedToResolve = true
       }
 
@@ -78,10 +78,10 @@ describe('Metric Schema Directive', () => {
       }
 
       if (failedToResolve) {
-        throw result
+        throw resolverResult
       }
 
-      return result
+      return resolverResult
     }
 
     // Execute the wrapped resolver
@@ -123,15 +123,15 @@ describe('Metric Schema Directive', () => {
     // Simulate what the Metric directive does
     const wrappedResolver = async (root: any, args: any, ctx: any, info: any) => {
       let failedToResolve = false
-      let result: any = null
+      let resolverResult: any = null
       let ellapsed: [number, number] = [0, 0]
 
       try {
         const start = process.hrtime()
-        result = await mockResolver(root, args, ctx, info)
+        resolverResult = await mockResolver(root, args, ctx, info)
         ellapsed = process.hrtime(start)
       } catch (error) {
-        result = error
+        resolverResult = error
         failedToResolve = true
       }
 
@@ -159,10 +159,10 @@ describe('Metric Schema Directive', () => {
       }
 
       if (failedToResolve) {
-        throw result
+        throw resolverResult
       }
 
-      return result
+      return resolverResult
     }
 
     // Execute the wrapped resolver and expect it to throw
@@ -206,15 +206,15 @@ describe('Metric Schema Directive', () => {
     // Simulate what the Metric directive does (without diagnostics)
     const wrappedResolver = async (root: any, args: any, ctx: any, info: any) => {
       let failedToResolve = false
-      let result: any = null
+      let resolverResult: any = null
       let ellapsed: [number, number] = [0, 0]
 
       try {
         const start = process.hrtime()
-        result = await mockResolver(root, args, ctx, info)
+        resolverResult = await mockResolver(root, args, ctx, info)
         ellapsed = process.hrtime(start)
       } catch (error) {
-        result = error
+        resolverResult = error
         failedToResolve = true
       }
 
@@ -244,10 +244,10 @@ describe('Metric Schema Directive', () => {
       }
 
       if (failedToResolve) {
-        throw result
+        throw resolverResult
       }
 
-      return result
+      return resolverResult
     }
 
     // Execute the wrapped resolver
diff --git a/src/service/worker/runtime/http/index.ts b/src/service/worker/runtime/http/index.ts
index 231d1d234..98b887aeb 100644
--- a/src/service/worker/runtime/http/index.ts
+++ b/src/service/worker/runtime/http/index.ts
@@ -26,7 +26,7 @@ import { vary } from './middlewares/vary'
 
 export const createPrivateHttpRoute = <T extends IOClients, U extends RecorderState, V extends ParamsContext>(
   clientsConfig: ClientsConfig<T>,
-  serviceHandler: RouteHandler<T, U, V> | Array<RouteHandler<T, U, V>>,
+  serviceHandler: RouteHandler<T, U, V> | RouteHandler<T, U, V>[],
   serviceRoute: ServiceRoute,
   routeId: string,
   globalLimiter: TokenBucket | undefined
@@ -53,7 +53,7 @@ export const createPrivateHttpRoute = <T extends IOClients, U extends RecorderSt
 
 export const createPublicHttpRoute = <T extends IOClients, U extends RecorderState, V extends ParamsContext>(
   clientsConfig: ClientsConfig<T>,
-  serviceHandler: RouteHandler<T, U, V> | Array<RouteHandler<T, U, V>>,
+  serviceHandler: RouteHandler<T, U, V> | RouteHandler<T, U, V>[],
   serviceRoute: ServiceRoute,
   routeId: string,
   globalLimiter: TokenBucket | undefined
diff --git a/src/service/worker/runtime/http/middlewares/rateLimit.test.ts b/src/service/worker/runtime/http/middlewares/rateLimit.test.ts
index 62254c097..0decfe0c9 100644
--- a/src/service/worker/runtime/http/middlewares/rateLimit.test.ts
+++ b/src/service/worker/runtime/http/middlewares/rateLimit.test.ts
@@ -27,7 +27,7 @@ function getRequestsArray(
   requestsAmount: number,
   middleware: Middleware,
   customNext?: () => Promise<void>
-): { mutexArr: Semaphore[], promisesArr: Array<Promise<void>> } {
+): { mutexArr: Semaphore[], promisesArr: Promise<void>[] } {
   const results = new Array(requestsAmount).fill(null).map(_ => startRequest(middleware, customNext))
   return { 
     mutexArr: results.map(result => result.mutex), 
diff --git a/src/service/worker/runtime/method.ts b/src/service/worker/runtime/method.ts
index 7a0c6051a..2b54fd78a 100644
--- a/src/service/worker/runtime/method.ts
+++ b/src/service/worker/runtime/method.ts
@@ -29,7 +29,7 @@ type MethodOptions<
   Record<
     HTTPMethods,
     | RouteHandler<ClientsT, StateT, CustomT>
-    | Array<RouteHandler<ClientsT, StateT, CustomT>>
+    | RouteHandler<ClientsT, StateT, CustomT>[]
   >
 >
 
@@ -54,7 +54,7 @@ export function method<
     options as Record<
       string,
       | RouteHandler<T, U, V>
-      | Array<RouteHandler<T, U, V>>
+      | RouteHandler<T, U, V>[]
     >
   )
 
diff --git a/src/service/worker/runtime/typings.ts b/src/service/worker/runtime/typings.ts
index 30f7bd2ab..be9fcd76b 100644
--- a/src/service/worker/runtime/typings.ts
+++ b/src/service/worker/runtime/typings.ts
@@ -104,9 +104,9 @@ export interface GraphQLOptions<ClientsT extends IOClients = IOClients, StateT e
 
 export interface ServiceConfig<ClientsT extends IOClients = IOClients, StateT extends RecorderState = RecorderState, CustomT extends ParamsContext = ParamsContext> {
   clients?: ClientsConfig<ClientsT>
-  events?: Record<string, EventHandler<ClientsT, StateT> | Array<EventHandler<ClientsT, StateT>>>,
+  events?: Record<string, EventHandler<ClientsT, StateT> | EventHandler<ClientsT, StateT>[]>,
   graphql?: GraphQLOptions<ClientsT, StateT, CustomT>,
-  routes?: Record<string, RouteHandler<ClientsT, StateT, CustomT> | Array<RouteHandler<ClientsT, StateT, CustomT>>>
+  routes?: Record<string, RouteHandler<ClientsT, StateT, CustomT> | RouteHandler<ClientsT, StateT, CustomT>[]>
 }
 
 export interface Cancellation {
diff --git a/src/service/worker/runtime/utils/compose.ts b/src/service/worker/runtime/utils/compose.ts
index 6f147366b..f4a3c9fc6 100644
--- a/src/service/worker/runtime/utils/compose.ts
+++ b/src/service/worker/runtime/utils/compose.ts
@@ -11,8 +11,8 @@ import {
   RouteHandler,
 } from '../typings'
 
-export const compose = <ClientsT extends IOClients, StateT extends RecorderState, CustomT extends ParamsContext>(middlewares: Array<RouteHandler<ClientsT, StateT, CustomT>>) =>
+export const compose = <ClientsT extends IOClients, StateT extends RecorderState, CustomT extends ParamsContext>(middlewares: RouteHandler<ClientsT, StateT, CustomT>[]) =>
   koaCompose(middlewares.map(pipe(timer, cancel)))
 
-export const composeForEvents = <ClientsT extends IOClients, StateT extends RecorderState>(middlewares: Array<EventHandler<ClientsT, StateT>>) =>
+export const composeForEvents = <ClientsT extends IOClients, StateT extends RecorderState>(middlewares: EventHandler<ClientsT, StateT>[]) =>
   koaCompose(middlewares.map(timerForEvents))
diff --git a/src/utils/buildFullPath.ts b/src/utils/buildFullPath.ts
index b4efcdff9..383c786a4 100644
--- a/src/utils/buildFullPath.ts
+++ b/src/utils/buildFullPath.ts
@@ -20,11 +20,11 @@
  * @returns {string} The combined full path
  */
 export default function(baseURL?: string, requestedURL?: string, allowAbsoluteUrls?: boolean): string | undefined {
-    let isRelativeUrl = !isAbsoluteURL(requestedURL);
-    if (baseURL && (isRelativeUrl || allowAbsoluteUrls == false)) {
-      return combineURLs(baseURL, requestedURL);
+    const isRelativeUrl = !isAbsoluteURL(requestedURL)
+    if (baseURL && (isRelativeUrl || allowAbsoluteUrls === false)) {
+      return combineURLs(baseURL, requestedURL)
     }
-    return requestedURL;
+    return requestedURL
   }
   
   /**
@@ -38,7 +38,7 @@ export default function(baseURL?: string, requestedURL?: string, allowAbsoluteUr
       // A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL).
       // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed
       // by any combination of letters, digits, plus, period, or hyphen.
-      return !!url && /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
+      return !!url && /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url)
   }
   
   /**
@@ -52,5 +52,5 @@ export default function(baseURL?: string, requestedURL?: string, allowAbsoluteUr
   function combineURLs(baseURL?: string, relativeURL?: string): string | undefined {
       return relativeURL && baseURL
         ? baseURL.replace(/\/?\/$/, '') + '/' + relativeURL.replace(/^\/+/, '')
-        : baseURL;
+        : baseURL
   }
\ No newline at end of file
diff --git a/src/utils/renameBy.ts b/src/utils/renameBy.ts
index 16a447780..ec0ccc36a 100644
--- a/src/utils/renameBy.ts
+++ b/src/utils/renameBy.ts
@@ -4,7 +4,7 @@ export const renameBy = <K>(
   fn: (key: string) => string,
   obj: Record<string, K>
 ): Record<string, K> =>
-  compose<Record<string, K>, Array<[string, K]>, Array<[string, K]>, Record<string, K>>(
+  compose<Record<string, K>, [string, K][], [string, K][], Record<string, K>>(
     fromPairs,
     map(([key, val]) => [fn(key), val] as [string, K]),
     toPairs
diff --git a/src/utils/time.ts b/src/utils/time.ts
index 90d22c05e..a24a86608 100644
--- a/src/utils/time.ts
+++ b/src/utils/time.ts
@@ -49,7 +49,7 @@ export const parseTimingName = (timing: string | undefined) => {
   }
 }
 
-export const reduceTimings = (timingsObj: Record<string, string>) => compose<Record<string, string>, Array<[string, string]>, string>(
+export const reduceTimings = (timingsObj: Record<string, string>) => compose<Record<string, string>, [string, string][], string>(
   reduce((acc, [key, dur]) => `${key};dur=${dur}, ${acc}`, ''),
   toPairs
 )(timingsObj)