nautobot 2.2.9__py3-none-any.whl → 2.3.0b1__py3-none-any.whl

nautobot/core/management/commands/generate_test_data.py

@@ -2,6 +2,7 @@ import hashlib
 import json
 import os
 
+from django.contrib.contenttypes.models import ContentType
 from django.core.management import call_command
 from django.core.management.base import BaseCommand, CommandError
 from django.core.serializers.json import DjangoJSONEncoder
@@ -68,30 +69,56 @@ class Command(BaseCommand):
                 ProviderFactory,
                 ProviderNetworkFactory,
             )
+            from nautobot.cloud.factory import (
+                CloudAccountFactory,
+                CloudNetworkFactory,
+                CloudResourceTypeFactory,
+                CloudServiceFactory,
+            )
             from nautobot.dcim.factory import (
+                ConsolePortTemplateFactory,
+                ConsoleServerPortTemplateFactory,
                 ControllerFactory,
                 ControllerManagedDeviceGroupFactory,
                 DeviceFactory,
                 DeviceFamilyFactory,
                 DeviceRedundancyGroupFactory,
                 DeviceTypeFactory,
+                FrontPortTemplateFactory,
+                InterfaceTemplateFactory,
                 LocationFactory,
                 LocationTypeFactory,
                 ManufacturerFactory,
+                ModuleBayTemplateFactory,
+                ModuleFactory,
+                ModuleTypeFactory,
                 PlatformFactory,
+                PowerOutletTemplateFactory,
+                PowerPortTemplateFactory,
+                RearPortTemplateFactory,
                 SoftwareImageFileFactory,
                 SoftwareVersionFactory,
             )
+            from nautobot.extras.choices import MetadataTypeDataTypeChoices
             from nautobot.extras.factory import (
                 ContactFactory,
+                DynamicGroupFactory,
                 ExternalIntegrationFactory,
+                JobLogEntryFactory,
+                JobResultFactory,
+                MetadataChoiceFactory,
+                MetadataTypeFactory,
+                ObjectChangeFactory,
+                ObjectMetadataFactory,
                 RoleFactory,
+                SavedViewFactory,
                 StatusFactory,
                 TagFactory,
                 TeamFactory,
             )
             from nautobot.extras.management import populate_role_choices, populate_status_choices
-            from nautobot.extras.utils import TaggableClassesQuery
+            from nautobot.extras.models import MetadataType
+            from nautobot.extras.utils import FeatureQuery, TaggableClassesQuery
             from nautobot.ipam.choices import PrefixTypeChoices
             from nautobot.ipam.factory import (
                 NamespaceFactory,
@@ -103,6 +130,7 @@ class Command(BaseCommand):
                 VRFFactory,
             )
             from nautobot.tenancy.factory import TenantFactory, TenantGroupFactory
+            from nautobot.users.factory import UserFactory
         except ImportError as err:
             raise CommandError('Unable to load data factories. Is the "factory-boy" package installed?') from err
 
@@ -133,6 +161,8 @@ class Command(BaseCommand):
         )
         # ...and some tags that apply to a random subset of content-types
         _create_batch(TagFactory, 15, description="on some content-types")
+        _create_batch(UserFactory, 5)
+        _create_batch(SavedViewFactory, 20)
         _create_batch(ContactFactory, 20)
         _create_batch(TeamFactory, 20)
         _create_batch(TenantGroupFactory, 10, description="without parents", has_parent=False)
@@ -176,11 +206,25 @@ class Command(BaseCommand):
         _create_batch(SoftwareImageFileFactory, 25, description="to be usable by DeviceTypes")
         _create_batch(ManufacturerFactory, 4, description="without Platforms")  # 4 more hard-coded Manufacturers
         _create_batch(DeviceTypeFactory, 30)
+        _create_batch(ModuleTypeFactory, 20)
+        _create_batch(ConsolePortTemplateFactory, 30)
+        _create_batch(ConsoleServerPortTemplateFactory, 30)
+        _create_batch(RearPortTemplateFactory, 30)
+        _create_batch(FrontPortTemplateFactory, 30)
+        _create_batch(InterfaceTemplateFactory, 30)
+        _create_batch(PowerPortTemplateFactory, 30)
+        _create_batch(PowerOutletTemplateFactory, 30)
+        _create_batch(ModuleBayTemplateFactory, 90)
         _create_batch(ManufacturerFactory, 2, description="without Platforms or DeviceTypes")  # Last 2 hard-coded
         _create_batch(DeviceRedundancyGroupFactory, 20)
         _create_batch(DeviceFactory, 20)
+        _create_batch(ModuleFactory, 20)
         _create_batch(SoftwareVersionFactory, 5, description="without Devices")
         _create_batch(SoftwareImageFileFactory, 5, description="without DeviceTypes")
+        _create_batch(CloudAccountFactory, 10)
+        _create_batch(CloudResourceTypeFactory, 20)
+        _create_batch(CloudNetworkFactory, 20)
+        _create_batch(CloudServiceFactory, 20)
         _create_batch(CircuitTypeFactory, 40)
         _create_batch(ProviderFactory, 20, description="to be usable by Circuits")
         _create_batch(ProviderNetworkFactory, 20)
@@ -207,6 +251,38 @@ class Command(BaseCommand):
             has_location=False,
             term_side="Z",
         )
+        _create_batch(
+            CircuitTerminationFactory,
+            2,
+            description="with a cloud network, for side A",
+            has_location=False,
+            has_cloud_network=True,
+            term_side="A",
+        )
+        _create_batch(
+            CircuitTerminationFactory,
+            2,
+            description="with a cloud network, for side Z",
+            has_location=False,
+            has_cloud_network=True,
+            term_side="Z",
+        )
+        _create_batch(
+            CircuitTerminationFactory,
+            2,
+            description="with a provider network, for side A",
+            has_location=False,
+            has_cloud_network=False,
+            term_side="A",
+        )
+        _create_batch(
+            CircuitTerminationFactory,
+            2,
+            description="with a provider network, for side Z",
+            has_location=False,
+            has_cloud_network=False,
+            term_side="Z",
+        )
         _create_batch(
             CircuitTerminationFactory,
             2,
@@ -239,6 +315,37 @@ class Command(BaseCommand):
         # _create_batch(ClusterFactory, 10)
         # _create_batch(VirtualMachineFactory, 10)
         # We need to remove them from there and enable them here instead, but that will require many test updates.
+        _create_batch(DynamicGroupFactory, 20, description="and StaticGroupAssociations")
+        _create_batch(
+            MetadataTypeFactory,
+            len(MetadataTypeDataTypeChoices.CHOICES),
+            description="on all content-types",
+            content_types=ContentType.objects.filter(FeatureQuery("metadata").get_query()),
+        )
+        _create_batch(
+            MetadataTypeFactory,
+            2 * len(MetadataTypeDataTypeChoices.CHOICES),
+            description="on various content-types",
+        )
+        _create_batch(MetadataChoiceFactory, 100)
+        _create_batch(ObjectChangeFactory, 100)
+        _create_batch(ObjectMetadataFactory, 100)
+        _create_batch(
+            ObjectMetadataFactory,
+            20,
+            metadata_type=MetadataType.objects.filter(data_type=MetadataTypeDataTypeChoices.TYPE_CONTACT_TEAM).first(),
+            has_contact=True,
+            description="with contacts",
+        )
+        _create_batch(
+            ObjectMetadataFactory,
+            20,
+            metadata_type=MetadataType.objects.filter(data_type=MetadataTypeDataTypeChoices.TYPE_CONTACT_TEAM).first(),
+            has_contact=False,
+            description="with teams",
+        )
+        _create_batch(JobResultFactory, 20)
+        _create_batch(JobLogEntryFactory, 100)
 
     def handle(self, *args, **options):
         if options["flush"]:
@@ -259,7 +366,13 @@ Type 'yes' to continue, or 'no' to cancel: """
             self.stdout.write(
                 self.style.WARNING(f'Flushing all existing data from the database "{options["database"]}"...')
             )
-            call_command("flush", "--no-input", "--database", options["database"])
+
+            # If we already have a fixture file to use, suppress the "post_migrate" signal that "flush" would normally
+            # trigger, as that would lead to creation of Job records (etc.) that WILL conflict with the fixture data.
+            inhibit_post_migrate = options["cache_test_fixtures"] and os.path.exists(options["fixture_file"])
+            call_command(
+                "flush", "--no-input", "--database", options["database"], inhibit_post_migrate=inhibit_post_migrate
+            )
 
         if options["cache_test_fixtures"] and os.path.exists(options["fixture_file"]):
             self.stdout.write(self.style.WARNING(f"Loading factory data from file {options['fixture_file']}"))
@@ -277,7 +390,7 @@ Type 'yes' to continue, or 'no' to cancel: """
                     "dumpdata",
                     indent=2,
                     format="json",
-                    exclude=["auth.permission", "extras.job", "extras.customfield"],
+                    exclude=["auth.permission"],
                     output=options["fixture_file"],
                 )
 

nautobot/core/models/__init__.py

@@ -19,6 +19,7 @@ __all__ = (
     "BaseManager",
     "BaseModel",
     "CompositeKeyQuerySetMixin",
+    "ContentTypeRelatedQuerySet",
     "RestrictedQuerySet",
     "construct_composite_key",
     "construct_natural_slug",
@@ -46,16 +47,19 @@ class BaseModel(models.Model):
 
     id = models.UUIDField(primary_key=True, default=uuid.uuid4, unique=True, editable=False)
 
-    # Reverse relation so that deleting a BaseModel automatically deletes any ContactAssociations related to it.
-    associated_contacts = GenericRelation(
-        "extras.ContactAssociation",
-        content_type_field="associated_object_type",
-        object_id_field="associated_object_id",
-        related_query_name="associated_contacts_%(app_label)s_%(class)s",  # e.g. 'associated_contacts_dcim_device'
-    )
-
     objects = BaseManager.from_queryset(RestrictedQuerySet)()
-    is_contact_associable_model = True
+    is_contact_associable_model = False  # ContactMixin overrides this to default True
+    is_dynamic_group_associable_model = False  # DynamicGroupMixin overrides this to default True
+    is_metadata_associable_model = True
+    is_saved_view_model = False  # SavedViewMixin overrides this to default True
+    is_cloud_resource_type_model = False  # CloudResourceTypeMixin overrides this to default True
+
+    associated_object_metadatas = GenericRelation(
+        "extras.ObjectMetadata",
+        content_type_field="assigned_object_type",
+        object_id_field="assigned_object_id",
+        related_query_name="associated_object_metadatas_%(app_label)s_%(class)s",  # e.g. 'associated_object_metadatas_dcim_device'
+    )
 
     class Meta:
         abstract = True
@@ -295,3 +299,24 @@ class BaseModel(models.Model):
                 f"expected no more than {len(natural_key_field_lookups)} but got {len(args)}."
             )
         return dict(zip(natural_key_field_lookups, args))
+
+
+class ContentTypeRelatedQuerySet(RestrictedQuerySet):
+    def get_for_model(self, model):
+        """
+        Return all `self.model` instances assigned to the given model.
+        """
+        content_type = ContentType.objects.get_for_model(model._meta.concrete_model)
+        return self.filter(content_types=content_type)
+
+    # TODO(timizuo): Merge into get_for_model; Cant do this now cause it would require alot
+    #  of refactoring
+    def get_for_models(self, models_):
+        """
+        Return all `self.model` instances assigned to the given `_models`.
+        """
+        q = models.Q()
+        for model in models_:
+            q |= models.Q(app_label=model._meta.app_label, model=model._meta.model_name)
+        content_types = ContentType.objects.filter(q)
+        return self.filter(content_types__in=content_types)

nautobot/core/models/generics.py

@@ -4,14 +4,21 @@ from nautobot.core.models import BaseModel
 from nautobot.core.models.fields import TagsField
 from nautobot.extras.models.change_logging import ChangeLoggedModel
 from nautobot.extras.models.customfields import CustomFieldModel
-from nautobot.extras.models.mixins import DynamicGroupMixin, NotesMixin
+from nautobot.extras.models.mixins import ContactMixin, DynamicGroupsModelMixin, NotesMixin, SavedViewMixin
 from nautobot.extras.models.relationships import RelationshipModel
 
 logger = logging.getLogger(__name__)
 
 
 class OrganizationalModel(
-    BaseModel, ChangeLoggedModel, CustomFieldModel, RelationshipModel, DynamicGroupMixin, NotesMixin
+    ChangeLoggedModel,
+    ContactMixin,
+    CustomFieldModel,
+    DynamicGroupsModelMixin,
+    NotesMixin,
+    RelationshipModel,
+    SavedViewMixin,
+    BaseModel,
 ):
     """
     Base abstract model for all organizational models.
@@ -27,7 +34,16 @@ class OrganizationalModel(
         abstract = True
 
 
-class PrimaryModel(BaseModel, ChangeLoggedModel, CustomFieldModel, RelationshipModel, DynamicGroupMixin, NotesMixin):
+class PrimaryModel(
+    ChangeLoggedModel,
+    ContactMixin,
+    CustomFieldModel,
+    DynamicGroupsModelMixin,
+    NotesMixin,
+    RelationshipModel,
+    SavedViewMixin,
+    BaseModel,
+):
     """
     Base abstract model for all primary models.
 

nautobot/core/models/name_color_content_types.py

@@ -1,50 +1,29 @@
 from django.contrib.contenttypes.models import ContentType
 from django.db import models
-from django.db.models import Q
 
 from nautobot.core.choices import ColorChoices
 from nautobot.core.constants import CHARFIELD_MAX_LENGTH
-from nautobot.core.models import BaseManager, BaseModel
+from nautobot.core.models import BaseManager, BaseModel, ContentTypeRelatedQuerySet
 from nautobot.core.models.fields import ColorField
-from nautobot.core.models.querysets import RestrictedQuerySet
 from nautobot.extras.models.change_logging import ChangeLoggedModel
 
 # Importing CustomFieldModel, ChangeLoggedModel, RelationshipModel from  nautobot.extras.models
 # caused circular import error
 from nautobot.extras.models.customfields import CustomFieldModel
-from nautobot.extras.models.mixins import DynamicGroupMixin, NotesMixin
+from nautobot.extras.models.mixins import ContactMixin, DynamicGroupsModelMixin, NotesMixin, SavedViewMixin
 from nautobot.extras.models.relationships import RelationshipModel
 
 
-class ContentTypeRelatedQuerySet(RestrictedQuerySet):
-    def get_for_model(self, model):
-        """
-        Return all `self.model` instances assigned to the given model.
-        """
-        content_type = ContentType.objects.get_for_model(model._meta.concrete_model)
-        return self.filter(content_types=content_type)
-
-    # TODO(timizuo): Merge into get_for_model; Cant do this now cause it would require alot
-    #  of refactoring
-    def get_for_models(self, models_):
-        """
-        Return all `self.model` instances assigned to the given `_models`.
-        """
-        q = Q()
-        for model in models_:
-            q |= Q(app_label=model._meta.app_label, model=model._meta.model_name)
-        content_types = ContentType.objects.filter(q)
-        return self.filter(content_types__in=content_types)
-
-
 # TODO(timizuo): Inheriting from OrganizationalModel here causes partial import error
 class NameColorContentTypesModel(
-    BaseModel,
     ChangeLoggedModel,
+    ContactMixin,
     CustomFieldModel,
-    RelationshipModel,
+    DynamicGroupsModelMixin,
     NotesMixin,
-    DynamicGroupMixin,
+    RelationshipModel,
+    SavedViewMixin,
+    BaseModel,
 ):
     """
     This abstract base properties model contains fields and functionality that are

nautobot/core/models/querysets.py

@@ -6,7 +6,7 @@ from nautobot.core.utils import permissions
 from nautobot.core.utils.data import merge_dicts_without_collision
 
 
-def count_related(model, field, *, filter_dict=None, distinct=False):
+def count_related(model, field, *, filter_dict=None, manager_name="objects", distinct=False):
     """
     Return a Subquery suitable for annotating a child object count.
 
@@ -14,13 +14,14 @@ def count_related(model, field, *, filter_dict=None, distinct=False):
         model (Model): The related model to aggregate
         field (str): The field on the related model which points back to the OuterRef model
         filter_dict (dict): Optional dict of filter key/value pairs to limit the Subquery
+        manager_name (str): Name of the manager on the model to use
     """
     filters = {field: OuterRef("pk")}
     if filter_dict:
         filters.update(filter_dict)
 
-    manager = model.objects
-    if hasattr(model.objects, "without_tree_fields"):
+    manager = getattr(model, manager_name)
+    if hasattr(manager, "without_tree_fields"):
         manager = manager.without_tree_fields()
     qs = manager.filter(**filters).order_by().values(field)
     if distinct:

nautobot/core/models/tree_queries.py

@@ -65,7 +65,7 @@ class TreeManager(TreeManager_, BaseManager.from_queryset(TreeQuerySet)):
     Extend django-tree-queries' TreeManager to incorporate RestrictedQuerySet.
     """
 
-    _with_tree_fields = True
+    _with_tree_fields = False
     use_in_migrations = True
 
     @property

nautobot/core/models/utils.py

@@ -150,29 +150,45 @@ def serialize_object_v2(obj):
     return data
 
 
-def find_models_with_matching_fields(app_models, field_names, field_attributes=None):
+def find_models_with_matching_fields(app_models, field_names=None, field_attributes=None, additional_constraints=None):
     """
-    Find all models that have fields with the specified names, and return them grouped by app.
+    Find all models that have fields with the specified names and satisfy the additional constraints,
+    and return them grouped by app.
 
     Args:
         app_models (list[BaseModel]): A list of model classes to search through.
         field_names (list[str]): A list of names of fields that must be present in order for the model to be considered
         field_attributes (dict): Optional dictionary of attributes to filter the fields by.
+        additional_constraints (dict): Optional dictionary of `{field: value}` to further filter the models by.
 
     Return:
         (dict): A dictionary where the keys are app labels and the values are sets of model names.
     """
     registry_items = {}
+    field_names = field_names or []
     field_attributes = field_attributes or {}
+    additional_constraints = additional_constraints or {}
     for model_class in app_models:
         app_label, model_name = model_class._meta.label_lower.split(".")
+        valid_model = True
         for field_name in field_names:
             try:
                 field = model_class._meta.get_field(field_name)
-                if all((getattr(field, item, None) == value for item, value in field_attributes.items())):
-                    registry_items.setdefault(app_label, set()).add(model_name)
+                if not all((getattr(field, item, None) == value for item, value in field_attributes.items())):
+                    valid_model = False
+                    break
             except FieldDoesNotExist:
-                pass
+                valid_model = False
+                break
+        if valid_model:
+            if not all(
+                getattr(model_class, additional_field, None) == additional_value
+                for additional_field, additional_value in additional_constraints.items()
+            ):
+                valid_model = False
+        if valid_model:
+            registry_items.setdefault(app_label, set()).add(model_name)
+
     registry_items = {key: sorted(value) for key, value in registry_items.items()}
     return registry_items
 

nautobot/core/settings.py

@@ -96,13 +96,6 @@ if "NAUTOBOT_DEPLOYMENT_ID" in os.environ and os.environ["NAUTOBOT_DEPLOYMENT_ID
 if "NAUTOBOT_DEVICE_NAME_AS_NATURAL_KEY" in os.environ and os.environ["NAUTOBOT_DEVICE_NAME_AS_NATURAL_KEY"] != "":
     DEVICE_NAME_AS_NATURAL_KEY = is_truthy(os.environ["NAUTOBOT_DEVICE_NAME_AS_NATURAL_KEY"])
 
-# The number of seconds to cache the member list of dynamic groups. Set this to `0` to disable caching.
-if (
-    "NAUTOBOT_DYNAMIC_GROUPS_MEMBER_CACHE_TIMEOUT" in os.environ
-    and os.environ["NAUTOBOT_DYNAMIC_GROUPS_MEMBER_CACHE_TIMEOUT"] != ""
-):
-    DYNAMIC_GROUPS_MEMBER_CACHE_TIMEOUT = int(os.environ["NAUTOBOT_DYNAMIC_GROUPS_MEMBER_CACHE_TIMEOUT"])
-
 # Exclude potentially sensitive models from wildcard view exemption. These may still be exempted
 # by specifying the model individually in the EXEMPT_VIEW_PERMISSIONS configuration parameter.
 EXEMPT_EXCLUDE_MODELS = (
@@ -517,6 +510,7 @@ INSTALLED_APPS = [
     "rest_framework",  # Must be after `nautobot.core` for template overrides
     "db_file_storage",
     "nautobot.circuits",
+    "nautobot.cloud",
     "nautobot.dcim",
     "nautobot.ipam",
     "nautobot.extras",
@@ -533,7 +527,6 @@ INSTALLED_APPS = [
     # "health_check.contrib.migrations",
     # "health_check.contrib.redis",
     "django_extensions",
-    "constance.backends.database",
     "django_ajax_tables",
     "silk",
 ]
@@ -714,14 +707,6 @@ CONSTANCE_CONFIG = {
         "Used for sending anonymous installation metrics, when settings.INSTALLATION_METRICS_ENABLED is set to True.",
         field_type=str,
     ),
-    "DYNAMIC_GROUPS_MEMBER_CACHE_TIMEOUT": ConstanceConfigItem(
-        default=0,
-        help_text="Dynamic Group member cache timeout in seconds. This is the amount of time that a Dynamic Group's member list "
-        "will be cached in Django cache backend. Since retrieving the member list of a Dynamic Group can be a very "
-        "expensive operation, especially in reverse, this cache is used to speed up the process of retrieving the "
-        "member list. This cache is invalidated when a Dynamic Group is saved. Set to 0 to disable caching.",
-        field_type=int,
-    ),
     "JOB_CREATE_FILE_MAX_SIZE": ConstanceConfigItem(
         default=10 << 20,
         help_text=mark_safe(  # noqa: S308  # suspicious-mark-safe-usage, but this is a static string so it's safe
@@ -815,7 +800,7 @@ CONSTANCE_CONFIG_FIELDSETS = {
     "Installation Metrics": ["DEPLOYMENT_ID"],
     "Natural Keys": ["DEVICE_NAME_AS_NATURAL_KEY", "LOCATION_NAME_AS_NATURAL_KEY"],
     "Pagination": ["PAGINATE_COUNT", "MAX_PAGE_SIZE", "PER_PAGE_DEFAULTS"],
-    "Performance": ["DYNAMIC_GROUPS_MEMBER_CACHE_TIMEOUT", "JOB_CREATE_FILE_MAX_SIZE"],
+    "Performance": ["JOB_CREATE_FILE_MAX_SIZE"],
     "Rack Elevation Rendering": [
         "RACK_ELEVATION_DEFAULT_UNIT_HEIGHT",
         "RACK_ELEVATION_DEFAULT_UNIT_WIDTH",
@@ -907,24 +892,13 @@ CELERY_TASK_TRACK_STARTED = True
 # If enabled, a `task-sent` event will be sent for every task so tasks can be tracked before they're consumed by a worker.
 CELERY_TASK_SEND_SENT_EVENT = True
 
-# How many tasks a worker is allowed to reserve for its own consumption and execution.
-# If set to zero (not recommended) a single worker can reserve all tasks even if other workers are free.
-# For short running tasks (such as webhooks) you may want to set this to a larger number to increase throughput.
-# Conversely, for long running tasks (such as SSoT or Golden-Config Jobs at scale) you may want to set this to 1
-# so that a worker executing a long-running task will not prefetch other tasks, which would block their execution
-# until the long-running task completes.
-# https://docs.celeryq.dev/en/stable/userguide/optimizing.html#prefetch-limits
-CELERY_WORKER_PREFETCH_MULTIPLIER = int(os.getenv("NAUTOBOT_CELERY_WORKER_PREFETCH_MULTIPLIER", "4"))
-
 # If enabled stdout and stderr of running jobs will be redirected to the task logger.
 CELERY_WORKER_REDIRECT_STDOUTS = is_truthy(os.getenv("NAUTOBOT_CELERY_WORKER_REDIRECT_STDOUTS", "True"))
 
-# The log level of log messages generated by redirected job stdout and stderr.
-# Can be one of `DEBUG`, `INFO`, `WARNING`, `ERROR`, or `CRITICAL`.
+# The log level of log messages generated by redirected job stdout and stderr. Can be one of `DEBUG`, `INFO`, `WARNING`, `ERROR`, or `CRITICAL`.
 CELERY_WORKER_REDIRECT_STDOUTS_LEVEL = os.getenv("NAUTOBOT_CELERY_WORKER_REDIRECT_STDOUTS_LEVEL", "WARNING")
 
-# Send task-related events so that tasks can be monitored using tools like flower.
-# Sets the default value for the workers -E argument.
+# Send task-related events so that tasks can be monitored using tools like flower. Sets the default value for the workers -E argument.
 CELERY_WORKER_SEND_TASK_EVENTS = True
 
 # Default celery queue name that will be used by workers and tasks if no queue is specified

nautobot/core/settings.yaml

@@ -426,20 +426,6 @@ properties:
     see_also:
       "`CELERY_TASK_SOFT_TIME_LIMIT`": "#celery_task_soft_time_limit"
     type: "integer"
-  CELERY_WORKER_PREFETCH_MULTIPLIER:
-    default: 4
-    description: "How many tasks a worker is allowed to reserve for its own consumption and execution."
-    details: >-
-      If set to `0` (not recommended) a single worker can reserve all tasks even if other workers are free.
-      For short running tasks (such as webhooks) you may want to set this to a larger number to increase throughput.
-      Conversely, for long-running tasks (such as SSoT or Golden-Config Jobs at scale) you may want to set this to `1`
-      so that a worker executing a long-running task will not prefetch other tasks, which would block their execution
-      until the long-running task completes.
-    environment_variable: "NAUTOBOT_CELERY_WORKER_PREFETCH_MULTIPLIER"
-    see_also:
-      "Celery documentation": "https://docs.celeryq.dev/en/stable/userguide/optimizing.html#prefetch-limits"
-    type: "integer"
-    version_added: "2.2.9"
   CELERY_WORKER_PROMETHEUS_PORTS:
     default: []
     description: "Ports for Prometheus metric HTTP server running on the celery worker(s)."
@@ -481,6 +467,12 @@ properties:
       !!! warning
           If enabling indefinite changelog retention, it is recommended to periodically delete old entries.
           Otherwise, the database may eventually exceed capacity.
+
+      +/- 2.2.0
+          As of Nautobot 2.2.0, changelog cleanup does not run automatically. Use the `Cleanup of ObjectChange records`
+          system Job to handle changelog cleanup; you may schedule this to run automatically like any other Job if
+          desired. The `CHANGELOG_RETENTION` setting provides a default age cutoff for the Job but may be overridden
+          at runtime if desired.
     environment_variable: "NAUTOBOT_CHANGELOG_RETENTION"
     is_constance_config: true
     type: "integer"
@@ -732,19 +724,6 @@ properties:
     is_constance_config: true
     type: "boolean"
     version_added: "2.0.0"
-  DYNAMIC_GROUPS_MEMBER_CACHE_TIMEOUT:
-    default: 0
-    description: >-
-      The number of seconds to cache the member list of dynamic groups. Set this to `0` to disable caching.
-    details: >-
-      With large datasets (those in scope of a Dynamic Group and number of Dynamic Groups themselves),
-      users will encounter a performance penalty using or accessing the membership lists.
-      This setting allows users to accept a cached list for common use cases (particularly in the UI)
-      that expires after the configured time."
-    environment_variable: "NAUTOBOT_DYNAMIC_GROUPS_MEMBER_CACHE_TIMEOUT"
-    is_constance_config: true
-    type: "integer"
-    version_added: "1.6.0"
   EXEMPT_VIEW_PERMISSIONS:
     default: []
     description: "A list of Nautobot models to exempt from the enforcement of view permissions."
@@ -1120,6 +1099,34 @@ properties:
       * `nautobot.core.graphql.*` - [GraphQL](../../platform-functionality/graphql.md) initialization and operation.
       * `nautobot.extras.plugins.*` - App loading and activity
       * `nautobot.core.views.generic.*` - Generic views which handle business logic for the web UI
+
+      #### Structlog Configuration
+
+      As of Nautobot 2.3, [django-structlog](https://django-structlog.readthedocs.io/en/latest/) is added as a core dependency. To use structlog, you can add the following code to your `nautobot_config.py` file:
+
+      ```python
+      from nautobot.core.settings_funcs import setup_structlog_logging
+
+      setup_structlog_logging(
+          LOGGING,
+          INSTALLED_APPS,
+          MIDDLEWARE,
+          log_level="DEBUG" if DEBUG else "INFO",
+          root_level="INFO",
+          plain_format=bool(DEBUG),  # Set to True to use human-readable structlog format over JSON
+          debug_db=False,  # Set to True to log all database queries
+      )
+      ```
+
+      Calling this function disables logging if running tests, otherwise:
+
+      * Overwrites all `formatters` and `handlers` to avoid logging duplication.
+          It's possible to add custom `formatters` and `handlers` after calling this function.
+      * Updates all `loggers` to use structlog with the specified `log_level`.
+      * Adds or updates the root logger to use structlog with the specified `root_level`.
+      * Uses a human-readable structlog format if `plain_format` is True, otherwise uses JSON.
+      * Adds database query logging if `debug_db` is True.
+      * Adds necessary Django apps and middleware for structlog.
     properties:
       additionalProperties: true
       disable_existing_loggers: