nautobot 2.4.4__py3-none-any.whl → 2.4.6__py3-none-any.whl

nautobot/extras/jobs.py

@@ -13,13 +13,13 @@ from typing import final
 import warnings
 
 from billiard.einfo import ExceptionInfo
+from celery.exceptions import Ignore, Reject
 from celery.utils.log import get_task_logger
 from db_file_storage.form_widgets import DBClearableFileInput
 from django import forms
 from django.conf import settings
 from django.contrib.auth import get_user_model
 from django.core.cache import cache
-from django.core.exceptions import ObjectDoesNotExist
 from django.core.files.base import ContentFile
 from django.core.files.uploadedfile import UploadedFile
 from django.core.validators import RegexValidator
@@ -121,6 +121,7 @@ class BaseJob:
 
     def __init__(self):
         self.logger = get_task_logger(self.__module__)
+        self._failed = False
 
     def __call__(self, *args, **kwargs):
         # Attempt to resolve serialized data back into original form by creating querysets or model instances
@@ -130,8 +131,9 @@ class BaseJob:
         try:
             deserialized_kwargs = self.deserialize_data(kwargs)
         except Exception as err:
-            self.logger.error("%s", err)
+            self.logger.exception("Error deserializing kwargs")
             raise RunJobTaskFailed("Error initializing job") from err
+
         if isinstance(self, JobHookReceiver):
             change_context = ObjectChangeEventContextChoices.CONTEXT_JOB_HOOK
         else:
@@ -163,7 +165,11 @@ class BaseJob:
     def __str__(self):
         return str(self.name)
 
-    # See https://github.com/PyCQA/pylint-django/issues/240 for why we have a pylint disable on each classproperty below
+    def fail(self, msg, *args, **kwargs):
+        """Mark this job as failed without immediately raising an exception and aborting."""
+        # Instead of failing in "fail" grouping, fail in the parent function's grouping by default
+        self.logger.failure(msg, *args, stacklevel=2, **kwargs)
+        self._failed = True
 
     def before_start(self, task_id, args, kwargs):
         """Handler called before the task starts.
@@ -174,65 +180,10 @@ class BaseJob:
             kwargs (Dict): Original keyword arguments for the task to execute.
 
         Returns:
-            (None): The return value of this handler is ignored.
+            (Any): The return value of this handler is ignored normally, **except** if `self.fail()` is called herein,
+                in which case the return value will be used as the overall JobResult return value
+                since `self.run()` will **not** be called in such a case.
         """
-        try:
-            self.job_result
-        except ObjectDoesNotExist as err:
-            raise RunJobTaskFailed(f"Unable to find associated job result for job {task_id}") from err
-
-        try:
-            self.job_model
-        except ObjectDoesNotExist as err:
-            raise RunJobTaskFailed(f"Unable to find associated job model for job {task_id}") from err
-
-        if not self.job_model.enabled:
-            self.logger.error(
-                "Job %s is not enabled to be run!",
-                self.job_model,
-                extra={"object": self.job_model, "grouping": "initialization"},
-            )
-            raise RunJobTaskFailed(f"Job {self.job_model} is not enabled to be run!")
-
-        ignore_singleton_lock = self.celery_kwargs.get("nautobot_job_ignore_singleton_lock", False)
-        if self.job_model.is_singleton:
-            is_running = cache.get(self.singleton_cache_key)
-            if is_running:
-                if ignore_singleton_lock:
-                    self.logger.info(
-                        "Job %s is a singleton and already running, but singleton will be ignored because"
-                        " `ignore_singleton_lock` is set.",
-                        self.job_model,
-                        extra={"object": self.job_model, "grouping": "initialization"},
-                    )
-                else:
-                    self.logger.error(
-                        "Job %s is a singleton and already running.",
-                        self.job_model,
-                        extra={"object": self.job_model, "grouping": "initialization"},
-                    )
-                    raise RunJobTaskFailed(f"Job '{self.job_model}' is a singleton and already running.")
-            cache_parameters = {
-                "key": self.singleton_cache_key,
-                "value": 1,
-                "timeout": self.job_model.time_limit or settings.CELERY_TASK_TIME_LIMIT,
-            }
-            cache.set(**cache_parameters)
-
-        soft_time_limit = self.job_model.soft_time_limit or settings.CELERY_TASK_SOFT_TIME_LIMIT
-        time_limit = self.job_model.time_limit or settings.CELERY_TASK_TIME_LIMIT
-        if time_limit <= soft_time_limit:
-            self.logger.warning(
-                "The hard time limit of %s seconds is less than "
-                "or equal to the soft time limit of %s seconds. "
-                "This job will fail silently after %s seconds.",
-                time_limit,
-                soft_time_limit,
-                time_limit,
-                extra={"grouping": "initialization"},
-            )
-
-        self.logger.info("Running job", extra={"grouping": "initialization", "object": self.job_model})
 
     def run(self, *args, **kwargs):
         """
@@ -277,11 +228,12 @@ class BaseJob:
         This is run by the worker when the task fails.
 
         Arguments:
-            exc (Exception): The exception raised by the task.
+            exc (Any): Exception raised by the task (if any) **or** return value from the task, if it failed cleanly,
+                such as if the Job called `self.fail()` rather than raising an exception.
             task_id (str): Unique id of the failed task.
             args (Tuple): Original arguments for the task that failed.
             kwargs (Dict): Original keyword arguments for the task that failed.
-            einfo (~billiard.einfo.ExceptionInfo): Exception information.
+            einfo (~billiard.einfo.ExceptionInfo): Exception information, or None.
 
         Returns:
             (None): The return value of this handler is ignored.
@@ -303,16 +255,7 @@ class BaseJob:
             (None): The return value of this handler is ignored.
         """
 
-        # Cleanup FileProxy objects
-        file_fields = list(self._get_file_vars())
-        file_ids = [kwargs[f] for f in file_fields if f in kwargs]
-        if file_ids:
-            self._delete_file_proxies(*file_ids)
-
-        if status == JobResultStatusChoices.STATUS_SUCCESS:
-            self.logger.success("Job completed", extra={"grouping": "post_run"})
-
-        cache.delete(self.singleton_cache_key)
+    # See https://github.com/PyCQA/pylint-django/issues/240 for why we have a pylint disable on each classproperty below
 
     @final
     @classproperty
@@ -1205,6 +1148,114 @@ def get_job(class_path, reload=False):
     return jobs.get(class_path, None)
 
 
+def _prepare_job(job_class_path, request, kwargs) -> tuple[Job, dict]:
+    """Helper method to run_job task, handling initial data setup and initialization before running a Job."""
+    logger.debug("Preparing to run job %s for task %s", job_class_path, request.id)
+
+    # Get the job code
+    job_class = get_job(job_class_path, reload=True)
+    if job_class is None:
+        raise KeyError(f"Job class not found for class path {job_class_path}")
+    job = job_class()
+    job.request = request
+
+    # Get the JobResult record to record results to
+    try:
+        job_result = JobResult.objects.get(id=request.id)
+    except JobResult.DoesNotExist:
+        job.logger.exception("Unable to find JobResult %s", request.id, extra={"grouping": "initialization"})
+        raise
+
+    # Get the JobModel record associated with this job
+    try:
+        job.job_model
+    except JobModel.DoesNotExist:
+        job.logger.exception(
+            "Unable to find Job database record %s", job_class_path, extra={"grouping": "initialization"}
+        )
+        raise
+
+    # Make sure it's valid to run this job - 1) is it enabled?
+    if not job.job_model.enabled:
+        job.logger.error(
+            "Job %s is not enabled to be run!",
+            job.job_model,
+            extra={"object": job.job_model, "grouping": "initialization"},
+        )
+        raise RunJobTaskFailed(f"Job {job.job_model} is not enabled to be run!")
+    # 2) if it's a singleton, is there any existing lock to be aware of?
+    if job.job_model.is_singleton:
+        is_running = cache.get(job.singleton_cache_key)
+        if is_running:
+            ignore_singleton_lock = job.celery_kwargs.get("nautobot_job_ignore_singleton_lock", False)
+            if ignore_singleton_lock:
+                job.logger.warning(
+                    "Job %s is a singleton and already running, but singleton will be ignored because"
+                    " `ignore_singleton_lock` is set.",
+                    job.job_model,
+                    extra={"object": job.job_model, "grouping": "initialization"},
+                )
+            else:
+                # TODO 3.0: maybe change to logger.failure() and return cleanly, as this is an "acceptable" failure?
+                job.logger.error(
+                    "Job %s is a singleton and already running.",
+                    job.job_model,
+                    extra={"object": job.job_model, "grouping": "initialization"},
+                )
+                raise RunJobTaskFailed(f"Job '{job.job_model}' is a singleton and already running.")
+        cache_parameters = {
+            "key": job.singleton_cache_key,
+            "value": 1,
+            "timeout": job.job_model.time_limit or settings.CELERY_TASK_TIME_LIMIT,
+        }
+        cache.set(**cache_parameters)
+
+    # Check for validity of the soft/hard time limits for the job.
+    # TODO: this is a bit out of place?
+    soft_time_limit = job.job_model.soft_time_limit or settings.CELERY_TASK_SOFT_TIME_LIMIT
+    time_limit = job.job_model.time_limit or settings.CELERY_TASK_TIME_LIMIT
+    if time_limit <= soft_time_limit:
+        job.logger.warning(
+            "The hard time limit of %s seconds is less than "
+            "or equal to the soft time limit of %s seconds. "
+            "This job will fail silently after %s seconds.",
+            time_limit,
+            soft_time_limit,
+            time_limit,
+            extra={"grouping": "initialization", "object": job.job_model},
+        )
+
+    # Send notice that the job is running
+    event_payload = {
+        "job_result_id": request.id,
+        "job_name": job.name,  # TODO: should this be job.job_model.name instead? Possible breaking change
+        "user_name": job_result.user.username,
+    }
+    if not job.job_model.has_sensitive_variables:
+        event_payload["job_kwargs"] = kwargs
+    publish_event(topic="nautobot.jobs.job.started", payload=event_payload)
+    job.logger.info("Running job", extra={"grouping": "initialization", "object": job.job_model})
+
+    # Return the job, ready to run
+    return job, event_payload
+
+
+def _cleanup_job(job, event_payload, status, kwargs):
+    """Helper method to run_job task, handling cleanup after running a Job."""
+    # Cleanup FileProxy objects
+    file_fields = list(job._get_file_vars())
+    file_ids = [kwargs[f] for f in file_fields if f in kwargs]
+    if file_ids:
+        job._delete_file_proxies(*file_ids)
+
+    if status == JobResultStatusChoices.STATUS_SUCCESS:
+        job.logger.success("Job completed", extra={"grouping": "post_run"})
+
+    publish_event(topic="nautobot.jobs.job.completed", payload=event_payload)
+
+    cache.delete(job.singleton_cache_key)
+
+
 @nautobot_task(bind=True)
 def run_job(self, job_class_path, *args, **kwargs):
     """
@@ -1212,49 +1263,76 @@ def run_job(self, job_class_path, *args, **kwargs):
 
     This calls the following Job APIs in the following order:
 
-    - `__init__()`
-    - `before_start()`
-    - `__call__()` (which calls `run()`)
-    - If no exceptions have been raised, `on_success()`, else `on_failure()`
-    - `after_return()`
+    - `Job.__init__()`
+    - `Job.before_start(self.request.id, args, kwargs)`
+    - `Job.__call__(*args, **kwargs)` (which calls `run(*args, **kwargs)`)
+    - If no exceptions have been raised (and `Job.fail()` was not called):
+        - `Job.on_success(result, self.request.id, args, kwargs)`
+    - Else:
+        - `Job.on_failure(result_or_exception, self.request.id, args, kwargs, einfo)`
+    - `Job.after_return(status, result_or_exception, self.request.id, args, kwargs, einfo)`
 
-    Finally, it either returns the data returned from `run()` or re-raises any exception encountered.
+    Finally, it either returns any data returned from `Job.run()` or re-raises any exception encountered.
     """
-    logger.debug("Running job %s", job_class_path)
 
-    job_class = get_job(job_class_path, reload=True)
-    if job_class is None:
-        raise KeyError(f"Job class not found for class path {job_class_path}")
-    job = job_class()
-    job.request = self.request
-    job_result = JobResult.objects.get(id=self.request.id)
-    payload = {
-        "job_result_id": self.request.id,
-        "job_name": job.name,
-        "user_name": job_result.user.username,
-    }
-    if not job.job_model.has_sensitive_variables:
-        payload["job_kwargs"] = kwargs
+    job, event_payload = _prepare_job(job_class_path, self.request, kwargs)
+
+    result = None
+    status = None
     try:
-        publish_event(topic="nautobot.jobs.job.started", payload=payload)
-        job.before_start(self.request.id, args, kwargs)
-        result = job(*args, **kwargs)
-        job.on_success(result, self.request.id, args, kwargs)
-        job.after_return(JobResultStatusChoices.STATUS_SUCCESS, result, self.request.id, args, kwargs, None)
-        payload["job_output"] = result
-        publish_event(topic="nautobot.jobs.job.completed", payload=payload)
-        return result
+        before_start_result = job.before_start(self.request.id, args, kwargs)
+        if not job._failed:
+            # Call job(), which automatically calls job.run():
+            result = job(*args, **kwargs)
+        else:
+            # don't run the job if before_start() reported a failure, and report the before_start() return value
+            result = before_start_result
+
+        event_payload["job_output"] = result
+        status = JobResultStatusChoices.STATUS_SUCCESS if not job._failed else JobResultStatusChoices.STATUS_FAILURE
+
+        if status == JobResultStatusChoices.STATUS_SUCCESS:
+            job.on_success(result, self.request.id, args, kwargs)
+        else:
+            job.on_failure(result, self.request.id, args, kwargs, None)
+
+        job.after_return(status, result, self.request.id, args, kwargs, None)
+
+        if status == JobResultStatusChoices.STATUS_SUCCESS:
+            return result
+
+        # Report a failure, but with a result rather than an exception and einfo:
+        self.update_state(
+            state=status,
+            meta=result,
+        )
+        # If we return a result, Celery automatically applies STATUS_SUCCESS.
+        # If we raise an exception *other than* `Ignore` or `Reject`, Celery automatically applies STATUS_FAILURE.
+        # We don't want to overwrite the manual state update that we did above, so:
+        raise Ignore()
+
+    except Reject:
+        status = status or JobResultStatusChoices.STATUS_REJECTED
+        raise
+
+    except Ignore:
+        status = status or JobResultStatusChoices.STATUS_IGNORED
+        raise
+
     except Exception as exc:
+        status = JobResultStatusChoices.STATUS_FAILURE
         einfo = ExceptionInfo(sys.exc_info())
         job.on_failure(exc, self.request.id, args, kwargs, einfo)
         job.after_return(JobResultStatusChoices.STATUS_FAILURE, exc, self.request.id, args, kwargs, einfo)
-        payload["einfo"] = {
+        event_payload["einfo"] = {
             "exc_type": type(exc).__name__,
             "exc_message": sanitize(str(exc)),
         }
-        publish_event(topic="nautobot.jobs.job.completed", payload=payload)
         raise
 
+    finally:
+        _cleanup_job(job, event_payload, status, kwargs)
+
 
 def enqueue_job_hooks(object_change, may_reload_jobs=True, jobhook_queryset=None):
     """

nautobot/extras/management/utils.py

@@ -47,12 +47,21 @@ def report_job_status(command, job_result):
         logs = JobLogEntry.objects.filter(job_result__pk=job_result.pk, grouping=group)
         debug_count = logs.filter(log_level=LogLevelChoices.LOG_DEBUG).count()
         info_count = logs.filter(log_level=LogLevelChoices.LOG_INFO).count()
+        success_count = logs.filter(log_level=LogLevelChoices.LOG_SUCCESS).count()
         warning_count = logs.filter(log_level=LogLevelChoices.LOG_WARNING).count()
+        failure_count = logs.filter(log_level=LogLevelChoices.LOG_FAILURE).count()
         error_count = logs.filter(log_level=LogLevelChoices.LOG_ERROR).count()
         critical_count = logs.filter(log_level=LogLevelChoices.LOG_CRITICAL).count()
 
         command.stdout.write(
-            f"\t{group}: {debug_count} debug, {info_count} info, {warning_count} warning, {error_count} error, {critical_count} critical"
+            f"\t{group}: "
+            f"{debug_count} debug, "
+            f"{info_count} info, "
+            f"{success_count} success, "
+            f"{warning_count} warning, "
+            f"{failure_count} failure, "
+            f"{error_count} error, "
+            f"{critical_count} critical"
         )
 
         for log_entry in logs:
@@ -63,7 +72,7 @@ def report_job_status(command, job_result):
                 status = status
             elif status == "warning":
                 status = command.style.WARNING(status)
-            elif status == "failure":
+            elif status in ["failure", "error", "critical"]:
                 status = command.style.NOTICE(status)
 
             if log_entry.log_object:
@@ -73,6 +82,8 @@ def report_job_status(command, job_result):
 
     if job_result.result:
         command.stdout.write(str(job_result.result))
+    if job_result.traceback:
+        command.stdout.write(command.style.ERROR(job_result.traceback))
 
     if job_result.status == JobResultStatusChoices.STATUS_FAILURE:
         status = command.style.ERROR("FAILURE")

nautobot/extras/models/datasources.py

@@ -220,6 +220,8 @@ class GitRepository(PrimaryModel):
         Returns:
             Returns the absolute path of the cloned repo if clone was successful, otherwise returns None.
         """
+        from nautobot.extras.datasources import get_repo_access_url
+
         if branch and head:
             raise ValueError("Cannot specify both branch and head")
 
@@ -233,7 +235,8 @@ class GitRepository(PrimaryModel):
             branch = self.branch
 
         try:
-            repo_helper = GitRepo(path_name, self.remote_url, depth=depth, branch=branch)
+            remote_url = get_repo_access_url(self)
+            repo_helper = GitRepo(path_name, remote_url, depth=depth, branch=branch)
             if head:
                 repo_helper.checkout(branch, head)
         except Exception as e:

nautobot/extras/models/jobs.py

@@ -897,25 +897,28 @@ class JobResult(BaseModel, CustomFieldModel):
                     # Cancel the scheduled SIGALRM if it hasn't fired already
                     signal.alarm(0)
 
-            # copy fields from eager result to job result
             job_result.refresh_from_db()
-            # Emulate prepare_exception() behavior
-            if isinstance(eager_result.result, Exception):
-                job_result.result = {
-                    "exc_type": type(eager_result.result).__name__,
-                    "exc_message": sanitize(str(eager_result.result)),
-                }
-            else:
-                if eager_result.result is not None:
+            # copy from eager result to job result if and only if the job result isn't already in a proper state.
+            if JobResultStatusChoices.precedence(job_result.status) > JobResultStatusChoices.precedence(
+                eager_result.status
+            ):
+                if eager_result.status in JobResultStatusChoices.EXCEPTION_STATES and isinstance(
+                    eager_result.result, Exception
+                ):
+                    job_result.result = {
+                        "exc_type": type(eager_result.result).__name__,
+                        "exc_message": sanitize(str(eager_result.result)),
+                    }
+                elif eager_result.result is not None:
                     job_result.result = sanitize(eager_result.result)
-                else:
-                    job_result.result = None
-            job_result.status = eager_result.status
-            if eager_result.traceback is not None:
-                job_result.traceback = sanitize(eager_result.traceback)
-            else:
-                job_result.traceback = None
-            job_result.date_done = timezone.now()
+                job_result.status = eager_result.status
+                if (
+                    eager_result.status in JobResultStatusChoices.EXCEPTION_STATES
+                    and eager_result.traceback is not None
+                ):
+                    job_result.traceback = sanitize(eager_result.traceback)
+            if not job_result.date_done:
+                job_result.date_done = timezone.now()
             job_result.save()
         else:
             # Jobs queued inside of a transaction need to run after the transaction completes and the JobResult is saved to the database

nautobot/extras/plugins/marketplace_manifest.yml

@@ -94,6 +94,24 @@
   "availability": "Open Source"
   "icon": >-
     data:image/png;base64,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
+- "name": "DNS Models"
+  "use_cases":
+  - "DNS"
+  "requires": []
+  "docs": "https://docs.nautobot.com/projects/dns-models/en/latest/"
+  "headline": "Model DNS Zones and their associated records in a vendor-neutral manner."
+  "description": >-
+    DNS Models allows users to document and understand the network by modeling their DNS data. DNS Records can then
+    be directly related to data about the network.
+  "package_name": "nautobot_dns_models"
+  "author": "Network to Code (NTC)"
+  "display":
+    "cloud": true
+    "oss": true
+    "enterprise": true
+  "availability": "Open Source"
+  "icon": >-
+    data:image/png;base64,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
 - "name": "Data Validation Engine"
   "use_cases":
   - "Data Management"

nautobot/extras/tables.py

@@ -112,6 +112,27 @@ JOB_BUTTONS = """
 <a href="{% url 'extras:jobresult_list' %}?job_model={{ record.name | urlencode }}" class="btn btn-default btn-xs" title="Job Results"><i class="mdi mdi-format-list-bulleted" aria-hidden="true"></i></a>
 """
 
+JOB_RESULT_BUTTONS = """
+{% load helpers %}
+{% if perms.extras.run_job %}
+    {% if record.job_model and record.task_kwargs %}
+        <a href="{% url 'extras:job_run' pk=record.job_model.pk %}?kwargs_from_job_result={{ record.pk }}"
+           class="btn btn-xs btn-success" title="Re-run job with same arguments.">
+            <i class="mdi mdi-repeat"></i>
+        </a>
+    {% elif record.job_model is not None %}
+        <a href="{% url 'extras:job_run' pk=record.job_model.pk %}" class="btn btn-primary btn-xs"
+           title="Run job">
+            <i class="mdi mdi-play"></i>
+        </a>
+    {% else %}
+        <a href="#" class="btn btn-xs btn-default disabled" title="Job is not available, cannot be re-run">
+            <i class="mdi mdi-repeat-off"></i>
+        </a>
+    {% endif %}
+{% endif %}
+"""
+
 SCHEDULED_JOB_BUTTONS = """
 <a href="{% url 'extras:jobresult_list' %}?scheduled_job={{ record.name | urlencode }}" class="btn btn-default btn-xs" title="Job Results"><i class="mdi mdi-format-list-bulleted" aria-hidden="true"></i></a>
 """
@@ -675,7 +696,7 @@ def log_object_link(value, record):
 
 
 def log_entry_color_css(record):
-    if record.log_level.lower() in ("error", "critical"):
+    if record.log_level.lower() in ("failure", "error", "critical"):
         return "danger"
     return record.log_level.lower()
 
@@ -811,7 +832,7 @@ class JobLogEntryTable(BaseTable):
     def render_log_level(self, value):
         log_level = value.lower()
         # The css is label-danger for failure items.
-        if log_level in ["error", "critical"]:
+        if log_level in ["failure", "error", "critical"]:
             log_level = "danger"
         elif log_level == "debug":
             log_level = "default"
@@ -877,32 +898,7 @@ class JobResultTable(BaseTable):
         linkify=True,
         verbose_name="Scheduled Job",
     )
-    actions = tables.TemplateColumn(
-        template_code="""
-            {% load helpers %}
-            {% if perms.extras.run_job %}
-                {% if record.job_model and record.task_kwargs %}
-                    <a href="{% url 'extras:job_run' pk=record.job_model.pk %}?kwargs_from_job_result={{ record.pk }}"
-                       class="btn btn-xs btn-success" title="Re-run job with same arguments.">
-                        <i class="mdi mdi-repeat"></i>
-                    </a>
-                {% elif record.job_model is not None %}
-                    <a href="{% url 'extras:job_run' pk=record.job_model.pk %}" class="btn btn-primary btn-xs"
-                       title="Run job">
-                        <i class="mdi mdi-play"></i>
-                    </a>
-                {% else %}
-                    <a href="#" class="btn btn-xs btn-default disabled" title="Job is not available, cannot be re-run">
-                        <i class="mdi mdi-repeat-off"></i>
-                    </a>
-                {% endif %}
-            {% endif %}
-            <a href="{% url 'extras:jobresult_delete' pk=record.pk %}" class="btn btn-xs btn-danger"
-               title="Delete this job result.">
-                <i class="mdi mdi-trash-can-outline"></i>
-            </a>
-        """
-    )
+    actions = ButtonsColumn(JobResult, buttons=("delete",), prepend_template=JOB_RESULT_BUTTONS)
 
     def render_summary(self, record):
         """
@@ -1067,14 +1063,13 @@ class ObjectMetadataTable(BaseTable):
 
 class NoteTable(BaseTable):
     actions = ButtonsColumn(Note)
-    created = tables.LinkColumn()
-    note = tables.Column(
-        attrs={"td": {"class": "rendered-markdown"}},
-    )
+    created = tables.DateTimeColumn(linkify=True)
+    last_updated = tables.DateTimeColumn()
+    note = tables.Column()
 
     class Meta(BaseTable.Meta):
         model = Note
-        fields = ("created", "note", "user_name")
+        fields = ("created", "last_updated", "note", "user_name")
 
     def render_note(self, value):
         return render_markdown(value)
@@ -1094,7 +1089,7 @@ class ScheduledJobTable(BaseTable):
     last_run_at = tables.DateTimeColumn(verbose_name="Most Recent Run", format=settings.SHORT_DATETIME_FORMAT)
     crontab = tables.Column()
     total_run_count = tables.Column(verbose_name="Total Run Count")
-    actions = ButtonsColumn(ScheduledJob, buttons=("delete"), prepend_template=SCHEDULED_JOB_BUTTONS)
+    actions = ButtonsColumn(ScheduledJob, buttons=("delete",), prepend_template=SCHEDULED_JOB_BUTTONS)
 
     class Meta(BaseTable.Meta):
         model = ScheduledJob

nautobot/extras/templates/extras/inc/panel_changelog.html

@@ -21,7 +21,7 @@
                 <br />
                 <small>
                     <span class="text-muted">{{ change.user_name }} -</span>
-                    <a href="{{ change.get_absolute_url }}" class="text-muted">{{ change.time|date:'SHORT_DATETIME_FORMAT' }}</a>
+                    <a href="{{ change.get_absolute_url }}" class="text-muted">{{ change.time|date:settings.SHORT_DATETIME_FORMAT }}</a>
                 </small>
             </div>
         {% endwith %}

nautobot/extras/templates/extras/inc/panel_jobhistory.html

@@ -7,7 +7,7 @@
             <span class="pull-right" title="{{ result.date_created }}">{% include 'extras/inc/job_label.html' %}</span>
             <br>
             <small>
-                <span class="text-muted">{{ result.user }} - {{ result.date_done|date:'SHORT_DATETIME_FORMAT' }}</span>
+                <span class="text-muted">{{ result.user }} - {{ result.date_done|date:settings.SHORT_DATETIME_FORMAT }}</span>
             </small>
         </div>
         {% if forloop.last %}