regscale-cli 6.16.0.0__py3-none-any.whl → 6.16.2.0__py3-none-any.whl

regscale/models/integration_models/synqly_models/connectors/assets.py

@@ -84,6 +84,7 @@ class Assets(SynqlyModel):
                 title=f"{self.integration_name} Assets",
                 plan_id=regscale_ssp_id,
                 integration_assets=integration_assets,
+                asset_count=len(integration_assets),
             )
 
         self.logger.info(f"[green]Sync from {self.integration_name} to RegScale completed.")

regscale/models/integration_models/synqly_models/connectors/vulnerabilities.py

@@ -133,6 +133,7 @@ class Vulnerabilities(SynqlyModel):
                 title=f"{self.integration_name} Vulnerabilities",
                 plan_id=regscale_ssp_id,
                 integration_assets=integration_assets,
+                asset_count=len(integration_assets),
             )
 
         if findings:
@@ -157,6 +158,7 @@ class Vulnerabilities(SynqlyModel):
                 title=f"{self.integration_name} Vulnerabilities",
                 plan_id=regscale_ssp_id,
                 integration_findings=integration_findings,
+                finding_count=len(integration_findings),
             )
         self.logger.info(f"[green]Sync from {self.integration_name} to RegScale completed.")
 

regscale/models/integration_models/tenable_models/integration.py

@@ -3,9 +3,9 @@ This module contains the Tenable SC Integration class that is responsible for fe
 """
 
 import logging
+import re
 from typing import Any, Iterator, List, Optional, Tuple
 
-from regscale.core.app.application import Application
 from regscale.core.app.utils.app_utils import epoch_to_datetime
 from regscale.integrations.commercial.tenablev2.utils import get_filtered_severities
 from regscale.integrations.integration_override import IntegrationOverride
@@ -13,6 +13,8 @@ from regscale.integrations.scanner_integration import IntegrationAsset, Integrat
 from regscale.models import regscale_models
 from regscale.models.integration_models.tenable_models.models import TenableAsset
 
+logger = logging.getLogger("regscale")
+
 
 class SCIntegration(ScannerIntegration):
     """
@@ -38,7 +40,7 @@ class SCIntegration(ScannerIntegration):
         :param dict kwargs: Additional keyword arguments
         :yields: Iterator[IntegrationAsset]
         """
-        integration_assets = kwargs.get("integration_assets")
+        integration_assets = kwargs.get("integration_assets", [])
         yield from integration_assets
 
     def fetch_findings(self, *args: Tuple, **kwargs: dict) -> Iterator[IntegrationFinding]:
@@ -50,7 +52,7 @@ class SCIntegration(ScannerIntegration):
         :yields: Iterator[IntegrationFinding]
 
         """
-        integration_findings = kwargs.get("integration_findings")
+        integration_findings = kwargs.get("integration_findings", [])
         yield from integration_findings
 
     def parse_findings(self, vuln: TenableAsset, integration_mapping: Any) -> List[IntegrationFinding]:
@@ -113,14 +115,34 @@ class SCIntegration(ScannerIntegration):
 
         validated_match = integration_mapping.field_map_validation(obj=vuln, model_type="asset")
         asset_identifier = validated_match or vuln.dnsName or vuln.dns or vuln.ip
-        cvss_score = self.get_cvss_score(vuln)
+        cvss_scores = self.get_cvss_scores(vuln)
         severity = self.finding_severity_map.get(vuln.severity.name, regscale_models.IssueSeverity.Low)
 
+        installed_versions_str = ""
+        fixed_versions_str = ""
+        package_path_str = ""
+
+        if "Installed package" in vuln.pluginText:
+            installed_versions = re.findall(r"Installed package\s*:\s*(\S+)", vuln.pluginText)
+            installed_versions_str = ", ".join(installed_versions)
+        if "Fixed package" in vuln.pluginText:
+            fixed_versions = re.findall(r"Fixed package\s*:\s*(\S+)", vuln.pluginText)
+            fixed_versions_str = ", ".join(fixed_versions)
+        if "Path" in vuln.pluginText:
+            package_path = re.findall(r"Path\s*:\s*(\S+)", vuln.pluginText)
+            package_path_str = ", ".join(package_path)
+        if "Installed version" in vuln.pluginText:
+            installed_versions = re.findall(r"Installed version\s*:\s*(.+)", vuln.pluginText)
+            installed_versions_str = ", ".join(installed_versions)
+        if "Fixed version" in vuln.pluginText:
+            fixed_versions = re.findall(r"Fixed version\s*:\s*(.+)", vuln.pluginText)
+            fixed_versions_str = ", ".join(fixed_versions)
+
         return IntegrationFinding(
             control_labels=[],  # Add an empty list for control_labels
             category="Tenable SC Vulnerability",  # Add a default category
             dns=vuln.dnsName,
-            title=getter("title") or (vuln.synopsis or vuln.pluginName),  # BMC Add CVE to title
+            title=getter("title") or f"{cve}: {vuln.synopsis}" if cve else (vuln.synopsis or vuln.pluginName),
             description=getter("description") or (vuln.description or vuln.pluginInfo),
             severity=severity,
             status=regscale_models.IssueStatus.Open,  # Findings of > Low are considered as FAIL
@@ -132,8 +154,11 @@ class SCIntegration(ScannerIntegration):
             date_last_updated=epoch_to_datetime(vuln.lastSeen),
             recommendation_for_mitigation=vuln.solution,
             cve=cve,
-            cvss_v3_score=cvss_score,
-            cvss_score=cvss_score,
+            cvss_v3_score=cvss_scores.get("cvss_v3_base_score", 0.0),
+            cvss_score=cvss_scores.get("cvss_v3_base_score", 0.0),
+            cvss_v3_vector=vuln.cvssV3Vector,
+            cvss_v2_score=cvss_scores.get("cvss_v2_base_score", 0.0),
+            cvss_v2_vector=vuln.cvssVector,
             vpr_score=float(vuln.vprScore) if vuln.vprScore else None,
             comments=vuln.cvssV3Vector,
             plugin_id=vuln.pluginID,
@@ -143,9 +168,16 @@ class SCIntegration(ScannerIntegration):
             basis_for_adjustment="Tenable SC import",
             vulnerability_type="Tenable SC Vulnerability",
             vulnerable_asset=vuln.dnsName,
+            build_version="",
+            affected_os=vuln.operatingSystem,
+            affected_packages=vuln.pluginName,
+            package_path=package_path_str,
+            installed_versions=installed_versions_str,
+            fixed_versions=fixed_versions_str,
+            fix_status="",
         )
 
-    def get_cvss_score(self, vuln: TenableAsset) -> float:
+    def get_cvss_scores(self, vuln: TenableAsset) -> dict:
         """
         Returns the CVSS score for the finding
 
@@ -153,10 +185,14 @@ class SCIntegration(ScannerIntegration):
         :return: The CVSS score
         :rtype: float
         """
+        res = {}
         try:
-            res = float(vuln.cvssV3BaseScore) if vuln.cvssV3BaseScore else 0.0
+            res["cvss_v3_base_score"] = float(vuln.cvssV3BaseScore) if vuln.cvssV3BaseScore else 0.0
+            res["cvss_v2_base_score"] = float(vuln.baseScore) if vuln.baseScore else 0.0
         except (ValueError, TypeError):
-            res = 0.0
+            res["cvss_v3_base_score"] = 0.0
+            res["cvss_v2_base_score"] = 0.0
+
         return res
 
     def to_integration_asset(self, asset: TenableAsset, **kwargs: dict) -> IntegrationAsset:

regscale/models/integration_models/trivy_import.py

@@ -221,7 +221,7 @@ class TrivyImport(FlatFileImporter):
         """
         data = self.validater.data
         assets: List[IntegrationAsset] = []
-        os_data = self.mapping.get_value(data, "Metadata", {}, warnings=False).get("OS", {})
+        os_data = self.mapping.get_value(data, "Metadata", {}).get("OS", {})
         try:
             assets.append(self.parse_asset(asset=data, os_data=os_data))
             return assets

regscale/models/integration_models/xray.py

@@ -123,7 +123,7 @@ class XRay(FlatFileImporter):
                         cve=cve,
                         vprScore=None,
                         tenantsId=0,  # Need a way to figure this out programmatically
-                        title=f"{self.mapping.get_value(dat, 'issue_id', warnings=False) or self.mapping.get_value(dat, 'summary', f'XRay Vulnerability from Import {get_current_datetime()}', warnings=False)} on asset {asset.name}",
+                        title=f"{self.mapping.get_value(dat, 'issue_id') or self.mapping.get_value(dat, 'summary', f'XRay Vulnerability from Import {get_current_datetime()}')} on asset {asset.name}",
                         description=self.mapping.get_value(dat, "summary"),
                         plugInText=vuln.get("cve"),
                         extra_data={

regscale/models/regscale_models/__init__.py

@@ -8,6 +8,7 @@ from .cci import *
 from .change import *
 from .checklist import *
 from .comment import *
+from .compliance_settings import *
 from .component import *
 from .component_mapping import *
 from .control import *
@@ -26,6 +27,7 @@ from .file import *
 from .implementation_objective import *
 from .implementation_option import *
 from .incident import *
+from .inherited_control import *
 from .interconnection import *
 from .issue import *
 from .leveraged_authorization import *

regscale/models/regscale_models/control_implementation.py

@@ -13,7 +13,7 @@ from pydantic import ConfigDict, Field
 
 from regscale.core.app.api import Api
 from regscale.core.app.application import Application
-from regscale.core.app.utils.app_utils import get_current_datetime, remove_keys
+from regscale.core.app.utils.app_utils import get_current_datetime
 from regscale.core.app.utils.catalog_utils.common import parentheses_to_dot
 from regscale.models.regscale_models.implementation_role import ImplementationRole
 from regscale.models.regscale_models.regscale_model import RegScaleModel
@@ -178,7 +178,7 @@ class ControlImplementation(RegScaleModel):
             export="/api/{model_slug}/export/{int_id}",
             wizard="/api/{model_slug}/wizard/{int_id}/{str_module}",
             get_date_last_assessed_by_parent="/api/{model_slug}/getDateLastAssessedByParent/{int_record}",
-            get_date_last_assessed_by_parent_and_module="/api/{model_slug}/getDateLastAssessedByParentAndModule/{str_module}/{int_record}",
+            get_date_last_assessed_by_parent_and_module="/api/{model_slug}/getDateLastAssessedByParentAndModule/{str_module}/{int_record}",  # noqa: E501
             get_date_last_assessed_for_all_assets="/api/{model_slug}/getDateLastAssessedForAllAssets/{int_record}",
             graph_controls_by_date="/api/{model_slug}/graphControlsByDate/{year}",
             get_date_last_assessed_by_control="/api/{model_slug}/getDateLastAssessedByControl/{int_control}",
@@ -203,14 +203,14 @@ class ControlImplementation(RegScaleModel):
             quick_update="/api/{model_slug}/quickUpdate/{id}/{str_status}/{int_weight}/{str_user}",
             dashboard_by_parent="/api/{model_slug}/dashboardByParent/{str_group_by}/{int_id}/{str_module}",
             security_control_dashboard="/api/{model_slug}/securityControlDashboard/{str_group_by}/{int_id}",
-            dashboard_by_parent_and_catalogue="/api/{model_slug}/dashboardByParentAndCatalogue/{str_group_by}/{int_id}/{int_cat_id}",
+            dashboard_by_parent_and_catalogue="/api/{model_slug}/dashboardByParentAndCatalogue/{str_group_by}/{int_id}/{int_cat_id}",  # noqa: E501
             group_by_family="/api/{model_slug}/groupByFamily/{int_security_plan}",
             dashboard_by_sp="/api/{model_slug}/dashboardBySP/{str_group_by}/{int_security_plan}",
             report="/api/{model_slug}/report/{str_report}",
             get_by_parent="/api/{model_slug}/getByParent/{int_id}/{str_module}",
             get_count_by_parent="/api/{model_slug}/getCountByParent/{int_id}/{str_module}",
             get_all_asset_controls_by_component="/api/{model_slug}/getAllAssetControlsByComponent/{int_id}",
-            drilldown_asset_controls_by_component="/api/{model_slug}/drilldownAssetControlsByComponent/{component_id}/{str_field}/{str_value}",
+            drilldown_asset_controls_by_component="/api/{model_slug}/drilldownAssetControlsByComponent/{component_id}/{str_field}/{str_value}",  # noqa: E501
             get_control_context="/api/{model_slug}/getControlContext/{int_control_id}/{int_parent_id}/{str_module}",
         )
 
@@ -662,7 +662,6 @@ class ControlImplementation(RegScaleModel):
         parent_module: str,
         existing_implementation_dict: dict,
         full_controls: dict,
-        partial_controls: dict,
         failing_controls: dict,
         include_not_implemented: Optional[bool] = False,
     ) -> None:
@@ -674,7 +673,6 @@ class ControlImplementation(RegScaleModel):
         :param str parent_module: Name of the parent module
         :param dict existing_implementation_dict: Dictionary of existing implementations
         :param dict full_controls: Dictionary of fully implemented controls
-        :param dict partial_controls: Dictionary of partially implemented controls
         :param dict failing_controls: Dictionary of failing controls
         :param Optional[bool] include_not_implemented: Whether to include not implemented controls, defaults to False
         :rtype: None
@@ -688,7 +686,6 @@ class ControlImplementation(RegScaleModel):
             parent_module,
             existing_implementation_dict,
             full_controls,
-            partial_controls,
             failing_controls,
             user_id,
             include_not_implemented,
@@ -705,7 +702,6 @@ class ControlImplementation(RegScaleModel):
         parent_module: str,
         existing_implementation_dict: dict,
         full_controls: dict,
-        partial_controls: dict,
         failing_controls: dict,
         user_id: Optional[str] = None,
         include_not_implemented: Optional[bool] = False,
@@ -718,7 +714,6 @@ class ControlImplementation(RegScaleModel):
         :param str parent_module: Name of the parent module
         :param dict existing_implementation_dict: Dictionary of existing implementations
         :param dict full_controls: Dictionary of fully implemented controls
-        :param dict partial_controls: Dictionary of partially implemented controls
         :param dict failing_controls: Dictionary of failing controls
         :param Optional[str] user_id: ID of the user performing the operation, defaults to None
         :param Optional[bool] include_not_implemented: Whether to include not implemented controls, defaults to False
@@ -729,21 +724,12 @@ class ControlImplementation(RegScaleModel):
         to_update = []
 
         for control in controls:
-            # if otherid exists in catalog object make sure it has something in it before matching
-            # this case may exist while new catalogs are being migrated to for customers
-            if len(control.get("otherId", [])) > 0:
-                lower_case_control_id = control["otherId"].lower()
-            else:
-                lower_case_control_id = control["controlId"].lower()
-
-            status = cls.check_implementation(full_controls, partial_controls, failing_controls, lower_case_control_id)
+            lower_case_control_id = control["controlId"].lower()
+            status = cls.check_implementation(full_controls, failing_controls, lower_case_control_id)
             if not include_not_implemented and status == ControlImplementationStatus.NotImplemented.value:
                 continue
 
-            if len(control.get("otherId", [])) > 0:
-                controlid = control["otherId"]
-            else:
-                controlid = control["controlId"]
+            controlid = control.get("controlId")
 
             if controlid not in existing_implementation_dict:
                 cim = cls.create_new_control_implementation(control, parent_id, parent_module, status, user_id)
@@ -808,18 +794,11 @@ class ControlImplementation(RegScaleModel):
         :param list to_update: List of controls to update
         :param Optional[str] user_id: ID of the user performing the operation, defaults to None
         """
-        existing_imp = existing_implementation_dict[control["controlId"]]
-        existing_imp.update(
-            {
-                "implementation": control.get("implementation"),
-                "status": status,
-                "dateLastAssessed": get_current_datetime(),
-                "lastUpdatedById": user_id,
-                "dateLastUpdated": get_current_datetime(),
-            }
-        )
-
-        remove_keys(existing_imp, ["createdBy", "systemRole", "controlOwner", "lastUpdatedBy"])
+        existing_imp: ControlImplementation = existing_implementation_dict[control["controlId"]]
+        existing_imp.status = status
+        existing_imp.dateLastAssessed = get_current_datetime()
+        existing_imp.lastUpdatedById = user_id
+        existing_imp.dateLastUpdated = get_current_datetime()
 
         if existing_imp not in to_update:
             to_update.append(existing_imp)
@@ -860,7 +839,6 @@ class ControlImplementation(RegScaleModel):
     @staticmethod
     def check_implementation(
         full_controls: dict,
-        partial_controls: dict,
         failing_controls: dict,
         control_id: str,
     ) -> str:
@@ -874,18 +852,14 @@ class ControlImplementation(RegScaleModel):
         :return: status of control implementation
         :rtype: str
         """
+        status = ControlImplementationStatus.NotImplemented.value
         if control_id in full_controls.keys():
-            logger.debug(f"Found fully implemented control: {control_id}")
-            return ControlImplementationStatus.FullyImplemented.value
-        elif control_id in partial_controls.keys():
-            logger.debug(f"Found partially implemented control: {control_id}")
-            return ControlImplementationStatus.PartiallyImplemented.value
+            logger.debug(f"Found control passing compliance check: {control_id}")
+            status = ControlImplementationStatus.PartiallyImplemented.value
         elif control_id in failing_controls.keys():
-            logger.debug(f"Found failing control: {control_id}")
-            return ControlImplementationStatus.InRemediation.value
-        else:
-            logger.debug(f"Found not implemented control: {control_id}")
-            return ControlImplementationStatus.NotImplemented.value
+            logger.debug(f"Found control failing compliance check: {control_id}")
+            status = ControlImplementationStatus.InRemediation.value
+        return status
 
     @classmethod
     def get_sort_position_dict(cls) -> dict:

regscale/models/regscale_models/inherited_control.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Model for Security Plan in the application"""
+
+from typing import Optional, Union
+
+from pydantic import ConfigDict, Field, field_validator
+
+from regscale.core.app.api import Api
+from regscale.core.app.logz import create_logger
+from regscale.core.app.utils.app_utils import get_current_datetime
+from regscale.models.regscale_models.regscale_model import RegScaleModel
+
+
+class InheritedControl(RegScaleModel):
+    """
+    Inherited Control model
+    """
+
+    _module_slug = "inheritedControls"
+
+    id: int = 0
+    createdBy: Optional[str] = None
+    createdById: Optional[str] = None
+    dateCreated: Optional[str] = Field(default_factory=get_current_datetime)
+    lastUpdatedById: Optional[str] = Field(default_factory=RegScaleModel.get_user_id)
+    dateLastUpdated: Optional[str] = Field(default_factory=get_current_datetime)
+    isPublic: bool = True
+    parentId: int = 0
+    parentModule: str = ""
+    baseControlId: int = 0
+    inheritedControlId: int = 0
+
+    @staticmethod
+    def _get_additional_endpoints() -> ConfigDict:
+        """
+        Get additional endpoints for the Inherited Controls model.
+
+        :return: A dictionary of additional endpoints
+        :rtype: ConfigDict
+        """
+        return ConfigDict(  # type: ignore
+            get_all_by_parent="/api/{model_slug}/getAllByParent/{intParentID}/{strModule}",
+            get_all_by_control="/api/{model_slug}/getAllByBaseControl/{control_id}",
+        )
+
+    @classmethod
+    def get_all_by_control(cls, control_id: int) -> dict:
+        """
+        Fetch the Mega API data for the given SSP ID
+
+        :param int ssp_id: RegScale SSP ID
+        :return: Mega API data
+        :rtype: dict
+        """
+        response = cls._get_api_handler().get(
+            endpoint=cls.get_endpoint("get_all_by_control").format(module_slug=cls._module_slug, control_id=control_id)
+        )
+        if not response.raise_for_status():
+            return response.json()
+        return {}

regscale/models/regscale_models/issue.py

@@ -789,6 +789,7 @@ class Issue(RegScaleModel):
         skip = 0
         control_issues: Dict[int, List[OpenIssueDict]] = defaultdict(list)
         logger.info("Fetching open issues for controls and for security plan %i...", plan_id)
+        supports_multiple_controls: bool = cls.is_multiple_controls_supported()
 
         # Define fields based on version
         fields = """
@@ -797,7 +798,7 @@ class Issue(RegScaleModel):
             otherIdentifier
             {extra_fields}
         """.format(
-            extra_fields="controlImplementations { id }" if cls.is_multiple_controls_supported() else ""
+            extra_fields="controlImplementations { id }" if supports_multiple_controls else ""
         )
 
         while True:
@@ -822,7 +823,7 @@ class Issue(RegScaleModel):
             items = response.get(cls.get_module_string(), {}).get("items", [])
 
             for item in items:
-                if cls.is_multiple_controls_supported() and item.get("controlImplementations"):
+                if supports_multiple_controls and item.get("controlImplementations"):
                     for control in item.get("controlImplementations", []):
                         control_issues[control["id"]].append(
                             OpenIssueDict(id=item["id"], otherIdentifier=item["otherIdentifier"])

regscale/models/regscale_models/mixins/parent_cache.py

@@ -51,7 +51,7 @@ class PlanCacheMixin(Generic[T]):
         objects = cls.get_plan_objects(plan_id)
         for obj in objects:
             cls.cache_object(obj)
-        logger.info("Cached %s %s objects", len(objects), cls.__name__)
+        logger.debug("Cached %s %s objects.", len(objects), cls.__name__)
 
     @classmethod
     def get_plan_objects(cls: Type[T], plan_id: int) -> List[T]:

regscale/models/regscale_models/regscale_model.py

@@ -53,6 +53,7 @@ class RegScaleModel(BaseModel, ABC):
     _original_data: Optional[Dict[str, Any]] = None
 
     # Caching
+    _disable_cache: bool = False  # flag to disable caching
     _object_cache: ClassVar[Cache] = Cache(maxsize=100000)
     _parent_cache: ClassVar[Cache] = Cache(maxsize=50000)
     _lock_registry: ClassVar[ThreadSafeDict] = ThreadSafeDict()
@@ -80,9 +81,46 @@ class RegScaleModel(BaseModel, ABC):
             super().__init__(*args, **data)
             # Capture initial state after initialization
             self._original_data = self.dict(exclude_unset=True)
+            self._disable_cache = self._fetch_disabled_cache_setting()
+            if self._disable_cache:
+                logger.debug("cache is disabled")
         except Exception as e:
             logger.error(f"Error creating {self.__class__.__name__}: {e} {data}", exc_info=True)
 
+    def _fetch_disabled_cache_setting(self) -> bool:
+        """
+        Check if caching is disabled based on the application config.
+
+        :return: True if caching is disabled, False otherwise
+        :rtype: bool
+        """
+        is_disabled = False
+        if config := self._get_api_handler().config:
+            is_disabled = config.get("disableCache", False)
+        return is_disabled
+
+    @classmethod
+    def disable_cache(cls) -> bool:
+        """
+        Disable caching for the model.
+
+        :return: True if caching is disabled, False otherwise
+        :rtype: bool
+        """
+        cls._disable_cache = True
+        return cls._disable_cache
+
+    @classmethod
+    def enable_cache(cls) -> bool:
+        """
+        Enable caching for the model.
+
+        :return: True if caching is enabled, False otherwise
+        :rtype: bool
+        """
+        cls._disable_cache = False
+        return cls._disable_cache
+
     @classmethod
     def _get_api_handler(cls) -> APIHandler:
         """
@@ -169,6 +207,8 @@ class RegScaleModel(BaseModel, ABC):
         :return: The cached object if found, None otherwise
         :rtype: Optional[T]
         """
+        if cls._disable_cache:
+            return None
         with cls._get_lock(cache_key):
             return cls._object_cache.get(cache_key)
 
@@ -181,6 +221,8 @@ class RegScaleModel(BaseModel, ABC):
         :return: None
         :rtype: None
         """
+        if cls._disable_cache:
+            return
         try:
             if not obj:
                 return
@@ -229,6 +271,8 @@ class RegScaleModel(BaseModel, ABC):
         :return: None
         :rtype: None
         """
+        if cls._disable_cache:
+            return
         parent_id = getattr(obj, cls._parent_id_field, None)
         parent_module = getattr(obj, "parentModule", getattr(obj, "parent_module", ""))
         if parent_id and parent_module:
@@ -252,6 +296,8 @@ class RegScaleModel(BaseModel, ABC):
         :return: None
         :rtype: None
         """
+        if cls._disable_cache:
+            return
         with cls._get_lock(cache_key):
             for obj in objects:
                 cls.cache_object(obj)
@@ -265,6 +311,8 @@ class RegScaleModel(BaseModel, ABC):
         :return: None
         :rtype: None
         """
+        if cls._disable_cache:
+            return
         cls._object_cache.clear()
 
     @classmethod
@@ -276,6 +324,8 @@ class RegScaleModel(BaseModel, ABC):
         :return: None
         :rtype: None
         """
+        if cls._disable_cache:
+            return
         cache_key = cls._get_cache_key(obj)
         with cls._get_lock(cache_key):
             cls._object_cache.delete(cache_key)
@@ -1058,12 +1108,12 @@ class RegScaleModel(BaseModel, ABC):
         return endpoint
 
     @classmethod
-    def _get_pending_updates(cls) -> Set[int]:
+    def _get_pending_updates(cls) -> Set[Union[int, str]]:
         """
         Get the set of pending updates for the class.
 
         :return: Set of pending update IDs
-        :rtype: Set[int]
+        :rtype: Set[Union[int, str]]
         """
         class_name = cls.__name__
         if class_name not in cls._pending_updates:
@@ -1138,18 +1188,34 @@ class RegScaleModel(BaseModel, ABC):
         # Handle updates
         pending_updates = cls._get_pending_updates()
         if pending_updates:
-            logger.info(f"Performing bulk update for {len(pending_updates)} {cls.__name__} objects")
-            objects_to_update = [cls.get_cached_object(cache_key=cache_key) for cache_key in pending_updates]
+            logger.debug(f"Analyzing {len(pending_updates)} {cls.__name__} objects for bulk update...")
+            objects_to_update = [
+                cls.get_cached_object(cache_key=cache_key)
+                for cache_key in pending_updates
+                if cls.get_cached_object(cache_key=cache_key)
+            ]
+            logger.debug(
+                f"{len(objects_to_update)}/{len(pending_updates)} {cls.__name__} objects qualify for bulk update."
+            )
             if objects_to_update:
+                logger.info(f"Performing bulk update for {len(objects_to_update)} {cls.__name__} objects...")
                 result["updated"] = cls.batch_update(items=objects_to_update, progress_context=progress_context)
             pending_updates.clear()
 
         # Handle creations
         pending_creations = cls._get_pending_creations()
         if pending_creations:
-            logger.info(f"Performing bulk creation for {len(pending_creations)} {cls.__name__} objects")
-            objects_to_create = [cls.get_cached_object(cache_key=cache_key) for cache_key in pending_creations]
+            logger.debug(f"Analyzing {len(pending_creations)} {cls.__name__} objects for bulk creation...")
+            objects_to_create = [
+                cls.get_cached_object(cache_key=cache_key)
+                for cache_key in pending_creations
+                if cls.get_cached_object(cache_key=cache_key)
+            ]
+            logger.debug(
+                f"{len(objects_to_create)}/{len(pending_creations)} {cls.__name__} objects qualify for bulk creation."
+            )
             if objects_to_create:
+                logger.info(f"Performing bulk creation for {len(pending_creations)} {cls.__name__} objects...")
                 result["created"] = cls.batch_create(items=objects_to_create, progress_context=progress_context)
             pending_creations.clear()
 
@@ -1437,7 +1503,7 @@ class RegScaleModel(BaseModel, ABC):
         :rtype: Optional[T]
         """
         if response and response.ok:
-            logger.info(json.dumps(response.json(), indent=4))
+            logger.debug(json.dumps(response.json(), indent=4))
             return cast(T, cls(**response.json()))
         else:
             cls.log_response_error(response=response, suppress_error=suppress_error)