chore: enable labels for api calls

src/adapters/network.js

@@ -5,9 +5,14 @@ const lodash = require('lodash');
 const http = require('http');
 const https = require('https');
 const axios = require('axios');
-const logger = require('../logger');
+const { isDefinedAndNotNull } = require('@rudderstack/integrations-lib');
 const stats = require('../util/stats');
-const { removeUndefinedValues, isDefinedAndNotNullAndNotEmpty } = require('../v0/util');
+const {
+  removeUndefinedValues,
+  getErrorStatusCode,
+  isDefinedAndNotNullAndNotEmpty,
+} = require('../v0/util');
+const logger = require('../logger');
 const { processAxiosResponse } = require('./utils/networkUtils');
 // Only for tests
 const { setResponsesForMockAxiosAdapter } = require('../../test/testHelper');
@@ -83,7 +88,9 @@ const fireHTTPStats = (clientResponse, startTime, statTags) => {
   const endpointPath = statTags.endpointPath ? statTags.endpointPath : '';
   const requestMethod = statTags.requestMethod ? statTags.requestMethod : '';
   const module = statTags.module ? statTags.module : '';
-  const statusCode = clientResponse.success ? clientResponse.response.status : '';
+  const statusCode = clientResponse.success
+    ? clientResponse.response.status
+    : getErrorStatusCode(clientResponse.response);
   const defArgs = {
     destType,
     endpointPath,
@@ -94,9 +101,9 @@ const fireHTTPStats = (clientResponse, startTime, statTags) => {
     startTime,
     clientResponse,
   };
-  if (statTags?.metadata) {
+  if (statTags?.metadata && typeof statTags?.metadata === 'object') {
     const metadata = !Array.isArray(statTags?.metadata) ? [statTags.metadata] : statTags.metadata;
-    metadata?.forEach((m) => {
+    metadata?.filter(isDefinedAndNotNull)?.forEach((m) => {
       fireOutgoingReqStats({
         ...defArgs,
         metadata: m,
@@ -448,4 +455,5 @@ module.exports = {
   getFormData,
   handleHttpRequest,
   enhanceRequestOptions,
+  fireHTTPStats,
 };

src/adapters/network.test.js

@@ -1,8 +1,17 @@
 const mockLoggerInstance = {
   info: jest.fn(),
 };
-const { getFormData, httpPOST, httpGET, httpSend } = require('./network');
+const { getFormData, httpPOST, httpGET, httpSend, fireHTTPStats } = require('./network');
 const { getFuncTestData } = require('../../test/testHelper');
+jest.mock('../util/stats', () => ({
+  timing: jest.fn(),
+  timingSummary: jest.fn(),
+  increment: jest.fn(),
+  counter: jest.fn(),
+  gauge: jest.fn(),
+  histogram: jest.fn(),
+}));
+const stats = require('../util/stats');
 
 jest.mock('@rudderstack/integrations-lib', () => {
   return {
@@ -39,6 +48,308 @@ describe(`${funcName} Tests`, () => {
   });
 });
 
+describe('fireHTTPStats tests', () => {
+  beforeEach(() => {
+    stats.timing.mockClear();
+    stats.counter.mockClear();
+  });
+  it('should not throw error when metadata is sent as correctly defined object', () => {
+    const clientResponse = {
+      success: true,
+      response: {
+        data: { a: 1, b: 2 },
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      },
+    };
+    const startTime = new Date();
+    const statTags = {
+      metadata: {
+        destType: 'DT',
+        destinationId: 'd1',
+        workspaceId: 'w1',
+        sourceId: 's1',
+      },
+      destType: 'DT',
+      feature: 'feat',
+      endpointPath: '/some/url',
+      requestMethod: 'post',
+    };
+    expect(() => {
+      fireHTTPStats(clientResponse, startTime, statTags);
+    }).not.toThrow(Error);
+    expect(stats.timing).toHaveBeenCalledTimes(1);
+    expect(stats.timing).toHaveBeenNthCalledWith(1, 'outgoing_request_latency', startTime, {
+      destinationId: 'd1',
+      workspaceId: 'w1',
+      sourceId: 's1',
+      destType: 'DT',
+      feature: 'feat',
+      module: '',
+      endpointPath: '/some/url',
+      requestMethod: 'post',
+    });
+  });
+  it('should not throw error when metadata is sent as correctly defined object[]', () => {
+    const clientResponse = {
+      success: false,
+      response: {
+        response: {
+          data: { errors: [{ e: 'something went bad' }] },
+          status: 400,
+          headers: { 'Content-Type': 'application/json' },
+        },
+        headers: { 'Content-Type': 'application/json' },
+        status: 400,
+      },
+    };
+    const startTime = new Date();
+    const statTags = {
+      metadata: [
+        {
+          destType: 'DT',
+          destinationId: 'd1',
+          workspaceId: 'w1',
+          jobId: 1,
+          sourceId: 's1',
+        },
+        {
+          destType: 'DT',
+          jobId: 2,
+          destinationId: 'd1',
+          workspaceId: 'w2',
+          sourceId: 's2',
+        },
+      ],
+      destType: 'DT',
+      feature: 'feat',
+      endpointPath: '/some/url',
+      requestMethod: 'post',
+    };
+    expect(() => {
+      fireHTTPStats(clientResponse, startTime, statTags);
+    }).not.toThrow(Error);
+
+    expect(stats.timing).toHaveBeenCalledTimes(2);
+    expect(stats.timing).toHaveBeenNthCalledWith(1, 'outgoing_request_latency', startTime, {
+      destinationId: 'd1',
+      workspaceId: 'w1',
+      sourceId: 's1',
+      destType: 'DT',
+      feature: 'feat',
+      module: '',
+      endpointPath: '/some/url',
+      requestMethod: 'post',
+    });
+    expect(stats.timing).toHaveBeenNthCalledWith(2, 'outgoing_request_latency', startTime, {
+      destinationId: 'd1',
+      workspaceId: 'w2',
+      sourceId: 's2',
+      destType: 'DT',
+      module: '',
+      feature: 'feat',
+      endpointPath: '/some/url',
+      requestMethod: 'post',
+    });
+  });
+  it('should not throw error when metadata is not sent', () => {
+    const clientResponse = {
+      success: false,
+      response: {
+        response: {
+          data: { errors: [{ e: 'something went bad' }] },
+          status: 400,
+          headers: { 'Content-Type': 'application/json' },
+        },
+        headers: { 'Content-Type': 'application/json' },
+        status: 400,
+      },
+    };
+    const startTime = new Date();
+    const statTags = {
+      destType: 'DT',
+      feature: 'feat',
+      endpointPath: '/some/url',
+      requestMethod: 'post',
+    };
+    expect(() => {
+      fireHTTPStats(clientResponse, startTime, statTags);
+    }).not.toThrow(Error);
+
+    expect(stats.timing).toHaveBeenCalledTimes(1);
+    expect(stats.timing).toHaveBeenNthCalledWith(1, 'outgoing_request_latency', startTime, {
+      destType: 'DT',
+      feature: 'feat',
+      module: '',
+      endpointPath: '/some/url',
+      requestMethod: 'post',
+    });
+  });
+  it('should not throw error when metadata is sent as empty array', () => {
+    const clientResponse = {
+      success: false,
+      response: {
+        response: {
+          data: { errors: [{ e: 'something went bad' }] },
+          status: 400,
+          headers: { 'Content-Type': 'application/json' },
+        },
+        headers: { 'Content-Type': 'application/json' },
+        status: 400,
+      },
+    };
+    const startTime = new Date();
+    const statTags = {
+      metadata: [],
+      destType: 'DT',
+      feature: 'feat',
+      endpointPath: '/some/url',
+      requestMethod: 'post',
+    };
+    expect(() => {
+      fireHTTPStats(clientResponse, startTime, statTags);
+    }).not.toThrow(Error);
+
+    expect(stats.timing).toHaveBeenCalledTimes(0);
+  });
+  it('should not throw error when metadata is sent as empty object', () => {
+    const clientResponse = {
+      success: false,
+      response: {
+        response: {
+          data: { errors: [{ e: 'something went bad' }] },
+          status: 400,
+          headers: { 'Content-Type': 'application/json' },
+        },
+        headers: { 'Content-Type': 'application/json' },
+        status: 400,
+      },
+    };
+    const startTime = new Date();
+    const statTags = {
+      metadata: {},
+      destType: 'DT',
+      feature: 'feat',
+      endpointPath: '/some/url',
+      requestMethod: 'post',
+    };
+    expect(() => {
+      fireHTTPStats(clientResponse, startTime, statTags);
+    }).not.toThrow(Error);
+
+    expect(stats.timing).toHaveBeenCalledTimes(1);
+    expect(stats.timing).toHaveBeenNthCalledWith(1, 'outgoing_request_latency', startTime, {
+      destType: 'DT',
+      feature: 'feat',
+      module: '',
+      endpointPath: '/some/url',
+      requestMethod: 'post',
+    });
+  });
+  it('should not throw error when metadata is sent as [null, null]', () => {
+    const clientResponse = {
+      success: false,
+      response: {
+        response: {
+          data: { errors: [{ e: 'something went bad' }] },
+          status: 400,
+          headers: { 'Content-Type': 'application/json' },
+        },
+        headers: { 'Content-Type': 'application/json' },
+        status: 400,
+      },
+    };
+    const startTime = new Date();
+    const statTags = {
+      metadata: [null, null],
+      destType: 'DT',
+      feature: 'feat',
+      endpointPath: '/some/url',
+      requestMethod: 'post',
+    };
+    expect(() => {
+      fireHTTPStats(clientResponse, startTime, statTags);
+    }).not.toThrow(Error);
+
+    expect(stats.timing).toHaveBeenCalledTimes(0);
+  });
+  it('should not throw error when metadata is sent as [1, 2]', () => {
+    const clientResponse = {
+      success: false,
+      response: {
+        response: {
+          data: { errors: [{ e: 'something went bad' }] },
+          status: 400,
+          headers: { 'Content-Type': 'application/json' },
+        },
+        headers: { 'Content-Type': 'application/json' },
+        status: 400,
+      },
+    };
+    const startTime = new Date();
+    const statTags = {
+      metadata: [1, 2],
+      destType: 'DT',
+      feature: 'feat',
+      endpointPath: '/some/url',
+      requestMethod: 'post',
+    };
+    expect(() => {
+      fireHTTPStats(clientResponse, startTime, statTags);
+    }).not.toThrow(Error);
+
+    expect(stats.timing).toHaveBeenCalledTimes(2);
+    expect(stats.timing).toHaveBeenNthCalledWith(1, 'outgoing_request_latency', startTime, {
+      destType: 'DT',
+      feature: 'feat',
+      module: '',
+      endpointPath: '/some/url',
+      requestMethod: 'post',
+    });
+    expect(stats.timing).toHaveBeenNthCalledWith(2, 'outgoing_request_latency', startTime, {
+      destType: 'DT',
+      feature: 'feat',
+      module: '',
+      endpointPath: '/some/url',
+      requestMethod: 'post',
+    });
+  });
+  it('should not throw error when metadata is sent as 1', () => {
+    const clientResponse = {
+      success: false,
+      response: {
+        response: {
+          data: { errors: [{ e: 'something went bad' }] },
+          status: 400,
+          headers: { 'Content-Type': 'application/json' },
+        },
+        headers: { 'Content-Type': 'application/json' },
+        status: 400,
+      },
+    };
+    const startTime = new Date();
+    const statTags = {
+      metadata: 1,
+      destType: 'DT',
+      feature: 'feat',
+      endpointPath: '/some/url',
+      requestMethod: 'post',
+    };
+    expect(() => {
+      fireHTTPStats(clientResponse, startTime, statTags);
+    }).not.toThrow(Error);
+
+    expect(stats.timing).toHaveBeenCalledTimes(1);
+    expect(stats.timing).toHaveBeenNthCalledWith(1, 'outgoing_request_latency', startTime, {
+      destType: 'DT',
+      feature: 'feat',
+      module: '',
+      endpointPath: '/some/url',
+      requestMethod: 'post',
+    });
+  });
+});
+
 describe('logging in http methods', () => {
   beforeEach(() => {
     mockLoggerInstance.info.mockClear();