transfer dev to fork

Author: alexafshar

README.md

@@ -138,7 +138,6 @@ Options:
   -c, --concurrent-connections INTEGER
   -u, --username TEXT             Adds the option to put username dynamically
   -p, --password TEXT             Adds the option to put password dynamically
-  --car                           Generate the configration analysis report as part of the output
   --help                          Show this help message and exit.
 ```
 
@@ -198,7 +197,6 @@ Options:
   -c, --concurrent-connections INTEGER
   -u, --username TEXT             Adds the option to put username dynamically
   -p, --password TEXT             Adds the option to put password dynamically
-  --car                           Generate the configration analysis report as part of the output
   --help                          Show this help message and exit
 ```
 
@@ -326,3 +324,19 @@ Debug logs can be taken by either:
 
 - checking the `debug` checkbox in the UI
 - running the backend with the `--debug` or `-d` flag
+
+
+
+release notes:
+-CAR report generated automically now as part of the artifacts generated.
+- UI enhancements (#160):
+  - UI now supports Dynamic Credentials for API client secret and token entries. Previously only  basic auth was supported. 
+  - You can view job file/threshhold files in-line rather than popup OS editor
+- #157 - Archive function added to keep a copy of all generated reports, timestamped in the "output/archive" diretory
+- Makefile added to ease building artifacts, docker images, running CAT from source, bundling, etc. 
+- bug fixes 
+  - #156
+
+
+
+

VERSION

@@ -1 +1 @@
-v1.8
+v1.8.0

backend/api/appd/AppDService.py

@@ -561,12 +561,6 @@ async def getAnalyticsEnabledStatusForAllApplications(self) -> Result:
 
     async def getDashboards(self) -> Result:
 
-        # self.controller.jsessionid = "c618719074f568d36fa97fca95c7"
-        # self.controller.xcsrftoken= "8c6b20c6ee1128ae47b8c4c782a6a28b55b5dc3d"
-        # self.controller.session.headers["X-CSRF-TOKEN"] = ( self.controller.xcsrftoken)
-        # self.controller.session.headers["Set-Cookie"] = (f"JSESSIONID="
-        #                                                  f"{self.controller.jsessionid};X-CSRF-TOKEN={self.controller.xcsrftoken};")
-
         debugString = f"Gathering Dashboards"
         logging.debug(f"{self.host} - {debugString}")
         response = await self.controller.getAllDashboardsMetadata()

backend/extractionSteps/maturityAssessment/apm/AppAgentsAPM.py

@@ -180,71 +180,72 @@ def analyze(self, controllerData, thresholds):
                 application["appAgentVersions"] = []
 
                 for node in application["nodes"]:
-                    if node["appAgentVersion"] in nodeVersionMap:
+                    app_agent_present = node.get("appAgentPresent") is True
+                    if app_agent_present and node["appAgentVersion"] in nodeVersionMap:
                         nodeVersionMap[node["appAgentVersion"]] += 1
-                    else:
+                    elif app_agent_present:
                         nodeVersionMap[node["appAgentVersion"]] = 1
 
                     # Calculate version age
-                    numberNodesWithAppAgentInstalled += 1
-                    if "" == node["appAgentVersion"]:  # No agent installed
-                        continue
+                numberNodesWithAppAgentInstalled += 1
+                    if not app_agent_present:
+                    continue
 
-                    version = semanticVersionRegex.search(node["appAgentVersion"])[0].split(".")  # e.g. 'Server Agent v21.6.1.2 GA ...'
-                    majorVersion = int(version[0])
-                    minorVersion = int(version[1])
+                version = semanticVersionRegex.search(node["appAgentVersion"])[0].split(".")  # e.g. 'Server Agent v21.6.1.2 GA ...'
+                majorVersion = int(version[0])
+                minorVersion = int(version[1])
 
                     hostInfo["appAgentVersions"].add((majorVersion, minorVersion, node["agentType"]))
                     application["appAgentVersions"].append(f"{node['agentType']}:{version[0]}.{version[1]}")
 
-                    if majorVersion == 4:  # Agents with version 4 and below will always fail.
-                        node["appAgentAge"] = 3
-                    else:
-                        years = currYear - majorVersion
-                        if minorVersion < currMonth:
-                            years += 1
-                        node["appAgentAge"] = years
+                if majorVersion == 4:  # Agents with version 4 and below will always fail.
+                    node["appAgentAge"] = 3
+                else:
+                    years = currYear - majorVersion
+                    if minorVersion < currMonth:
+                        years += 1
+                    node["appAgentAge"] = years
 
-                        if years <= 2:
-                            numberAppAgentsLessThan2YearsOld += 1
-                        if years == 1:
-                            numberAppAgentsLessThan1YearOld += 1
+                    if years <= 2:
+                        numberAppAgentsLessThan2YearsOld += 1
+                    if years == 1:
+                        numberAppAgentsLessThan1YearOld += 1
 
-                    # Determine application load
-                    if node["appAgentAvailability"] != 0:
-                        numberAppAgentsReportingData += 1
+                # Determine application load
+                if node["appAgentAvailability"] != 0:
+                    numberAppAgentsReportingData += 1
 
-                    if node["nodeMetricsUploadRequestsExceedingLimit"] != 0:
-                        analysisDataEvaluatedMetrics["metricLimitNotHit"] = False
+                if node["nodeMetricsUploadRequestsExceedingLimit"] != 0:
+                    analysisDataEvaluatedMetrics["metricLimitNotHit"] = False
 
-                # In the case of multiple versions, will return the largest common agent count regardless of version.
-                try:
+            # In the case of multiple versions, will return the largest common agent count regardless of version.
+            try:
                     numberAppAgentsRunningSameVersion = nodeVersionMap[max(nodeVersionMap, key=nodeVersionMap.get)]
-                except ValueError:
-                    logging.debug(
-                        f'{hostInfo["controller"].host} - No app agents returned for application {application["name"]}, unable to parse agent versions.'
-                    )
+            except ValueError:
+                logging.debug(
+                    f'{hostInfo["controller"].host} - No app agents returned for application {application["name"]}, unable to parse agent versions.'
+                )
 
-                # Calculate percents of compliant nodes.
-                if numberNodesWithAppAgentInstalled != 0.0:
+            # Calculate percents of compliant nodes.
+            if numberNodesWithAppAgentInstalled != 0.0:
                     analysisDataEvaluatedMetrics["percentAgentsLessThan1YearOld"] = (
                         numberAppAgentsLessThan1YearOld / numberNodesWithAppAgentInstalled * 100
-                    )
+                )
                     analysisDataEvaluatedMetrics["percentAgentsLessThan2YearsOld"] = (
                         numberAppAgentsLessThan2YearsOld / numberNodesWithAppAgentInstalled * 100
-                    )
+                )
                     analysisDataEvaluatedMetrics["percentAgentsReportingData"] = numberAppAgentsReportingData / numberNodesWithAppAgentInstalled * 100
                     analysisDataEvaluatedMetrics["percentAgentsRunningSameVersion"] = (
                         numberAppAgentsRunningSameVersion / numberNodesWithAppAgentInstalled * 100
-                    )
-                else:
+                )
+            else:
                     analysisDataEvaluatedMetrics["percentAgentsLessThan1YearOld"] = 0
                     analysisDataEvaluatedMetrics["percentAgentsLessThan2YearsOld"] = 0
-                    analysisDataEvaluatedMetrics["percentAgentsReportingData"] = 0
+                analysisDataEvaluatedMetrics["percentAgentsReportingData"] = 0
                     analysisDataEvaluatedMetrics["percentAgentsRunningSameVersion"] = 0
 
-                analysisDataRawMetrics["numberOfNodes"] = len(application["nodes"])
-                analysisDataRawMetrics["numberOfTiers"] = len(application["tiers"])
+            analysisDataRawMetrics["numberOfNodes"] = len(application["nodes"])
+            analysisDataRawMetrics["numberOfTiers"] = len(application["tiers"])
                 analysisDataRawMetrics["numberNodesWithAppAgentInstalled"] = numberNodesWithAppAgentInstalled
                 analysisDataRawMetrics["numberAppAgentsLessThan1YearOld"] = numberAppAgentsLessThan1YearOld
                 analysisDataRawMetrics["numberAppAgentsLessThan2YearsOld"] = numberAppAgentsLessThan2YearsOld

backend/extractionSteps/maturityAssessment/apm/MachineAgentsAPM.py

@@ -124,73 +124,99 @@ def analyze(self, controllerData, thresholds):
                 application["machineAgentVersions"] = []
 
                 for node in application["nodes"]:
-                    if node["machineAgentVersion"] in nodeVersionMap:
-                        nodeVersionMap[node["machineAgentVersion"]] += 1
-                    else:
-                        nodeVersionMap[node["machineAgentVersion"]] = 1
-
-                    if node["appAgentPresent"] and node["machineAgentPresent"]:
-                        numberMachineAgentsInstalledAlongsideAppAgents += 1
-
-                    if node["machineAgentPresent"]:
+                    if node.get("machineAgentPresent", False):
                         numberNodesWithMachineAgentInstalled += 1
-                    else:
-                        logging.info("machineAgentPresent NOT present!")
-                        continue
-
-                    # Calculate version age
-                    version = semanticVersionRegex.search(node["machineAgentVersion"])[0].split(".")  # e.g. 'Server Agent v21.6.1.2 GA ...'
-                    majorVersion = int(version[0])
-                    minorVersion = int(version[1])
-
-                    logging.info(f'major version: {majorVersion}, minor version: {minorVersion}')
 
-
-                    hostInfo["machineAgentVersions"].add((majorVersion, minorVersion))
-                    application["machineAgentVersions"].append(f"{version[0]}.{version[1]}")
-
-                    if majorVersion == 4:  # Agents with version 4 and below will always fail.
-                        node["machineAgentAge"] = 3
+                        # Check if an App Agent is also present to count agents installed alongside each other.
+                        # Assuming 'appAgentPresent' is always a key if 'node' is well-formed.
+                        if node["appAgentPresent"]:
+                            numberMachineAgentsInstalledAlongsideAppAgents += 1
+
+                        # Safely retrieve the machine agent version string from the nested metadata.
+                        # Using .get() with default empty dictionaries to prevent KeyError if intermediate keys are missing.
+                        machine_agent_version_str = node.get('metadata', {}).get('applicationComponentNode', {}).get('machineAgentVersion')
+
+                        if machine_agent_version_str: # Only proceed if the version string is not None or empty
+                            # Update nodeVersionMap with the retrieved version string
+                            if machine_agent_version_str in nodeVersionMap:
+                                nodeVersionMap[machine_agent_version_str] += 1
+                            else:
+                                nodeVersionMap[machine_agent_version_str] = 1
+
+                            logging.info(f'application {application["name"]} node data: {node}')
+
+                            # Calculate version age
+                            match = semanticVersionRegex.search(machine_agent_version_str)
+                            if match:
+                                version = match[0].split(".")
+                                majorVersion = int(version[0])
+                                minorVersion = int(version[1])
+
+                                logging.info(f'major version: {majorVersion}, minor version: {minorVersion}')
+
+                                hostInfo["machineAgentVersions"].add((majorVersion, minorVersion))
+                                application["machineAgentVersions"].append(f"{version[0]}.{version[1]}")
+
+                                if majorVersion == 4:  # Agents with version 4 and below will always fail.
+                                    node["machineAgentAge"] = 3
+                                else:
+                                    years = currYear - majorVersion
+                                    if minorVersion < currMonth:
+                                        years += 1
+                                    node["machineAgentAge"] = years
+
+                                    if years <= 2:
+                                        numberMachineAgentsLessThan2YearsOld += 1
+                                    if years == 1:
+                                        numberMachineAgentsLessThan1YearOld += 1
+                            else:
+                                logging.warning(f"Could not parse machine agent version from '{machine_agent_version_str}' for node {node.get('name', 'unknown')}. Skipping age calculation.")
+                                node["machineAgentAge"] = None # Indicate that age couldn't be determined
+                        else:
+                            logging.warning(f"Machine agent present for node {node.get('name', 'unknown')}, but 'machineAgentVersion' is None or empty in metadata. Skipping version-dependent analysis.")
+                            node["machineAgentAge"] = None # Indicate that age couldn't be determined
+
+                        # Determine application load - this uses 'machineAgentAvailability' which is at the top level of 'node'
+                        if node.get("machineAgentAvailability", 0) != 0:
+                            numberMachineAgentsReportingData += 1
                     else:
-                        years = currYear - majorVersion
-                        if minorVersion < currMonth:
-                            years += 1
-                        node["machineAgentAge"] = years
-
-                        if years <= 2:
-                            numberMachineAgentsLessThan2YearsOld += 1
-                        if years == 1:
-                            numberMachineAgentsLessThan1YearOld += 1
-
-                    # Determine application load
-                    if node["machineAgentAvailability"] != 0:
-                        numberMachineAgentsReportingData += 1
+                        logging.info(f"No machine agent present for node {node.get('name', 'unknown')}. Skipping machine agent specific analysis for this node.")
+                        # The original code had a 'continue' here to skip the rest of the loop for this node
+                        # if 'machineAgentPresent' was False. We maintain that behavior.
+                        continue # Skip to the next node if no machine agent is present.
 
                 # In the case of multiple versions, will return the largest common agent count regardless of version.
                 try:
-                    numberMachineAgentsRunningSameVersion = nodeVersionMap[max(nodeVersionMap, key=nodeVersionMap.get)]
+                    # Only attempt to find the max if nodeVersionMap is not empty
+                    if nodeVersionMap:
+                        numberMachineAgentsRunningSameVersion = nodeVersionMap[max(nodeVersionMap, key=nodeVersionMap.get)]
+                    else:
+                        numberMachineAgentsRunningSameVersion = 0 # No machine agents, so 0 running same version
                 except ValueError:
+                    # This ValueError typically happens if max() is called on an empty sequence,
+                    # which is now explicitly handled by 'if nodeVersionMap:'. This block might be redundant but harmless.
                     logging.debug(
                         f'{hostInfo["controller"].host} - No machine agents returned for application {application["name"]}, unable to parse agent versions.'
                     )
+                    numberMachineAgentsRunningSameVersion = 0 # Ensure it's initialized even on error
 
                 # Calculate percentage of compliant nodes.
                 # Default all to bronze. Will be modified in call to 'applyThresholds'.
                 if numberNodesWithMachineAgentInstalled != 0.0:
                     analysisDataEvaluatedMetrics["percentAgentsLessThan1YearOld"] = (
-                        numberMachineAgentsLessThan1YearOld / numberNodesWithMachineAgentInstalled * 100
+                            numberMachineAgentsLessThan1YearOld / numberNodesWithMachineAgentInstalled * 100
                     )
                     analysisDataEvaluatedMetrics["percentAgentsLessThan2YearsOld"] = (
-                        numberMachineAgentsLessThan2YearsOld / numberNodesWithMachineAgentInstalled * 100
+                            numberMachineAgentsLessThan2YearsOld / numberNodesWithMachineAgentInstalled * 100
                     )
                     analysisDataEvaluatedMetrics["percentAgentsReportingData"] = (
-                        numberMachineAgentsReportingData / numberNodesWithMachineAgentInstalled * 100
+                            numberMachineAgentsReportingData / numberNodesWithMachineAgentInstalled * 100
                     )
                     analysisDataEvaluatedMetrics["percentAgentsRunningSameVersion"] = (
-                        numberMachineAgentsRunningSameVersion / numberNodesWithMachineAgentInstalled * 100
+                            numberMachineAgentsRunningSameVersion / numberNodesWithMachineAgentInstalled * 100
                     )
                     analysisDataEvaluatedMetrics["percentAgentsInstalledAlongsideAppAgents"] = (
-                        numberMachineAgentsInstalledAlongsideAppAgents / numberNodesWithMachineAgentInstalled * 100
+                            numberMachineAgentsInstalledAlongsideAppAgents / numberNodesWithMachineAgentInstalled * 100
                     )
                 else:
                     analysisDataEvaluatedMetrics["percentAgentsLessThan1YearOld"] = 0
@@ -205,4 +231,4 @@ def analyze(self, controllerData, thresholds):
                 analysisDataRawMetrics["numberMachineAgentsLessThan1YearOld"] = numberMachineAgentsLessThan1YearOld
                 analysisDataRawMetrics["numberMachineAgentsLessThan2YearsOld"] = numberMachineAgentsLessThan2YearsOld
 
-                self.applyThresholds(analysisDataEvaluatedMetrics, analysisDataRoot, jobStepThresholds)
+                self.applyThresholds(analysisDataEvaluatedMetrics, analysisDataRoot, jobStepThresholds)

backend/output/presentations/cxPptFsoUseCases.py

@@ -544,7 +544,7 @@ def createCxHamUseCasePpt(folder: str):
                              f"{file_prefix}-Synthetics.xlsx"
                          ))
 
-    assert len(excels.getWorkBooks()) >= 9
+    assert len(excels.getWorkBooks()) >= 10
 
     # currently only 1st controller in the job file is examined.
     controller = getValuesInColumn(apm_wb["Analysis"], "controller")[0]