@elisra-devops/docgen-data-provider 1.140.0 → 1.142.0

package/src/helpers/requestContext.ts

@@ -0,0 +1,222 @@
+import { redactValue } from '../utils/logger';
+import { CONTEXT_LIMITS } from '../utils/logSink';
+
+// What a failed Azure DevOps request looks like to whoever is triaging it. Built once, at the
+// TFSServices choke point, and attached to the thrown error — so every caller that logs that
+// error (however it words its own message) carries the same sanitized request description
+// into the log record and the diagnostics store, instead of only the call sites that happened
+// to print the URL themselves.
+export interface AdoRequestContext {
+  method?: string;
+  url?: string;
+  status?: number;
+  attempt?: number;
+  requestBody?: string;
+  responseExcerpt?: string;
+}
+
+const MAX_URL_LEN = CONTEXT_LIMITS.url;
+const MAX_BODY_LEN = CONTEXT_LIMITS.requestBody;
+const MAX_STRING_VALUE_LEN = 500;
+const MAX_ARRAY_ITEMS = 50;
+const MAX_PATCH_OPS = 20;
+const MAX_RESPONSE_LEN = CONTEXT_LIMITS.responseExcerpt;
+const MAX_TEXT_RESPONSE_LEN = 200;
+
+// Exact names, not a substring match — "key" must not mask a legitimate "keywords" parameter.
+const SENSITIVE_PARAM = /^(access_?token|token|pat|password|pwd|secret|sig|signature|api_?key|key|authorization|auth)$/i;
+
+const truncate = (text: string, max: number): string => (text.length > max ? `${text.slice(0, max)}…` : text);
+
+/** Strips credentials embedded in the URL and masks sensitive query parameter values. */
+export function sanitizeUrl(raw: unknown): string | undefined {
+  if (typeof raw !== 'string' || !raw) return undefined;
+  try {
+    const parsed = new URL(raw);
+    parsed.username = '';
+    parsed.password = '';
+    // Rewrite only the sensitive values in the raw query string — re-serializing through
+    // URLSearchParams would re-encode every other parameter ($depth, %20, +).
+    if (parsed.search) {
+      parsed.search = parsed.search
+        .slice(1)
+        .split('&')
+        .map((pair) => {
+          const eq = pair.indexOf('=');
+          if (eq < 0) return pair;
+          let name = pair.slice(0, eq);
+          try {
+            name = decodeURIComponent(name);
+          } catch {
+            // keep the raw name
+          }
+          return SENSITIVE_PARAM.test(name) ? `${pair.slice(0, eq)}=[REDACTED]` : pair;
+        })
+        .join('&');
+    }
+    return truncate(parsed.toString(), MAX_URL_LEN);
+  } catch {
+    return truncate(raw, MAX_URL_LEN);
+  }
+}
+
+/**
+ * Replaces each single-quoted WIQL literal with its length — the query structure (fields,
+ * operators, numbers, @macros) stays readable, free-text values never reach the logs.
+ * `''` is WIQL's escaped quote.
+ */
+export function maskWiqlLiterals(text: string): string {
+  return text.replace(/'(?:[^']|'')*'/g, (m) => `'[${m.length - 2} chars]'`);
+}
+
+function isBinaryLike(data: unknown): boolean {
+  return (
+    (typeof Buffer !== 'undefined' && Buffer.isBuffer(data)) ||
+    data instanceof ArrayBuffer ||
+    ArrayBuffer.isView(data as ArrayBufferView)
+  );
+}
+
+function isJsonPatch(data: unknown): data is Array<{ op: string; path: string }> {
+  return (
+    Array.isArray(data) &&
+    data.length > 0 &&
+    data.every(
+      (item) =>
+        item &&
+        typeof item === 'object' &&
+        typeof (item as Record<string, unknown>).op === 'string' &&
+        typeof (item as Record<string, unknown>).path === 'string'
+    )
+  );
+}
+
+function clampValues(value: unknown, depth = 0): unknown {
+  if (typeof value === 'string') return truncate(value, MAX_STRING_VALUE_LEN);
+  if (depth > 6 || value === null || typeof value !== 'object') return value;
+  if (Array.isArray(value)) {
+    const items = value.slice(0, MAX_ARRAY_ITEMS).map((v) => clampValues(v, depth + 1));
+    return value.length > MAX_ARRAY_ITEMS ? [...items, `…(+${value.length - MAX_ARRAY_ITEMS} more)`] : items;
+  }
+  const out: Record<string, unknown> = {};
+  for (const key of Object.keys(value as Record<string, unknown>)) {
+    out[key] = clampValues((value as Record<string, unknown>)[key], depth + 1);
+  }
+  return out;
+}
+
+/**
+ * A short, safe description of a request body — enough to see *what was asked* (the WIQL
+ * text, the id list) without ever carrying credentials or work-item content:
+ *  - GET/HEAD never have one.
+ *  - JSON-Patch arrays (work item / test case updates) keep only `op` + `path`; the `value`s
+ *    are real field content and are dropped.
+ *  - a WIQL `query` keeps its structure but its quoted literals are masked.
+ *  - other JSON goes through redactValue (credential-looking keys scrubbed at any depth),
+ *    with every string and the total length bounded.
+ *  - anything that isn't plain JSON is described by type and size only.
+ */
+export function summarizeBody(data: unknown, method?: string): string | undefined {
+  const verb = String(method || '').toUpperCase();
+  if (verb === 'GET' || verb === 'HEAD') return undefined;
+  if (data === undefined || data === null || data === '') return undefined;
+
+  if (typeof data === 'string') {
+    try {
+      const parsed = JSON.parse(data);
+      return typeof parsed === 'string' ? `[text, ${data.length} chars]` : summarizeBody(parsed, method);
+    } catch {
+      return `[text, ${data.length} chars]`;
+    }
+  }
+  if (typeof data !== 'object') return `[${typeof data}]`;
+  if (isBinaryLike(data)) {
+    const size = (data as { byteLength?: number }).byteLength;
+    return `[binary${typeof size === 'number' ? `, ${size} bytes` : ''}]`;
+  }
+  if (typeof (data as { pipe?: unknown }).pipe === 'function') return '[stream]';
+  if (typeof FormData !== 'undefined' && data instanceof FormData) return '[form-data]';
+
+  if (isJsonPatch(data)) {
+    const ops = data.slice(0, MAX_PATCH_OPS).map((o) => `${o.op} ${o.path}`);
+    const more = data.length > MAX_PATCH_OPS ? ` …(+${data.length - MAX_PATCH_OPS} more)` : '';
+    return truncate(`json-patch (${data.length} ops, values omitted): ${ops.join('; ')}${more}`, MAX_BODY_LEN);
+  }
+  if (Array.isArray(data) ? data.length === 0 : Object.keys(data).length === 0) return undefined;
+
+  try {
+    const body =
+      !Array.isArray(data) && typeof (data as { query?: unknown }).query === 'string'
+        ? { ...(data as Record<string, unknown>), query: maskWiqlLiterals((data as { query: string }).query) }
+        : data;
+    return truncate(JSON.stringify(clampValues(redactValue(body))), MAX_BODY_LEN);
+  } catch {
+    return '[unserializable body]';
+  }
+}
+
+/** The server's own explanation of the failure (ADO puts it in `message`), bounded. */
+export function summarizeResponse(data: unknown): string | undefined {
+  if (data === undefined || data === null) return undefined;
+  if (typeof data === 'string') return truncate(data, MAX_TEXT_RESPONSE_LEN);
+  if (isBinaryLike(data)) return undefined;
+  if (typeof (data as { pipe?: unknown }).pipe === 'function') return '[stream]';
+  try {
+    const message = (data as { message?: unknown }).message;
+    if (typeof message === 'string') return truncate(message, MAX_RESPONSE_LEN);
+    return truncate(JSON.stringify(redactValue(data)), MAX_RESPONSE_LEN);
+  } catch {
+    return '[unserializable response data]';
+  }
+}
+
+export function buildAdoRequestContext(
+  error: any,
+  request: { method?: string; url?: string; data?: unknown },
+  attempt?: number
+): AdoRequestContext {
+  const method = String(request.method || error?.config?.method || 'get').toUpperCase();
+  const context: AdoRequestContext = { method, url: sanitizeUrl(request.url ?? error?.config?.url) };
+  const status = Number(error?.response?.status);
+  if (Number.isFinite(status) && status > 0) context.status = status;
+  if (attempt !== undefined) context.attempt = attempt;
+  const requestBody = summarizeBody(request.data, method);
+  if (requestBody) context.requestBody = requestBody;
+  const responseExcerpt = summarizeResponse(error?.response?.data);
+  if (responseExcerpt) context.responseExcerpt = responseExcerpt;
+  return context;
+}
+
+/**
+ * Attaches the context as an enumerable own property: winston's errors() / log() merge an
+ * Error's own enumerable properties onto the log record, which is how the transport and the
+ * text formatter find it without every call site having to pass it along.
+ */
+export function annotateAdoError<T>(error: T, context: AdoRequestContext): T {
+  if (error && typeof error === 'object') {
+    try {
+      Object.defineProperty(error, 'adoRequest', { value: context, enumerable: true, configurable: true, writable: true });
+    } catch {
+      // A frozen/exotic error object just goes unannotated — never worth failing the request path.
+    }
+  }
+  return error;
+}
+
+/**
+ * The log metadata for a caught error: message, stack, code, and the request description when
+ * the error came through TFSServices. Deliberately NOT the error object itself — passing a
+ * whole AxiosError would merge its entire config/request/response graph onto the record.
+ * winston concatenates meta.message onto the call's own message, so
+ * `logger.error('Could not fetch X:', describeError(err))` reads the same as the old
+ * `logger.error(\`Could not fetch X: ${err.message}\`)` — plus the request, which a message
+ * string can't carry.
+ */
+export function describeError(error: unknown): Record<string, unknown> {
+  if (!error || typeof error !== 'object') return { message: String(error) };
+  const e = error as Record<string, unknown>;
+  const meta: Record<string, unknown> = { message: e.message, stack: e.stack };
+  if (typeof e.code === 'string') meta.code = e.code;
+  if (e.adoRequest) meta.adoRequest = e.adoRequest;
+  return meta;
+}

package/src/helpers/tfs.ts

@@ -1,5 +1,6 @@
 import axios, { AxiosInstance, AxiosRequestConfig } from 'axios';
 import logger from '../utils/logger';
+import { AdoRequestContext, annotateAdoError, buildAdoRequestContext } from './requestContext';
 
 // Environment detection
 const isNode = typeof window === 'undefined' && typeof process !== 'undefined' && process.versions?.node;
@@ -83,7 +84,7 @@ export class TFSServices {
       return res;
     } catch (e) {
       logger.error(`error download zip file , url : ${url}`);
-      throw new Error(String(e));
+      throw annotateAdoError(new Error(String(e)), buildAdoRequestContext(e, { method: 'GET', url }));
     }
   }
 
@@ -178,7 +179,7 @@ export class TFSServices {
       const result = await this.axiosInstance.request(config);
       return result.data;
     } catch (e: any) {
-      this.logDetailedError(e, url);
+      this.reportFailure(e, { method: 'GET', url });
       throw e;
     }
   }
@@ -203,7 +204,7 @@ export class TFSServices {
       const result = await this.axiosInstance.request(config);
       return result;
     } catch (e: any) {
-      this.logDetailedError(e, url);
+      this.reportFailure(e, { method: requestMethod, url, data });
       throw e;
     }
   }
@@ -246,10 +247,9 @@ export class TFSServices {
           continue;
         }
 
-        // Log error if needed
-        if (printError) {
-          this.logDetailedError(e, url);
-        }
+        // Always annotate (so any caller that logs this error — however it words its own
+        // message — carries the request), log the dedicated record only when asked to.
+        this.reportFailure(e, { method: config.method, url, data: config.data }, attempts, printError);
 
         throw e;
       }
@@ -284,27 +284,33 @@ export class TFSServices {
   }
 
   /**
-   * Log detailed error information
+   * Describes the failed request once, attaches it to the error, and (optionally) emits the one
+   * dedicated "ADO request failed" record.
    */
-  private static logDetailedError(error: any, url: string): void {
-    if (error.response) {
-      logger.error(`Error for ${url} - ${error.message}`);
-      logger.error(`Status: ${error.response.status}`);
-
-      if (error.response.data) {
-        if (typeof error.response.data === 'string') {
-          logger.error(`Response: ${error.response.data.substring(0, 200)}`);
-        } else {
-          const dataMessage =
-            error.response.data.message || JSON.stringify(error.response.data).substring(0, 200);
-          logger.error(`Response: ${dataMessage}`);
-        }
-      }
-    } else {
-      logger.error(`Error for ${url} - ${error.message}`);
+  private static reportFailure(
+    error: any,
+    request: { method?: string; url: string; data?: unknown },
+    attempt?: number,
+    print: boolean = true
+  ): void {
+    const context = buildAdoRequestContext(error, request, attempt);
+    annotateAdoError(error, context);
+    if (print) {
+      this.logDetailedError(error, context);
     }
   }
 
+  /**
+   * Log detailed error information
+   */
+  private static logDetailedError(error: any, context: AdoRequestContext): void {
+    logger.error('ADO request failed', {
+      message: error?.message,
+      stack: error?.stack,
+      adoRequest: context,
+    });
+  }
+
   private static getErrorMessage(error: any): string {
     if (error.response?.data?.message) {
       return JSON.stringify(error.response.data.message);

package/src/modules/GitDataProvider.ts

@@ -1,6 +1,7 @@
 import { TFSServices } from '../helpers/tfs';
 import TicketsDataProvider from './TicketsDataProvider';
 import logger from '../utils/logger';
+import { describeError } from '../helpers/requestContext';
 import {
   createLinkedRelation,
   createRequirementRelation,
@@ -124,7 +125,7 @@ export default class GitDataProvider {
       }
       return undefined;
     } catch (err: any) {
-      logger.warn(`File ${fileName} could not be read: ${err.message}`);
+      logger.warn(`File ${fileName} could not be read:`, describeError(err));
       return undefined;
     }
   }
@@ -1119,7 +1120,7 @@ export default class GitDataProvider {
         submodules.push(subModule);
       }
     } catch (error: any) {
-      logger.error(`Error in getSubmodulesData: ${error.message}`);
+      logger.error('Error in getSubmodulesData:', describeError(error));
     } finally {
       return submodules;
     }

package/src/modules/JfrogDataProvider.ts

@@ -1,6 +1,7 @@
 import { TFSServices } from '../helpers/tfs';
 
 import logger from '../utils/logger';
+import { describeError } from '../helpers/requestContext';
 
 export default class JfrogDataProvider {
   orgUrl: string = '';
@@ -19,7 +20,7 @@ export default class JfrogDataProvider {
     if (!serviceConnectionResponse?.url) {
       throw new Error(`Service connection ${connectionId} returned no URL — identity may lack service-endpoint read permission`);
     }
-    logger.debug(`service connection url ${JSON.stringify(serviceConnectionResponse.url)}`);
+    logger.debug(`service connection url ${serviceConnectionResponse.url}`);
     return serviceConnectionResponse.url;
   }
 
@@ -56,7 +57,7 @@ export default class JfrogDataProvider {
       logger.debug(`CI Url from JFROG: ${getCiResponse.buildInfo.url}`);
       return getCiResponse.buildInfo.url;
     } catch (err: any) {
-      logger.error(`Error occurred during querying JFrog using: ${err.message}`);
+      logger.error('Error occurred during querying JFrog using:', describeError(err));
       throw err;
     }
   }

package/src/modules/PipelinesDataProvider.ts

@@ -2,6 +2,7 @@ import { PipelineRun, Repository, ResourceRepository } from '../models/tfs-data'
 import { TFSServices } from '../helpers/tfs';
 
 import logger from '../utils/logger';
+import { describeError } from '../helpers/requestContext';
 import GitDataProvider from './GitDataProvider';
 const pLimit = require('p-limit');
 const MAX_DISCOVERY_PAGES = 50;
@@ -1252,7 +1253,7 @@ export default class PipelinesDataProvider {
       },
       parameters: parameter, //'{"Test":"123"}'
     };
-    logger.info(JSON.stringify(data));
+    logger.info('Triggering build', data);
     let url = `${this.orgUrl}${projectName}/_apis/build/builds?api-version=5.0`;
     let res = await TFSServices.postRequest(url, this.token, 'post', data, null);
     return res;
@@ -1331,7 +1332,7 @@ export default class PipelinesDataProvider {
       }
       return res;
     } catch (err: any) {
-      logger.error(`Could not fetch Pipeline Run History: ${err.message}`);
+      logger.error('Could not fetch Pipeline Run History:', describeError(err));
     }
   }
 
@@ -1401,7 +1402,7 @@ export default class PipelinesDataProvider {
         // Azure DevOps returns continuation token header for next page
         continuationToken = this.getContinuationToken(headers);
       } catch (err: any) {
-        logger.error(`GetAllReleaseHistory failed: ${err.message}`);
+        logger.error('GetAllReleaseHistory failed:', describeError(err));
         throw err;
       }
     } while (continuationToken);
@@ -1463,7 +1464,7 @@ export default class PipelinesDataProvider {
         }
       }
     } catch (err: any) {
-      logger.error(`Error fetching pipeline ${pipelineRunId} with url ${url} : ${err.message}`);
+      logger.error(`Error fetching pipeline ${pipelineRunId} with url ${url} :`, describeError(err));
       return undefined;
     }
   }

package/src/modules/ResultDataProvider.ts

@@ -22,6 +22,7 @@ import type {
   MewpRunStatus,
 } from '../models/mewp-reporting';
 import logger from '../utils/logger';
+import { describeError } from '../helpers/requestContext';
 import MewpExternalIngestionUtils from '../utils/mewpExternalIngestionUtils';
 import MewpExternalTableUtils, {
   MewpExternalFileValidationError,
@@ -139,7 +140,7 @@ export default class ResultDataProvider {
           this.fetchTestPoints(projectName, testPlanId, suite.testSuiteId)
             .then((testPointsItems) => ({ ...suite, testPointsItems }))
             .catch((error: any) => {
-              logger.error(`Error occurred for suite ${suite.testSuiteId}: ${error.message}`);
+              logger.error(`Error occurred for suite ${suite.testSuiteId}:`, describeError(error));
               return { ...suite, testPointsItems: [] };
             })
         )
@@ -259,10 +260,22 @@ export default class ResultDataProvider {
 
       return { combinedResults, openPcrToTestCaseTraceMap, testCaseToOpenPcrTraceMap };
     } catch (error: any) {
-      logger.error(`Error during getCombinedResultsSummary: ${error.message}`);
+      // One event, one record — this used to be two separate calls (message, then
+      // conditionally the response body), which interleave with other requests' output
+      // under concurrency and become two unrelated entries in the dashboard's error grouping.
+      let responseSummary: string | undefined;
       if (error.response) {
-        logger.error(`Response Data: ${JSON.stringify(error.response.data)}`);
+        // Truncated to match the bound already used for this in tfs.ts — an untruncated ADO
+        // response body isn't a credential, but it can still be large/sensitive work-item content
+        // and doesn't need to go into logs unbounded. JSON.stringify itself (not just the
+        // output) can throw on a circular value, so that has to be guarded too, not just capped.
+        try {
+          responseSummary = JSON.stringify(error.response.data).substring(0, 200);
+        } catch {
+          responseSummary = '[unserializable response data]';
+        }
       }
+      logger.error('Error during getCombinedResultsSummary:', { ...describeError(error), responseSummary });
       // Ensure the error is rethrown to propagate it correctly
       throw new Error(error.message || 'Unknown error occurred during getCombinedResultsSummary');
     }
@@ -390,7 +403,7 @@ export default class ResultDataProvider {
 
       return fetchedTestResults;
     } catch (error: any) {
-      logger.error(`Error during getTestReporterResults: ${error.message}`);
+      logger.error('Error during getTestReporterResults:', describeError(error));
     }
   }
 
@@ -431,7 +444,7 @@ export default class ResultDataProvider {
 
       return { planId: testPlanId, planName, rows: rows || [] };
     } catch (error: any) {
-      logger.error(`Error during getTestReporterFlatResults: ${error.message}`);
+      logger.error('Error during getTestReporterFlatResults:', describeError(error));
       return { planId: testPlanId, planName: '', rows: [] };
     }
   }
@@ -733,7 +746,7 @@ export default class ResultDataProvider {
         rows,
       };
     } catch (error: any) {
-      logger.error(`Error during getMewpL2CoverageFlatResults: ${error.message}`);
+      logger.error('Error during getMewpL2CoverageFlatResults:', describeError(error));
       if (error instanceof MewpExternalFileValidationError) {
         throw error;
       }
@@ -1110,7 +1123,7 @@ export default class ResultDataProvider {
         rows,
       };
     } catch (error: any) {
-      logger.error(`Error during getMewpInternalValidationFlatResults: ${error.message}`);
+      logger.error('Error during getMewpInternalValidationFlatResults:', describeError(error));
       return defaultPayload;
     }
   }
@@ -3059,7 +3072,7 @@ export default class ResultDataProvider {
       const testPlan = await TFSServices.getItemContent(url, this.token);
       return testPlan.name;
     } catch (error: any) {
-      logger.error(`Error during fetching Test Plan Name: ${error.message}`);
+      logger.error('Error during fetching Test Plan Name:', describeError(error));
       return '';
     }
   }
@@ -3107,7 +3120,7 @@ export default class ResultDataProvider {
         };
       });
     } catch (error: any) {
-      logger.error(`Error during fetching Test Suites: ${error.message}`);
+      logger.error('Error during fetching Test Suites:', describeError(error));
       return [];
     }
   }
@@ -3261,8 +3274,7 @@ export default class ResultDataProvider {
       );
       return detailedPoints;
     } catch (err: any) {
-      logger.error(`Error during fetching Cross Test Points: ${err.message}`);
-      logger.error(`Error stack: ${err.stack}`);
+      logger.error('Error during fetching Cross Test Points', err);
       return [];
     }
   }
@@ -3281,7 +3293,7 @@ export default class ResultDataProvider {
 
       return count !== 0 ? testPoints.map((testPoint: any) => this.mapTestPoint(testPoint, projectName)) : [];
     } catch (error: any) {
-      logger.error(`Error during fetching Test Points: ${error.message}`);
+      logger.error('Error during fetching Test Points:', describeError(error));
       return [];
     }
   }
@@ -3903,10 +3915,7 @@ export default class ResultDataProvider {
         relatedCRs,
       };
     } catch (error: any) {
-      logger.error(`Error while fetching run result: ${error.message}`);
-      if (isTestReporter) {
-        logger.error(`Error stack: ${error.stack}`);
-      }
+      logger.error('Error while fetching run result', error);
       return null;
     }
   }
@@ -4465,7 +4474,7 @@ export default class ResultDataProvider {
             relatedCRs.push({ id, title, workItemType: 'Change Request', url });
           }
         } catch (err: any) {
-          logger.error(`Could not append related work item to test case ${wiByRevision.id}: ${err.message}`);
+          logger.error(`Could not append related work item to test case ${wiByRevision.id}:`, describeError(err));
         }
       }
     }
@@ -4595,7 +4604,7 @@ export default class ResultDataProvider {
           ? testCase.workItem.workItemFields
           : [];
         if (testCaseWorkItemFields.length === 0) {
-          logger.warn(`Could not fetch the steps from WI ${JSON.stringify(testCase.workItem.id)}`);
+          logger.warn(`Could not fetch the steps from WI ${testCase.workItem.id}`);
           if (!isTestReporter) {
             continue;
           }
@@ -4848,7 +4857,7 @@ export default class ResultDataProvider {
 
             return { ...suite, testPointsItems, testCasesItems };
           } catch (error: any) {
-            logger.error(`Error occurred for suite ${suite.testSuiteId}: ${error.message}`);
+            logger.error(`Error occurred for suite ${suite.testSuiteId}:`, describeError(error));
             return suite;
           }
         })
@@ -5058,8 +5067,7 @@ export default class ResultDataProvider {
         ? createResponseObject(resultData, testSuiteId, point, ...additionalArgs)
         : null;
     } catch (error: any) {
-      logger.error(`Error occurred for point ${point.testCaseId}: ${error.message}`);
-      logger.error(`Stack trace: ${error.stack}`);
+      logger.error(`Error occurred for point ${point.testCaseId}`, error);
       return null;
     }
   }
@@ -5153,8 +5161,7 @@ export default class ResultDataProvider {
           summarizedItemMap.set(wi.id, mappedItem);
         }
       } catch (error: any) {
-        logger.error(`Error occurred while fetching linked work items: ${error.message}`);
-        logger.error(`Error Stack: ${error.stack}`);
+        logger.error('Error occurred while fetching linked work items', error);
       }
     }
 
@@ -5826,8 +5833,7 @@ export default class ResultDataProvider {
           }
           return resultDataResponse;
         } catch (err: any) {
-          logger.error(`Error occurred while fetching result data: ${err.message}`);
-          logger.error(`Error stack: ${err.stack}`);
+          logger.error('Error occurred while fetching result data', err);
           return null;
         }
       },

package/src/modules/TestDataProvider.ts

@@ -4,6 +4,7 @@ import { TestSteps, createMomRelation, createRequirementRelation } from '../mode
 import { TestCase } from '../models/tfs-data';
 import * as xml2js from 'xml2js';
 import logger from '../utils/logger';
+import { describeError } from '../helpers/requestContext';
 import Utils from '../utils/testStepParserHelper';
 import DataProviderUtils from '../utils/DataProviderUtils';
 const pLimit = require('p-limit');
@@ -56,7 +57,7 @@ export default class TestDataProvider {
 
       return result;
     } catch (error: any) {
-      logger.error(`Error fetching ${url}: ${error.message}`);
+      logger.error(`Error fetching ${url}:`, describeError(error));
       throw error;
     }
   }
@@ -187,7 +188,7 @@ export default class TestDataProvider {
     try {
       return await this.fetchWithCache(testsuitesUrl);
     } catch (e: any) {
-      logger.error(`Failed to get test suites: ${e.message}`);
+      logger.error('Failed to get test suites:', describeError(e));
       return null;
     }
   }
@@ -599,7 +600,7 @@ export default class TestDataProvider {
         }
       }
     } catch (err: any) {
-      logger.error(`Error: ${err.message} while trying to structure testCases for test suite ${suite.id}`);
+      logger.error(`Error while trying to structure testCases for test suite ${suite.id}:`, describeError(err));
     }
 
     return testCasesUrlList;