@rudderstack/integrations-lib
Version:
A comprehensive TypeScript library providing shared utilities, SDKs, and tools for RudderStack integrations and destinations.
281 lines • 36.2 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.AxiosClient = void 0;
/* eslint-disable require-await */
const axios_1 = __importDefault(require("axios"));
const http_1 = __importDefault(require("http"));
const https_1 = __importDefault(require("https"));
const constants_1 = require("../../constants");
const utils_1 = require("../../utils");
// Allowed labels for timing metrics
const TIMING_METRIC_LABELS = [
'feature',
'destType',
'endpointPath',
'requestMethod',
'module',
'workspaceId',
'destinationId',
'implementation',
'sourceId',
];
// Allowed labels for counter metrics
const COUNTER_METRIC_LABELS = [
'feature',
'destType',
'endpointPath',
'success',
'statusCode',
'requestMethod',
'module',
'workspaceId',
'destinationId',
'implementation',
'sourceId',
];
/**
* Filters labels to only include allowed keys
* @param allLabels - The complete set of labels
* @param allowedLabels - Array of allowed label keys
* @returns Filtered labels object
*/
function filterMetricLabels(allLabels, allowedLabels) {
return allowedLabels.reduce((filteredLabels, key) => {
if (allLabels[key] !== undefined) {
return { ...filteredLabels, [key]: allLabels[key] };
}
return filteredLabels;
}, {});
}
/**
* A wrapper around axios to make http requests
*
* @class AxiosClient
* @classdesc
* The `AxiosClient` class is a wrapper around the axios library that provides a simplified interface for making HTTP requests. It handles various types of errors and provides a consistent response format.
*
* @param {AxiosRequestConfig} options - The default options for the http client
*
* @example
* const axiosClient = new AxiosClient({ timeout: 1000 * 10 });
* const response = await axiosClient.post("https://example.com", { foo: "bar" });
* if (response.type === "success") {
* console.log(response.statusCode);
* console.log(response.responseBody);
* } else if (response.type === "application-error") {
* console.log(response.statusCode);
* console.log(response.message);
* console.log(response.responseBody);
* } else if (response.type === "client-error") {
* console.log(response.statusCode);
* console.log(response.message);
* }
*/
class AxiosClient {
constructor(options, observabilityConfig) {
const defaultOptions = {
timeout: 1000 * 10,
// `withCredentials` indicates whether or not cross-site Access-Control requests should be made using credentials
withCredentials: false,
// `responseEncoding` indicates encoding to use for decoding responses (Node.js only),
responseEncoding: 'utf8',
// `maxBodyLength` (Node only option) defines the max size of the http request content in bytes allowed,
maxBodyLength: 1000 * 1000 * 10,
// `maxRedirects` defines the maximum number of redirects to follow in node.js,
maxRedirects: 5,
// `httpAgent` and `httpsAgent` define a custom agent to be used when performing http
httpAgent: new http_1.default.Agent({ keepAlive: true }),
// and https requests, respectively, in node.js. This allows options to be added like `keepAlive` that are not enabled by default.
httpsAgent: new https_1.default.Agent({ keepAlive: true }),
};
this.options = { ...defaultOptions, ...options };
this.instance = axios_1.default.create(this.options);
// Merge with default config to eliminate null checks
const defaultObservabilityConfig = {
logger: undefined,
statsClient: undefined,
defaultStatTags: {},
};
this.observabilityConfig = { ...defaultObservabilityConfig, ...observabilityConfig };
}
async makeRequest(config, responseParser) {
const startTimestamp = new Date();
// Extract metadata for logging/metrics
const method = config.method?.toUpperCase() || 'UNKNOWN';
const url = config.url || 'unknown';
const body = config.data || undefined;
const statTags = {
...this.observabilityConfig.defaultStatTags,
requestMethod: method,
endpointPath: 'default',
...config.statTags,
};
const metadataMetricTags = {
...(this.observabilityConfig.defaultStatTags?.metadata || {}),
...(config.statTags?.metadata || {}),
};
// Optional request logging
const requestLogParams = {
requestDetails: {
method: method || 'undefined',
url: url || 'undefined',
body: body || 'undefined',
},
metadata: statTags.metadata || {},
};
this.observabilityConfig.logger?.requestLog(`[HTTP] ${method} ${url} request`, requestLogParams);
try {
const requestConfig = config;
const response = await this.instance.request(requestConfig);
const { status, data, headers } = response;
// Optional response logging
const responseLogParams = {
responseDetails: {
status: status || 0,
body: data || 'undefined',
headers: headers || 'undefined',
},
metadata: statTags.metadata || {},
};
this.observabilityConfig.logger?.responseLog(`[HTTP] ${method} ${url} response`, responseLogParams);
// Optional success metrics
const allLabels = { ...metadataMetricTags, ...statTags, statusCode: status };
const timingLabels = filterMetricLabels(allLabels, TIMING_METRIC_LABELS);
this.observabilityConfig.statsClient?.timing('outgoing_request_latency', startTimestamp, timingLabels);
const counterLabels = filterMetricLabels(allLabels, COUNTER_METRIC_LABELS);
this.observabilityConfig.statsClient?.counter('outgoing_request_count', 1, counterLabels);
if (responseParser) {
try {
const parsedData = responseParser(data);
return {
type: 'success',
statusCode: status,
responseBody: parsedData,
headers,
};
}
catch (error) {
const unknownError = error;
return {
type: 'client-error',
// @ts-expect-error: Error has status
statusCode: unknownError.status || 500,
message: `Failed to parse response data: ${unknownError.message}`,
};
}
}
return { type: 'success', statusCode: status, responseBody: data, headers };
}
catch (error) {
// Determine status code for error metrics
let errorStatusCode = 500; // Default to 500 for network/unknown errors
if (axios_1.default.isAxiosError(error)) {
const axiosError = error;
if (axiosError.response) {
errorStatusCode = axiosError.response.status;
}
}
// Optional error logging
this.observabilityConfig.logger?.error?.(`[HTTP] ${method} ${url} error`, {
error: error.message,
statTags: { ...statTags, statusCode: errorStatusCode },
});
// Optional error metrics
const allErrorLabels = { ...metadataMetricTags, ...statTags, statusCode: errorStatusCode };
const timingLabels = filterMetricLabels(allErrorLabels, TIMING_METRIC_LABELS);
this.observabilityConfig.statsClient?.timing('outgoing_request_latency', startTimestamp, timingLabels);
const counterLabels = filterMetricLabels(allErrorLabels, COUNTER_METRIC_LABELS);
this.observabilityConfig.statsClient?.counter('outgoing_request_count', 1, counterLabels);
if (axios_1.default.isAxiosError(error)) {
const axiosError = error;
if (axiosError.response) {
const { response } = axiosError;
return {
type: 'application-error',
statusCode: response.status,
message: response.statusText,
responseBody: response.data,
headers: response.headers,
};
}
if (axiosError.code) {
const resp = constants_1.NETWORK_STATUS_ERR_MAP[axiosError.code];
if (!resp) {
return {
type: 'client-error',
statusCode: 500,
message: `Unknown Error:${axiosError.message}`,
};
}
return {
type: 'client-error',
statusCode: resp.status,
message: resp.message,
};
}
}
const unknownError = error;
const status = 500;
const message = unknownError.message || 'Unknown Error';
return { type: 'client-error', statusCode: status, message };
}
}
async get(url, options, responseParser) {
let config = {
method: 'get',
url,
};
if ((0, utils_1.isNotEmpty)(options)) {
config = { ...config, ...options };
}
return this.makeRequest(config, responseParser);
}
async post(url, data, options, responseParser) {
let config = {
method: 'post',
url,
data,
};
if ((0, utils_1.isNotEmpty)(options)) {
config = { ...config, ...options };
}
return this.makeRequest(config, responseParser);
}
async put(url, data, options, responseParser) {
let config = {
method: 'put',
url,
data,
};
if ((0, utils_1.isNotEmpty)(options)) {
config = { ...config, ...options };
}
return this.makeRequest(config, responseParser);
}
async patch(url, data, options, responseParser) {
let config = {
method: 'patch',
url,
data,
};
if ((0, utils_1.isNotEmpty)(options)) {
config = { ...config, ...options };
}
return this.makeRequest(config, responseParser);
}
async delete(url, options, responseParser) {
let config = {
method: 'delete',
url,
};
if ((0, utils_1.isNotEmpty)(options)) {
config = { ...config, ...options };
}
return this.makeRequest(config, responseParser);
}
}
exports.AxiosClient = AxiosClient;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"axios_client.js","sourceRoot":"","sources":["../../../src/network/clients/axios_client.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable require-await */\nimport axios, { AxiosError, AxiosInstance } from 'axios';\nimport http from 'http';\nimport https from 'https';\nimport { NETWORK_STATUS_ERR_MAP } from '../../constants';\nimport {\n  ApiResponse,\n  HttpClient,\n  ResponseParser,\n  AxiosClientObservabilityConfig,\n  StatTags,\n  RequestLogParams,\n  ResponseLogParams,\n  RequestConfig,\n} from './types';\nimport { isNotEmpty } from '../../utils';\n\n// Allowed labels for timing metrics\nconst TIMING_METRIC_LABELS = [\n  'feature',\n  'destType',\n  'endpointPath',\n  'requestMethod',\n  'module',\n  'workspaceId',\n  'destinationId',\n  'implementation',\n  'sourceId',\n];\n\n// Allowed labels for counter metrics\nconst COUNTER_METRIC_LABELS = [\n  'feature',\n  'destType',\n  'endpointPath',\n  'success',\n  'statusCode',\n  'requestMethod',\n  'module',\n  'workspaceId',\n  'destinationId',\n  'implementation',\n  'sourceId',\n];\n\n/**\n * Filters labels to only include allowed keys\n * @param allLabels - The complete set of labels\n * @param allowedLabels - Array of allowed label keys\n * @returns Filtered labels object\n */\nfunction filterMetricLabels(\n  allLabels: Record<string, unknown>,\n  allowedLabels: string[],\n): Record<string, unknown> {\n  return allowedLabels.reduce((filteredLabels: Record<string, unknown>, key: string) => {\n    if (allLabels[key] !== undefined) {\n      return { ...filteredLabels, [key]: allLabels[key] };\n    }\n    return filteredLabels;\n  }, {});\n}\n\n/**\n * A wrapper around axios to make http requests\n *\n * @class AxiosClient\n * @classdesc\n * The `AxiosClient` class is a wrapper around the axios library that provides a simplified interface for making HTTP requests. It handles various types of errors and provides a consistent response format.\n *\n * @param {AxiosRequestConfig} options - The default options for the http client\n *\n * @example\n * const axiosClient = new AxiosClient({ timeout: 1000 * 10 });\n * const response = await axiosClient.post(\"https://example.com\", { foo: \"bar\" });\n * if (response.type === \"success\") {\n *   console.log(response.statusCode);\n *   console.log(response.responseBody);\n * } else if (response.type === \"application-error\") {\n *   console.log(response.statusCode);\n *   console.log(response.message);\n *   console.log(response.responseBody);\n * } else if (response.type === \"client-error\") {\n *   console.log(response.statusCode);\n *   console.log(response.message);\n * }\n */\nexport class AxiosClient implements HttpClient {\n  private options: RequestConfig;\n\n  private instance: AxiosInstance;\n\n  private observabilityConfig: AxiosClientObservabilityConfig;\n\n  constructor(options?: RequestConfig, observabilityConfig?: AxiosClientObservabilityConfig) {\n    const defaultOptions = {\n      timeout: 1000 * 10,\n      // `withCredentials` indicates whether or not cross-site Access-Control requests should be made using credentials\n      withCredentials: false,\n      // `responseEncoding` indicates encoding to use for decoding responses (Node.js only),\n      responseEncoding: 'utf8',\n      // `maxBodyLength` (Node only option) defines the max size of the http request content in bytes allowed,\n      maxBodyLength: 1000 * 1000 * 10,\n      // `maxRedirects` defines the maximum number of redirects to follow in node.js,\n      maxRedirects: 5,\n      // `httpAgent` and `httpsAgent` define a custom agent to be used when performing http\n      httpAgent: new http.Agent({ keepAlive: true }),\n      // and https requests, respectively, in node.js. This allows options to be added like `keepAlive` that are not enabled by default.\n      httpsAgent: new https.Agent({ keepAlive: true }),\n    };\n    this.options = { ...defaultOptions, ...options };\n    this.instance = axios.create(this.options);\n\n    // Merge with default config to eliminate null checks\n    const defaultObservabilityConfig: AxiosClientObservabilityConfig = {\n      logger: undefined,\n      statsClient: undefined,\n      defaultStatTags: {},\n    };\n    this.observabilityConfig = { ...defaultObservabilityConfig, ...observabilityConfig };\n  }\n\n  private async makeRequest<T>(\n    config: RequestConfig,\n    responseParser?: ResponseParser<T>,\n  ): Promise<ApiResponse<T>> {\n    const startTimestamp = new Date();\n    // Extract metadata for logging/metrics\n    const method = config.method?.toUpperCase() || 'UNKNOWN';\n    const url = config.url || 'unknown';\n    const body = config.data || undefined;\n    const statTags: StatTags = {\n      ...this.observabilityConfig.defaultStatTags,\n      requestMethod: method,\n      endpointPath: 'default',\n      ...config.statTags,\n    };\n\n    const metadataMetricTags = {\n      ...(this.observabilityConfig.defaultStatTags?.metadata || {}),\n      ...(config.statTags?.metadata || {}),\n    };\n\n    // Optional request logging\n    const requestLogParams: RequestLogParams = {\n      requestDetails: {\n        method: method || 'undefined',\n        url: url || 'undefined',\n        body: body || 'undefined',\n      },\n      metadata: statTags.metadata || {},\n    };\n    this.observabilityConfig.logger?.requestLog(\n      `[HTTP] ${method} ${url} request`,\n      requestLogParams,\n    );\n\n    try {\n      const requestConfig = config;\n      const response = await this.instance.request(requestConfig);\n      const { status, data, headers } = response;\n\n      // Optional response logging\n      const responseLogParams: ResponseLogParams = {\n        responseDetails: {\n          status: status || 0,\n          body: data || 'undefined',\n          headers: headers || 'undefined',\n        },\n        metadata: statTags.metadata || {},\n      };\n      this.observabilityConfig.logger?.responseLog(\n        `[HTTP] ${method} ${url} response`,\n        responseLogParams,\n      );\n\n      // Optional success metrics\n      const allLabels = { ...metadataMetricTags, ...statTags, statusCode: status };\n\n      const timingLabels = filterMetricLabels(allLabels, TIMING_METRIC_LABELS);\n      this.observabilityConfig.statsClient?.timing(\n        'outgoing_request_latency',\n        startTimestamp,\n        timingLabels,\n      );\n\n      const counterLabels = filterMetricLabels(allLabels, COUNTER_METRIC_LABELS);\n      this.observabilityConfig.statsClient?.counter('outgoing_request_count', 1, counterLabels);\n\n      if (responseParser) {\n        try {\n          const parsedData = responseParser(data);\n          return {\n            type: 'success',\n            statusCode: status,\n            responseBody: parsedData,\n            headers,\n          };\n        } catch (error) {\n          const unknownError = error as Error;\n          return {\n            type: 'client-error',\n            // @ts-expect-error: Error has status\n            statusCode: unknownError.status || 500,\n            message: `Failed to parse response data: ${unknownError.message}`,\n          };\n        }\n      }\n      return { type: 'success', statusCode: status, responseBody: data, headers };\n    } catch (error) {\n      // Determine status code for error metrics\n      let errorStatusCode = 500; // Default to 500 for network/unknown errors\n      if (axios.isAxiosError(error)) {\n        const axiosError = error as AxiosError;\n        if (axiosError.response) {\n          errorStatusCode = axiosError.response.status;\n        }\n      }\n\n      // Optional error logging\n      this.observabilityConfig.logger?.error?.(`[HTTP] ${method} ${url} error`, {\n        error: (error as Error).message,\n        statTags: { ...statTags, statusCode: errorStatusCode },\n      });\n\n      // Optional error metrics\n      const allErrorLabels = { ...metadataMetricTags, ...statTags, statusCode: errorStatusCode };\n\n      const timingLabels = filterMetricLabels(allErrorLabels, TIMING_METRIC_LABELS);\n      this.observabilityConfig.statsClient?.timing(\n        'outgoing_request_latency',\n        startTimestamp,\n        timingLabels,\n      );\n\n      const counterLabels = filterMetricLabels(allErrorLabels, COUNTER_METRIC_LABELS);\n      this.observabilityConfig.statsClient?.counter('outgoing_request_count', 1, counterLabels);\n\n      if (axios.isAxiosError(error)) {\n        const axiosError = error as AxiosError;\n        if (axiosError.response) {\n          const { response } = axiosError;\n          return {\n            type: 'application-error',\n            statusCode: response.status,\n            message: response.statusText,\n            responseBody: response.data,\n            headers: response.headers,\n          };\n        }\n        if (axiosError.code) {\n          const resp = NETWORK_STATUS_ERR_MAP[axiosError.code];\n          if (!resp) {\n            return {\n              type: 'client-error',\n              statusCode: 500,\n              message: `Unknown Error:${axiosError.message}`,\n            };\n          }\n          return {\n            type: 'client-error',\n            statusCode: resp.status,\n            message: resp.message,\n          };\n        }\n      }\n\n      const unknownError = error as Error;\n      const status = 500;\n      const message = unknownError.message || 'Unknown Error';\n\n      return { type: 'client-error', statusCode: status, message };\n    }\n  }\n\n  public async get<T>(\n    url: string,\n    options?: RequestConfig,\n    responseParser?: ResponseParser<T>,\n  ): Promise<ApiResponse<T>> {\n    let config: RequestConfig = {\n      method: 'get',\n      url,\n    };\n    if (isNotEmpty(options)) {\n      config = { ...config, ...options };\n    }\n    return this.makeRequest<T>(config, responseParser);\n  }\n\n  public async post<T>(\n    url: string,\n    data?: unknown,\n    options?: RequestConfig,\n    responseParser?: ResponseParser<T>,\n  ): Promise<ApiResponse<T>> {\n    let config: RequestConfig = {\n      method: 'post',\n      url,\n      data,\n    };\n    if (isNotEmpty(options)) {\n      config = { ...config, ...options };\n    }\n    return this.makeRequest<T>(config, responseParser);\n  }\n\n  public async put<T>(\n    url: string,\n    data?: unknown,\n    options?: RequestConfig,\n    responseParser?: ResponseParser<T>,\n  ): Promise<ApiResponse<T>> {\n    let config: RequestConfig = {\n      method: 'put',\n      url,\n      data,\n    };\n    if (isNotEmpty(options)) {\n      config = { ...config, ...options };\n    }\n    return this.makeRequest<T>(config, responseParser);\n  }\n\n  public async patch<T>(\n    url: string,\n    data?: unknown,\n    options?: RequestConfig,\n    responseParser?: ResponseParser<T>,\n  ): Promise<ApiResponse<T>> {\n    let config: RequestConfig = {\n      method: 'patch',\n      url,\n      data,\n    };\n    if (isNotEmpty(options)) {\n      config = { ...config, ...options };\n    }\n    return this.makeRequest<T>(config, responseParser);\n  }\n\n  public async delete<T>(\n    url: string,\n    options?: RequestConfig,\n    responseParser?: ResponseParser<T>,\n  ): Promise<ApiResponse<T>> {\n    let config: RequestConfig = {\n      method: 'delete',\n      url,\n    };\n    if (isNotEmpty(options)) {\n      config = { ...config, ...options };\n    }\n    return this.makeRequest<T>(config, responseParser);\n  }\n\n  // Add other HTTP methods as needed\n}\n"]}