[MOB-46781] Parse actionId for errors

devership16 · devership16 · commit dbcbd6412334 · 2026-02-20T13:57:53.000+05:30
- Jira: https://perforce.atlassian.net/browse/MOB-46781
diff --git a/bzt/modules/_apiritif/generator.py b/bzt/modules/_apiritif/generator.py
@@ -62,6 +62,75 @@ def create_method_name(label):
 
 
 class ApiritifScriptGenerator(object):
+    def _gen_class_actionid_tracking(self):
+        # Add _current_actionId to the class and update it on each action_start
+        return [
+            ast.Assign(
+                targets=[ast_attr("self._current_actionId")],
+                value=ast.Constant(value=None, kind="")
+            )
+        ]
+
+    def _gen_action_start_with_tracking(self, actionId):
+        # Assign actionId to self._current_actionId before action_start
+        return [
+            ast.Assign(
+                targets=[ast_attr("self._current_actionId")],
+                value=ast.Constant(value=actionId, kind="")
+            )
+        ]
+
+    def _gen_teardown_with_actionid(self):
+        # Print the last actionId if an error occurred
+        return ast.FunctionDef(
+            name="tearDown",
+            args=[ast.Name(id='self', ctx=ast.Param())],
+            body=[
+                ast.If(
+                    test=ast_attr("self.driver"),
+                    body=[ast.Expr(ast_call(func=ast_attr("self.driver.quit")))],
+                    orelse=[]
+                ),
+                ast.If(
+                    test=ast.Call(
+                        func=ast.Name(id="hasattr", ctx=ast.Load()),
+                        args=[ast.Name(id="self", ctx=ast.Load()), ast.Constant("_outcome", kind="")],
+                        keywords=[]
+                    ),
+                    body=[
+                        ast.If(
+                            test=ast.Attribute(
+                                value=ast.Attribute(
+                                    value=ast.Name(id="self", ctx=ast.Load()),
+                                    attr="_outcome",
+                                    ctx=ast.Load()
+                                ),
+                                attr="errors",
+                                ctx=ast.Load()
+                            ),
+                            body=[
+                                ast.Expr(ast_call(
+                                    func=ast.Name(id="print", ctx=ast.Load()),
+                                    args=[ast.BinOp(
+                                        left=ast.Constant("[TAURUS][actionId] ", kind=""),
+                                        op=ast.Add(),
+                                        right=ast.Call(
+                                            func=ast.Name(id="str", ctx=ast.Load()),
+                                            args=[ast_attr("self._current_actionId")],
+                                            keywords=[]
+                                        )
+                                    )],
+                                    keywords=[]
+                                ))
+                            ],
+                            orelse=[]
+                        )
+                    ],
+                    orelse=[]
+                )
+            ],
+            decorator_list=[]
+        )
     BYS = {
         'xpath': "XPATH",
         'css': "CSS_SELECTOR",
diff --git a/bzt/modules/aggregator.py b/bzt/modules/aggregator.py
@@ -232,6 +232,7 @@ def __init__(self, perc_levels=(), hist_max_rt=1000.0, ext_aggregation=False):
         self[KPISet.RESP_CODES] = Counter()
         self[KPISet.PERCENTILES] = {}
         self.ext_aggregation = ext_aggregation
+        self.log = logging.getLogger(self.__class__.__name__)
 
     def __deepcopy__(self, memo):
         mycopy = KPISet(self.perc_levels, self[KPISet.RESP_TIMES].high)
@@ -248,10 +249,12 @@ def __deepcopy__(self, memo):
     @staticmethod
     def error_item_skel(
             error: str, ret_c: str, cnt: int, err_type: int,
-            urls: Counter, tag: str, err_resp_data: Optional[ErrorResponseData] = None) -> dict:
+            urls: Counter, tag: str, err_resp_data: Optional[ErrorResponseData] = None, action_id: str = None) -> dict:
         assert isinstance(urls, collections.Counter)
+        logging.getLogger("DEV DEV").info("In error_item_skel, err_resp_data: {}".format(err_resp_data))
         response_bodies = KPISet._get_response_bodies(err_resp_data)
-        return {
+        logging.getLogger("DEV DEV").info("In error_item_skel, response_bodies: {}".format(response_bodies))
+        item = {
             "cnt": cnt,
             "msg": error,
             "tag": tag,  # just one more string qualifier
@@ -260,6 +263,9 @@ def error_item_skel(
             "urls": urls,
             "responseBodies": response_bodies
         }
+        if action_id is not None:
+            item["action_id"] = action_id
+        return item
 
     @staticmethod
     def _get_response_bodies(err_resp_data: Optional[ErrorResponseData]) -> list:
@@ -276,11 +282,15 @@ def _get_response_bodies(err_resp_data: Optional[ErrorResponseData]) -> list:
 
     def add_sample(self, sample):
         """
-        Add sample, consisting of: cnc, rt, cn, lt, rc, error, trname, byte_count
+        Add sample, consisting of: cnc, rt, cn, lt, rc, error, trname, byte_count, [action_id]
 
         :type sample: tuple
         """
-        cnc, r_time, con_time, latency, r_code, error, trname, byte_count = sample
+        if len(sample) == 9:
+            cnc, r_time, con_time, latency, r_code, error, trname, byte_count, action_id = sample
+        else:
+            cnc, r_time, con_time, latency, r_code, error, trname, byte_count = sample
+            action_id = None
         self[self.SAMPLE_COUNT] += 1
         if cnc:
             self.add_concurrency(cnc, trname)
@@ -297,8 +307,19 @@ def add_sample(self, sample):
 
         if error is not None:
             self[self.FAILURES] += 1
-
-            item = self.error_item_skel(error, r_code, 1, KPISet.ERRTYPE_ERROR, Counter(), None)
+            self.log.info(f"DEV DEV: error: {error}")
+            self.log.info(f"DEV DEV: r_code: {r_code}")
+            self.log.info(f"DEV DEV: error: {error}")
+            self.log.info(f"DEV DEV: action_id: {action_id}")
+            item = self.error_item_skel(
+                error,
+                r_code,
+                1,
+                KPISet.ERRTYPE_ERROR,
+                Counter(),
+                None,
+                action_id=action_id)
+            self.log.info(f"DEV DEV: item: {item}")
             self.inc_list(self[self.ERRORS], ("msg", error), item)
         else:
             self[self.SUCCESSES] += 1
@@ -739,7 +760,7 @@ def __aggregate_current(self, datapoint, samples):
 
             if self.generalize_labels:
                 base_label = self._generalize_label(base_label)
-
+            self.log.info(f"Sample: {sample}")
             self.__add_sample(current, base_label, sample[1:])
 
         overall = KPISet(self.track_percentiles, self.__get_rtimes_max(''), ext_aggregation=self._redundant_aggregation)
@@ -767,7 +788,7 @@ def __add_sample(self, current, label, kpis):
                 perc_levels=self.track_percentiles,
                 hist_max_rt=self.__get_rtimes_max(label),
                 ext_aggregation=self._redundant_aggregation)
-
+        self.log.info(f"kpis: {kpis}")
         current[label].add_sample(kpis)
 
     def __get_rtimes_max(self, label):
diff --git a/bzt/modules/functional.py b/bzt/modules/functional.py
@@ -18,7 +18,8 @@
 from bzt.engine import Aggregator
 from bzt.modules.aggregator import ResultsReader
 from bzt.utils import BetterDict, iteritems, LDJSONReader
-
+import pprint
+import logging
 
 class FunctionalAggregator(Aggregator):
     """
@@ -35,10 +36,12 @@ def __init__(self):
 
     def add_underling(self, reader):
         assert isinstance(reader, FunctionalResultsReader)
+        self.log.info("DEV DEV: adding underling: %s", pprint.pformat(vars(reader)))
         self.underlings.append(reader)
 
     def add_listener(self, listener):
         assert isinstance(listener, FunctionalAggregatorListener)
+        self.log.info("DEV DEV: adding listener: %s", pprint.pformat(vars(listener)))
         self.listeners.append(listener)
 
     def prepare(self):
@@ -49,11 +52,13 @@ def process_readers(self, last_pass=False):
 
         for reader in self.underlings:
             for sample in reader.read(last_pass):
+                self.log.info("DEV DEV: sample in process: %s", pprint.pformat(sample.__dict__))
                 new_results.add_sample(sample)
 
         if new_results:
             self.cumulative_results.merge(new_results)
             for listener in self.listeners:
+                self.log.info("DEV DEV: functional aggregated_results: %s", pprint.pformat(self.cumulative_results.__dict__))
                 listener.aggregated_results(new_results, self.cumulative_results)
 
     def check(self):
@@ -65,10 +70,20 @@ def post_process(self):
 
 
 class FunctionalSample(object):
+    def to_error_dict(self):
+        err = {
+            "error_msg": self.error_msg,
+            "error_trace": self.error_trace,
+            "status": self.status,
+        }
+        if getattr(self, "actionId", None):
+            err["actionId"] = self.actionId
+        return err
+
     def __init__(
             self, test_case, test_suite, status,
             start_time, duration, error_msg, error_trace,
-            extras=None, subsamples=None, path=None,
+            extras=None, subsamples=None, path=None, actionId=None
     ):
         # test_case: str - name of test case (method)
         # test_suite: str - name of test suite (class)
@@ -90,6 +105,7 @@ def __init__(
         self.extras = extras or {}
         self.subsamples = subsamples or []
         self.path = path or []
+        self.actionId = actionId
 
     def get_fqn(self):
         if self.path:
@@ -112,18 +128,25 @@ def get_type(self):
 class ResultsTree(BetterDict):
     def __init__(self):
         super(ResultsTree, self).__init__()
+        self.log = logging.getLogger(self.__class__.__name__)
 
     def add_sample(self, sample):
         """
         :type sample: FunctionalSample
         """
         test_suite = sample.test_suite
+        self.log.info("DEV DEV: adding sample to suite: %s", pprint.pformat(vars(sample)))
+        self.log.info("DEV DEV: test_suite: %s", pprint.pformat(test_suite))
+        if hasattr(sample, "error_msg") and sample.error_msg:
+            self.log.info("DEV DEV: Adding error sample with error dict: %s", sample.to_error_dict())
         self.get(test_suite, [], force_set=True).append(sample)
 
     def test_suites(self):
         return [key for key, _ in iteritems(self)]
 
     def test_cases(self, suite_name):
+        test_cases = self.get(suite_name, [])
+        self.log.info("DEV DEV: In results tree test_cases: %s", [sample.to_error_dict() for sample in test_cases])
         return self.get(suite_name, [])
 
 
@@ -237,6 +260,8 @@ class FuncSamplesReader(FunctionalResultsReader):
     FIELDS_EXTRACTED_TO_ARTIFACTS = ["requestBody", "responseBody", "requestCookiesRaw"]
 
     def __init__(self, filename, engine, parent_logger):
+        import logging
+        self.log = logging.getLogger(self.__class__.__name__)
         self.report_reader = TestReportReader(filename, parent_logger)
         self.engine = engine
         self.read_records = 0
@@ -257,14 +282,29 @@ def _write_sample_data_to_artifacts(self, sample_extras):
 
     def _samples_from_row(self, row):
         result = []
+        self.log.info("DEV DEV: In _samples_from_row, row: %s", pprint.pformat(row))
         subsamples = [sample for item in row.get("subsamples", []) for sample in self._samples_from_row(item)]
         if any(subsample.get_type() == 'transaction' for subsample in subsamples):
+            self.log.info("DEV DEV: In _samples_from_row if")
+            for sub in subsamples:
+                if sub.get_type() == 'transaction':
+                    self.log.info("DEV DEV: transaction subsample actionId: %s", getattr(sub, 'actionId', None))
             result.extend([sub for sub in subsamples if sub.get_type() == 'transaction'])
         else:
-            sample = FunctionalSample(test_case=row["test_case"], test_suite=row["test_suite"],
-                                      status=row["status"], start_time=row["start_time"], duration=row["duration"],
-                                      error_msg=row["error_msg"], error_trace=row["error_trace"],
-                                      extras=row.get("extras", {}), subsamples=subsamples, path=row.get("path", []))
+            self.log.info("DEV DEV: In _samples_from_row else")
+            sample = FunctionalSample(
+                test_case=row["test_case"],
+                test_suite=row["test_suite"],
+                status=row["status"],
+                start_time=row["start_time"],
+                duration=row["duration"],
+                error_msg=row["error_msg"],
+                error_trace=row["error_trace"],
+                extras=row.get("extras", {}),
+                subsamples=subsamples,
+                path=row.get("path", []),
+                actionId=row.get("actionId") or row.get("action_id")
+            )
             result.append(sample)
         return result
 
diff --git a/bzt/modules/reporting.py b/bzt/modules/reporting.py
@@ -17,10 +17,12 @@
 """
 import copy
 import csv
+import logging
 import os
 import time
 from collections import Counter, OrderedDict
 from datetime import datetime
+import pprint
 
 from terminaltables3 import AsciiTable
 
@@ -46,6 +48,7 @@ def __init__(self):
         self.end_time = time.time()
         self.first_ts = float("inf")
         self.last_ts = 0
+        self.log = logging.getLogger(self.__class__.__name__)
 
     def startup(self):
         self.start_time = time.time()
@@ -74,6 +77,7 @@ def aggregated_results(self, results, cumulative_results):
         :type cumulative_results: bzt.modules.functional.ResultsTree
         :type results: bzt.modules.functional.ResultsTree
         """
+        self.log.info("DEV DEV: Final aggregated_results: %s", pprint.pformat(vars(cumulative_results)))
         self.cumulative_results = cumulative_results
 
     def shutdown(self):
@@ -87,11 +91,11 @@ def post_process(self):
 
         if self.parameters.get("test-duration", True):
             self.__report_duration()
-
+        self.log.info("DEV DEV: Reached in postprocess of FinalStatus")
         if self.last_sec:
             if '' in self.last_sec[DataPoint.CUMULATIVE]:
                 summary_kpi = self.last_sec[DataPoint.CUMULATIVE][""]
-
+                self.log.info(f"DEV DEV: summary_kpi: {summary_kpi}")
                 if self.parameters.get("summary", True):
                     self.__report_samples_count(summary_kpi)
                 if self.parameters.get("percentiles", True):
@@ -136,11 +140,15 @@ def __report_all_tests(self):
                     self.log.info("Stacktrace:\n%s", case.error_trace)
 
     def __report_failed_tests(self):
+        self.log.info("DEV DEV: __report_failed_tests:")
         for test_suite in self.cumulative_results.test_suites():
             for case in self.cumulative_results.test_cases(test_suite):
+                self.log.info("DEV DEV: case: %s", pprint.pformat(vars(case)))
                 if case.status in ("FAILED", "BROKEN"):
                     full_name = case.test_suite + "." + case.test_case
                     msg = "Test {test_case} failed: {error_msg}".format(test_case=full_name, error_msg=case.error_msg)
+                    if hasattr(case, "action_id") and case.action_id:
+                        msg += f"\nAction ID: {case.action_id}"
                     if case.error_trace:
                         msg += "\n" + case.error_trace
                     self.log.warning(msg)
@@ -182,6 +190,7 @@ def __report_failed_labels(self, cumulative):
         """
         reports failed labels
         """
+        self.log.info(f"DEV DEV: cumulative: {cumulative}")
         report_template = "%d failed samples: %s"
         sorted_labels = sorted(cumulative.keys())
         for sample_label in sorted_labels:
@@ -196,6 +205,7 @@ def __get_sample_element(self, sample, label_name):
         total_samples_count = failed_samples_count + success_samples_count
         assert total_samples_count > 0, "Total samples is zero for %s" % label_name
         success_samples_perc = (success_samples_count * 100) / total_samples_count
+        self.log.info(f"DEV DEV: sample: {sample}, label_name: {label_name}, failed_samples_count: {failed_samples_count}, success_samples_count: {success_samples_count}, total_samples_count: {total_samples_count}, success_samples_perc: {success_samples_perc}")
 
         errors = set()
         for err_desc in sample['errors']:
@@ -403,6 +413,7 @@ def aggregated_results(self, _, cumulative_results):
         """
         :type cumulative_results: bzt.modules.functional.ResultsTree
         """
+        self.log.info("DEV DEV: aggregated_results: %s", pprint.pformat(vars(cumulative_results)))
         self.cumulative_results = cumulative_results
 
     def post_process(self):
