nautobot 2.4.13__py3-none-any.whl → 2.4.15__py3-none-any.whl

nautobot/extras/choices.py

@@ -483,22 +483,30 @@ class SecretsGroupAccessTypeChoices(ChoiceSet):
 
 
 class SecretsGroupSecretTypeChoices(ChoiceSet):
+    TYPE_AUTHKEY = "authentication-key"
+    TYPE_AUTHPROTOCOL = "authentication-protocol"
     TYPE_KEY = "key"
+    TYPE_NOTES = "notes"
     TYPE_PASSWORD = "password"  # noqa: S105  # hardcoded-password-string -- false positive
+    TYPE_PRIVALGORITHM = "private-algorithm"
+    TYPE_PRIVKEY = "private-key"
     TYPE_SECRET = "secret"  # noqa: S105  # hardcoded-password-string -- false positive
     TYPE_TOKEN = "token"  # noqa: S105  # hardcoded-password-string -- false positive
-    TYPE_USERNAME = "username"
     TYPE_URL = "url"
-    TYPE_NOTES = "notes"
+    TYPE_USERNAME = "username"
 
     CHOICES = (
+        (TYPE_AUTHKEY, "Authentication Key"),
+        (TYPE_AUTHPROTOCOL, "Authentication Protocol"),
         (TYPE_KEY, "Key"),
+        (TYPE_NOTES, "Notes"),
         (TYPE_PASSWORD, "Password"),
+        (TYPE_PRIVALGORITHM, "Private Algorithm"),
+        (TYPE_PRIVKEY, "Private Key"),
         (TYPE_SECRET, "Secret"),
         (TYPE_TOKEN, "Token"),
-        (TYPE_USERNAME, "Username"),
         (TYPE_URL, "URL"),
-        (TYPE_NOTES, "Notes"),
+        (TYPE_USERNAME, "Username"),
     )
 
 

nautobot/extras/factory.py

@@ -1,4 +1,4 @@
-from datetime import timedelta, timezone
+from datetime import timezone
 import json
 
 from django.contrib.auth import get_user_model
@@ -137,8 +137,10 @@ class JobLogEntryFactory(BaseModelFactory):
     def created(self):
         if self.job_result.date_done:
             return faker.Faker().date_time_between_dates(
-                datetime_start=self.job_result.date_created, datetime_end=self.job_result.date_done, tzinfo=timezone.utc
+                datetime_start=self.job_result.date_started, datetime_end=self.job_result.date_done, tzinfo=timezone.utc
             )
+        elif self.job_result.date_started:
+            return faker.Faker().past_datetime(start_date=self.job_result.date_started, tzinfo=timezone.utc)
         return faker.Faker().past_datetime(start_date=self.job_result.date_created, tzinfo=timezone.utc)
 
 
@@ -183,7 +185,7 @@ class JobResultFactory(BaseModelFactory):
     job_model = factory.Maybe("has_job_model", random_instance(Job), None)
     name = factory.Faker("word")
     task_name = factory.Faker("word")
-    # date_created and date_done are handled below
+    # date_created, date_started, and date_done are handled below
     user = factory.Maybe("has_user", random_instance(get_user_model()), None)
     status = factory.Iterator(
         [
@@ -210,23 +212,20 @@ class JobResultFactory(BaseModelFactory):
         return None
 
     @factory.post_generation
-    def date_created(self, created, extracted, **kwargs):  # pylint: disable=method-hidden
-        if created:
-            if extracted:
-                self.date_created = extracted
-            else:
-                self.date_created = faker.Faker().date_time_between(
-                    start_date="-1y", end_date="now", tzinfo=timezone.utc
-                )
-
-    @factory.post_generation
-    def date_done(self, created, extracted, **kwargs):  # pylint: disable=method-hidden
-        if created:
-            if extracted:
-                self.date_done = extracted
-            else:
-                # TODO, should we create "in progress" job results without a date_done value as well?
-                self.date_done = self.date_created + timedelta(minutes=faker.Faker().random_int())
+    def dates(self, created, extracted, **kwargs):  # pylint: disable=method-hidden
+        if not created:
+            return
+        if extracted:
+            return
+        # Create a date_created in the past, but not too far in the past
+        self.date_created = faker.Faker().date_time_between(start_date="-1y", end_date="-1w", tzinfo=timezone.utc)
+        self.date_started = faker.Faker().date_time_between(
+            start_date=self.date_created, end_date="-1d", tzinfo=timezone.utc
+        )
+        # TODO, should we create "in progress" job results without a date_done value as well?
+        self.date_done = faker.Faker().date_time_between(
+            start_date=self.date_started, end_date="now", tzinfo=timezone.utc
+        )
 
 
 class MetadataChoiceFactory(BaseModelFactory):

nautobot/extras/filters/__init__.py

@@ -1,4 +1,5 @@
 from difflib import get_close_matches
+from uuid import UUID
 
 from django.conf import settings
 from django.contrib.auth import get_user_model
@@ -1012,7 +1013,7 @@ class JobResultFilterSet(BaseFilterSet, CustomFieldModelFilterSetMixin):
 
     class Meta:
         model = JobResult
-        fields = ["id", "date_created", "date_done", "name", "status", "user", "scheduled_job"]
+        fields = ["id", "date_created", "date_started", "date_done", "name", "status", "user", "scheduled_job"]
 
 
 class JobLogEntryFilterSet(BaseFilterSet):
@@ -1193,7 +1194,7 @@ class NoteFilterSet(BaseFilterSet):
         filter_predicates={
             "user_name": "icontains",
             "note": "icontains",
-            "assigned_object_id": "exact",
+            "assigned_object_id": {"lookup_expr": "exact", "preprocessor": UUID},
         },
     )
     assigned_object_type = ContentTypeFilter()

nautobot/extras/filters/mixins.py

@@ -1,5 +1,7 @@
 from django.contrib.contenttypes.models import ContentType
 from django.db.models import Model, Q
+from django.utils.encoding import force_str
+from django.utils.text import capfirst
 import django_filters
 from django_filters.constants import EMPTY_VALUES
 from django_filters.utils import verbose_lookup_expr
@@ -74,7 +76,9 @@ class CustomFieldModelFilterSetMixin(django_filters.FilterSet):
             CustomFieldTypeChoices.TYPE_SELECT: CustomFieldSelectFilter,
         }
 
-        custom_fields = CustomField.objects.get_for_model(self._meta.model, exclude_filter_disabled=True)
+        custom_fields = CustomField.objects.get_for_model(
+            self._meta.model, exclude_filter_disabled=True, get_queryset=False
+        )
         for cf in custom_fields:
             # Determine filter class for this CustomField type, default to CustomFieldCharFilter
             new_filter_name = cf.add_prefix_to_cf_key()
@@ -129,11 +133,21 @@ class CustomFieldModelFilterSetMixin(django_filters.FilterSet):
         # Create new filters for each lookup expression in the map
         for lookup_name, lookup_expr in lookup_map.items():
             new_filter_name = f"{filter_name}__{lookup_name}"
+
+            # Based on logic in BaseFilterSet._generate_lookup_expression_filters
+            verbose_expression = (
+                ["exclude", custom_field.label] if lookup_name.startswith("n") else [custom_field.label]
+            )
+            if isinstance(lookup_expr, str):
+                verbose_expression.append(verbose_lookup_expr(lookup_expr))
+            verbose_expression = [force_str(part) for part in verbose_expression if part]
+            label = capfirst(" ".join(verbose_expression))
+
             new_filter = filter_type(
                 field_name=custom_field.key,
                 lookup_expr=lookup_expr,
                 custom_field=custom_field,
-                label=f"{custom_field.label} ({verbose_lookup_expr(lookup_expr)})",
+                label=label,
                 exclude=lookup_name.startswith("n"),
             )
 
@@ -220,13 +234,13 @@ class RelationshipModelFilterSetMixin(django_filters.FilterSet):
         """
         Append form fields for all Relationships assigned to this model.
         """
-        src_relationships, dst_relationships = Relationship.objects.get_for_model(model=model, hidden=False)
+        src_relationships, dst_relationships = Relationship.objects.get_for_model(
+            model=model, hidden=False, get_queryset=False
+        )
 
-        for rel in src_relationships:
-            self._append_relationships_side([rel], RelationshipSideChoices.SIDE_SOURCE, model)
+        self._append_relationships_side(src_relationships, RelationshipSideChoices.SIDE_SOURCE, model)
 
-        for rel in dst_relationships:
-            self._append_relationships_side([rel], RelationshipSideChoices.SIDE_DESTINATION, model)
+        self._append_relationships_side(dst_relationships, RelationshipSideChoices.SIDE_DESTINATION, model)
 
     def _append_relationships_side(self, relationships, initial_side, model):
         """
@@ -295,6 +309,7 @@ class RoleModelFilterSetMixin(django_filters.FilterSet):
                 field_name="role",
                 query_params={"content_types": [cls._meta.model._meta.label_lower]},
             )
+            cls.declared_filters["role"] = filters["role"]  # pylint: disable=no-member
 
         return filters
 
@@ -324,5 +339,6 @@ class StatusModelFilterSetMixin(django_filters.FilterSet):
                 field_name="status",
                 query_params={"content_types": [cls._meta.model._meta.label_lower]},
             )
+            cls.declared_filters["status"] = filters["status"]  # pylint: disable=no-member
 
         return filters

nautobot/extras/forms/__init__.py

@@ -12,5 +12,6 @@ from .contacts import (
     TeamFilterForm,
     TeamForm,
 )
-from .forms import *  # noqa: F403  # undefined-local-with-import-star
+
 from .mixins import *  # noqa: F403  # undefined-local-with-import-star
+from .forms import *  # noqa: F403  # undefined-local-with-import-star

nautobot/extras/forms/forms.py

@@ -43,6 +43,7 @@ from nautobot.core.utils.deprecation import class_deprecated_in_favor_of
 from nautobot.dcim.models import Device, DeviceRedundancyGroup, DeviceType, Location, Platform
 from nautobot.extras.choices import (
     ButtonClassChoices,
+    CustomFieldFilterLogicChoices,
     DynamicGroupTypeChoices,
     JobExecutionType,
     JobQueueTypeChoices,
@@ -134,6 +135,7 @@ __all__ = (
     "ConfigContextSchemaForm",
     "CustomFieldBulkCreateForm",  # 2.0 TODO remove this deprecated class
     "CustomFieldBulkDeleteForm",
+    "CustomFieldBulkEditForm",
     "CustomFieldChoiceFormSet",
     "CustomFieldFilterForm",
     "CustomFieldForm",
@@ -197,6 +199,7 @@ __all__ = (
     "SecretFilterForm",
     "SecretForm",
     "SecretsGroupAssociationFormSet",
+    "SecretsGroupBulkEditForm",
     "SecretsGroupFilterForm",
     "SecretsGroupForm",
     "StaticGroupAssociationFilterForm",
@@ -464,6 +467,66 @@ class CustomFieldDescriptionField(CommentField):
         return "Also used as the help text when editing models using this custom field.<br>" + super().default_helptext
 
 
+class CustomFieldBulkEditForm(BootstrapMixin, NoteModelBulkEditFormMixin):
+    pk = forms.ModelMultipleChoiceField(queryset=CustomField.objects.all(), widget=forms.MultipleHiddenInput)
+    grouping = forms.CharField(
+        required=False,
+        max_length=CHARFIELD_MAX_LENGTH,
+        label="Grouping",
+        help_text="Human-readable grouping that this custom field belongs to.",
+    )
+    description = forms.CharField(
+        required=False,
+        max_length=CHARFIELD_MAX_LENGTH,
+        label="Description",
+        help_text="A helpful description for this field.",
+    )
+    required = forms.NullBooleanField(
+        required=False,
+        widget=BulkEditNullBooleanSelect,
+        label="Required",
+        help_text="If true, this field is required when creating new objects or editing an existing object.",
+    )
+    filter_logic = forms.ChoiceField(
+        required=False,
+        choices=add_blank_choice(CustomFieldFilterLogicChoices.CHOICES),
+        label="Filter logic",
+        help_text="Loose matches any instance of a given string; Exact matches the entire field.",
+    )
+    weight = forms.IntegerField(
+        required=False, label="Weight", help_text="Fields with higher weights appear lower in a form."
+    )
+    advanced_ui = forms.NullBooleanField(
+        required=False,
+        widget=BulkEditNullBooleanSelect,
+        label="Move to Advanced tab",
+        help_text="Hide this field from the object's primary information tab. It will appear in the 'Advanced' tab instead.",
+    )
+    add_content_types = MultipleContentTypeField(
+        limit_choices_to=FeatureQuery("custom_fields"), required=False, label="Add Content Types"
+    )
+    remove_content_types = MultipleContentTypeField(
+        limit_choices_to=FeatureQuery("custom_fields"), required=False, label="Remove Content Types"
+    )
+
+    class Meta:
+        model = CustomField
+        fields = (
+            "grouping",
+            "description",
+            "required",
+            "filter_logic",
+            "weight",
+            "advanced_ui",
+            "add_content_types",
+            "remove_content_types",
+        )
+        nullable_fields = [
+            "grouping",
+            "description",
+        ]
+
+
 class CustomFieldForm(BootstrapMixin, forms.ModelForm):
     label = forms.CharField(
         required=True, max_length=CHARFIELD_MAX_LENGTH, help_text="Name of the field as displayed to users."
@@ -2082,6 +2145,14 @@ class RoleFilterForm(NautobotFilterForm):
 #
 
 
+class SecretsGroupBulkEditForm(NautobotBulkEditForm):
+    pk = forms.ModelMultipleChoiceField(queryset=SecretsGroup.objects.all(), widget=forms.MultipleHiddenInput())
+    description = forms.CharField(max_length=CHARFIELD_MAX_LENGTH, required=False)
+
+    class Meta:
+        model = SecretsGroup
+
+
 def provider_choices():
     return sorted([(slug, provider.name) for slug, provider in registry["secrets_providers"].items()])
 

nautobot/extras/forms/mixins.py

@@ -95,7 +95,7 @@ class CustomFieldModelFilterFormMixin(forms.Form):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
-        custom_fields = CustomField.objects.get_for_model(self.model, exclude_filter_disabled=True)
+        custom_fields = CustomField.objects.get_for_model(self.model, exclude_filter_disabled=True, get_queryset=False)
         self.custom_fields = []
         for cf in custom_fields:
             field_name = cf.add_prefix_to_cf_key()
@@ -714,7 +714,9 @@ class RelationshipModelFilterFormMixin(forms.Form):
         """
         Append form fields for all Relationships assigned to this model.
         """
-        src_relationships, dst_relationships = Relationship.objects.get_for_model(model=self.model, hidden=False)
+        src_relationships, dst_relationships = Relationship.objects.get_for_model(
+            model=self.model, hidden=False, get_queryset=False
+        )
 
         for rel in src_relationships:
             self._append_relationships_side([rel], RelationshipSideChoices.SIDE_SOURCE)

nautobot/extras/managers.py

@@ -111,10 +111,13 @@ class JobResultManager(BaseManager.from_queryset(RestrictedQuerySet), TaskResult
         except Job.DoesNotExist:
             pass
 
+        if "date_started" in kwargs:
+            fields["date_started"] = kwargs["date_started"]
+
         obj, created = self.using(using).get_or_create(id=task_id, defaults=fields)
 
         if not created:
-            # Make sure `date_done` is allowed to stay null until the task reacheas a ready state.
+            # Make sure `date_done` is allowed to stay null until the task reaches a ready state.
             #
             # Default behavior in `django-celery-results` has this field as a
             # `DateField(auto_now=True)` which just automatically updates the `date_done` field on every

nautobot/extras/migrations/0062_collect_roles_from_related_apps_roles.py

@@ -1,7 +1,6 @@
 # Generated by Django 3.2.16 on 2022-11-19 23:15
 
 from collections import namedtuple
-import logging
 
 from django.db import migrations, models
 
@@ -24,8 +23,6 @@ color_map = {
     "success": ColorChoices.COLOR_GREEN,
 }
 
-logger = logging.getLogger(__name__)
-
 
 def create_equivalent_roles_of_virtualmachine_device_role(apps):
     """Create equivalent roles for the VirtualMachine DeviceRole."""
@@ -82,17 +79,43 @@ def create_roles(apps, roles_to_create, content_types):
                 "description": old_role.description,
                 "color": getattr(old_role, "color", color_map["default"]),
                 "weight": getattr(old_role, "weight", None),
+                "_custom_field_data": getattr(old_role, "_custom_field_data", {}),
             },
         )
         if created:
-            logger.info(f'Created Role "{new_role.name}"')
+            print(f"    Created Role {new_role.name!r}")
+        else:
+            updated = False
+            # Fix up in the case of overlapping roles
+            if new_role.weight is None and hasattr(old_role, "weight"):
+                new_role.weight = old_role.weight
+                updated = True
+            if old_role.description and not new_role.description:
+                new_role.description = old_role.description
+                updated = True
+            if hasattr(old_role, "_custom_field_data"):
+                for field, value in old_role._custom_field_data.items():
+                    if field in new_role._custom_field_data:
+                        if new_role._custom_field_data[field] != value:
+                            print(
+                                f"    Value conflict for custom field {field!r} for role {new_role.name!r} - DATA LOSS"
+                            )
+                    else:
+                        new_role._custom_field_data[field] = value
+                        updated = True
+            if updated:
+                print(f"    Updated Role {new_role.name!r}")
+                new_role.save()
+            else:
+                print(f"    No changes to already-created Role {new_role.name!r}")
+
         if old_role_ct and hasattr(old_role, "pk"):
             # Move over existing object change records to the new role we created
             updated_count = ObjectChange.objects.filter(
                 changed_object_type=old_role_ct, changed_object_id=old_role.pk
             ).update(changed_object_type=new_role_ct, changed_object_id=new_role.pk)
-            logger.info(
-                f'Updated {updated_count} ObjectChanges from the existing "{old_role.name}" {old_role._meta.label}'
+            print(
+                f"    Updated {updated_count} ObjectChanges from the existing {old_role.name!r} {old_role._meta.label}"
             )
 
     # This is for all of the change records for roles which no longer exist
@@ -100,7 +123,7 @@ def create_roles(apps, roles_to_create, content_types):
         updated_count = ObjectChange.objects.filter(changed_object_type=old_role_ct).update(
             changed_object_type=new_role_ct
         )
-        logger.info(f"Updated {updated_count} leftover ObjectChanges from deleted {old_role_ct.model} records.")
+        print(f"    Updated {updated_count} leftover ObjectChanges from deleted {old_role_ct.model} records.")
 
     roles = Role.objects.filter(name__in=[roles.name for roles in roles_to_create])
 

nautobot/extras/migrations/0124_add_joblogentry_index.py

@@ -0,0 +1,16 @@
+# Generated by Django 4.2.23 on 2025-07-31 23:49
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("extras", "0123_alter_joblogentry_created"),
+    ]
+
+    operations = [
+        migrations.AddIndex(
+            model_name="joblogentry",
+            index=models.Index(fields=["job_result", "created"], name="extras_joblog_jr_created_idx"),
+        ),
+    ]

nautobot/extras/migrations/0125_jobresult_date_started.py

@@ -0,0 +1,18 @@
+# Generated by Django 4.2.23 on 2025-08-11 16:18
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("django_celery_results", "0012_taskresult_date_started"),
+        ("extras", "0124_add_joblogentry_index"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="jobresult",
+            name="date_started",
+            field=models.DateTimeField(blank=True, db_index=True, null=True),
+        ),
+    ]

nautobot/extras/models/customfields.py

@@ -1,4 +1,4 @@
-from collections import OrderedDict
+from collections import defaultdict, OrderedDict
 from datetime import date, datetime
 import json
 import logging
@@ -48,21 +48,42 @@ logger = logging.getLogger(__name__)
 class ComputedFieldManager(BaseManager.from_queryset(RestrictedQuerySet)):
     use_in_migrations = True
 
-    def get_for_model(self, model):
+    def get_for_model(self, model, get_queryset=True):
         """
         Return all ComputedFields assigned to the given model.
+
+        Returns a queryset by default, or a list if `get_queryset` param is False.
         """
         concrete_model = model._meta.concrete_model
         cache_key = f"{self.get_for_model.cache_key_prefix}.{concrete_model._meta.label_lower}"
+        list_cache_key = f"{cache_key}.list"
+        if not get_queryset:
+            listing = cache.get(list_cache_key)
+            if listing is not None:
+                return listing
         queryset = cache.get(cache_key)
         if queryset is None:
             content_type = ContentType.objects.get_for_model(concrete_model)
             queryset = self.get_queryset().filter(content_type=content_type)
             cache.set(cache_key, queryset)
+        if not get_queryset:
+            listing = list(queryset)
+            cache.set(list_cache_key, listing)
+            return listing
         return queryset
 
     get_for_model.cache_key_prefix = "nautobot.extras.computedfield.get_for_model"
 
+    def populate_list_caches(self):
+        """Populate all caches for `get_for_model(..., get_queryset=False)` lookups."""
+        queryset = self.all().select_related("content_type")
+        listings = defaultdict(list)
+        for cf in queryset:
+            listings[f"{cf.content_type.app_label}.{cf.content_type.model}"].append(cf)
+        for ct in ContentType.objects.all():
+            label = f"{ct.app_label}.{ct.model}"
+            cache.set(f"{self.get_for_model.cache_key_prefix}.{label}.list", listings[label])
+
 
 @extras_features("graphql")
 class ComputedField(
@@ -370,18 +391,24 @@ class CustomFieldModel(models.Model):
 class CustomFieldManager(BaseManager.from_queryset(RestrictedQuerySet)):
     use_in_migrations = True
 
-    def get_for_model(self, model, exclude_filter_disabled=False):
+    def get_for_model(self, model, exclude_filter_disabled=False, get_queryset=True):
         """
         Return (and cache) all CustomFields assigned to the given model.
 
         Args:
             model (Model): The django model to which custom fields are registered
             exclude_filter_disabled (bool): Exclude any custom fields which have filter logic disabled
+            get_queryset (bool): Whether to return a QuerySet or a list.
         """
         concrete_model = model._meta.concrete_model
         cache_key = (
             f"{self.get_for_model.cache_key_prefix}.{concrete_model._meta.label_lower}.{exclude_filter_disabled}"
         )
+        list_cache_key = f"{cache_key}.list"
+        if not get_queryset:
+            listing = cache.get(list_cache_key)
+            if listing is not None:
+                return listing
         queryset = cache.get(cache_key)
         if queryset is None:
             content_type = ContentType.objects.get_for_model(concrete_model)
@@ -389,6 +416,10 @@ class CustomFieldManager(BaseManager.from_queryset(RestrictedQuerySet)):
             if exclude_filter_disabled:
                 queryset = queryset.exclude(filter_logic=CustomFieldFilterLogicChoices.FILTER_DISABLED)
             cache.set(cache_key, queryset)
+        if not get_queryset:
+            listing = list(queryset)
+            cache.set(list_cache_key, listing)
+            return listing
         return queryset
 
     get_for_model.cache_key_prefix = "nautobot.extras.customfield.get_for_model"
@@ -405,6 +436,24 @@ class CustomFieldManager(BaseManager.from_queryset(RestrictedQuerySet)):
 
     keys_for_model.cache_key_prefix = "nautobot.extras.customfield.keys_for_model"
 
+    def populate_list_caches(self):
+        """Populate all caches for `get_for_model(..., get_queryset=False)` and `keys_for_model` lookups."""
+        queryset = self.all().prefetch_related("content_types")
+        cf_listings = defaultdict(lambda: defaultdict(list))
+        key_listings = defaultdict(list)
+        for cf in queryset:
+            for ct in cf.content_types.all():
+                label = f"{ct.app_label}.{ct.model}"
+                cf_listings[label][False].append(cf)
+                if cf.filter_logic != CustomFieldFilterLogicChoices.FILTER_DISABLED:
+                    cf_listings[label][True].append(cf)
+                key_listings[label].append(cf.key)
+        for ct in ContentType.objects.all():
+            label = f"{ct.app_label}.{ct.model}"
+            cache.set(f"{self.get_for_model.cache_key_prefix}.{label}.True.list", cf_listings[label][True])
+            cache.set(f"{self.get_for_model.cache_key_prefix}.{label}.False.list", cf_listings[label][False])
+            cache.set(f"{self.keys_for_model.cache_key_prefix}.{label}", key_listings[label])
+
 
 @extras_features("webhooks")
 class CustomField(
@@ -465,8 +514,7 @@ class CustomField(
         blank=True,
         null=True,
         help_text=(
-            "Default value for the field (must be a JSON value). Encapsulate strings with double quotes (e.g. "
-            '"Foo").'
+            'Default value for the field (must be a JSON value). Encapsulate strings with double quotes (e.g. "Foo").'
         ),
     )
     weight = models.PositiveSmallIntegerField(

nautobot/extras/models/datasources.py

@@ -100,8 +100,7 @@ class GitRepository(PrimaryModel):
 
         if self.present_in_database and self.slug != self.__initial_slug:
             raise ValidationError(
-                f"Slug cannot be changed once set. Current slug is {self.__initial_slug}, "
-                f"requested slug is {self.slug}"
+                f"Slug cannot be changed once set. Current slug is {self.__initial_slug}, requested slug is {self.slug}"
             )
 
         if not self.present_in_database:

nautobot/extras/models/jobs.py

@@ -543,6 +543,12 @@ class JobLogEntry(BaseModel):
         ordering = ["created"]
         get_latest_by = "created"
         verbose_name_plural = "job log entries"
+        indexes = [
+            models.Index(
+                name="extras_joblog_jr_created_idx",
+                fields=["job_result", "created"],
+            )
+        ]
 
 
 #
@@ -644,6 +650,7 @@ class JobResult(BaseModel, CustomFieldModel):
         help_text="Registered name of the Celery task for this job. Internal use only.",
     )
     date_created = models.DateTimeField(auto_now_add=True, db_index=True)
+    date_started = models.DateTimeField(null=True, blank=True, db_index=True)
     date_done = models.DateTimeField(null=True, blank=True, db_index=True)
     user = models.ForeignKey(
         to=settings.AUTH_USER_MODEL, on_delete=models.SET_NULL, related_name="+", blank=True, null=True
@@ -708,7 +715,7 @@ class JobResult(BaseModel, CustomFieldModel):
     natural_key_field_names = ["id"]
 
     def __str__(self):
-        return f"{self.name} started at {self.date_created} ({self.status})"
+        return f"{self.name} created at {self.date_created} ({self.status})"
 
     def as_dict(self):
         """This is required by the django-celery-results DB backend."""
@@ -730,7 +737,8 @@ class JobResult(BaseModel, CustomFieldModel):
         if not self.date_done:
             return None
 
-        duration = self.date_done - self.date_created
+        # Older records may not have a date_started value, so we use date_created as a fallback.
+        duration = self.date_done - (self.date_started or self.date_created)
         minutes, seconds = divmod(duration.total_seconds(), 60)
 
         return f"{int(minutes)} minutes, {seconds:.2f} seconds"
@@ -748,7 +756,8 @@ class JobResult(BaseModel, CustomFieldModel):
             # Only add metrics if we have a related job model. If we are moving to a terminal state we should always
             # have a related job model, so this shouldn't be too tight of a restriction.
             if self.job_model:
-                duration = self.date_done - self.date_created
+                # Older records may not have a date_started value, so we use date_created as a fallback.
+                duration = self.date_done - (self.date_started or self.date_created)
                 JOB_RESULT_METRIC.labels(self.job_model.grouping, self.job_model.name, status).observe(
                     duration.total_seconds()
                 )
@@ -878,6 +887,7 @@ class JobResult(BaseModel, CustomFieldModel):
             # synchronous tasks are run before the JobResult is saved, so any fields required by
             # the job must be added before calling `apply()`
             job_result.celery_kwargs = job_celery_kwargs
+            job_result.date_started = timezone.now()
             job_result.save()
 
             # setup synchronous task logging