nautobot 2.0.0a3__py3-none-any.whl → 2.0.0b1__py3-none-any.whl

nautobot/extras/models/jobs.py

@@ -1,33 +1,38 @@
 # Data models relating to Jobs
 
+import contextlib
 from datetime import timedelta
 import logging
-import os
-import uuid
 
 from celery import schedules
+from celery.utils.log import get_logger, LoggingProxy
 from django.conf import settings
 from django.contrib.contenttypes.models import ContentType
-from django.core.exceptions import ObjectDoesNotExist, ValidationError
+from django.core.exceptions import ValidationError
 from django.core.serializers.json import DjangoJSONEncoder
 from django.core.validators import MinValueValidator
 from django.db import models, transaction
 from django.db.models import signals
-from django.urls import reverse
 from django.utils import timezone
+from django.utils.functional import cached_property
 from django_celery_beat.clockedschedule import clocked
 from prometheus_client import Histogram
 
-from nautobot.core.celery import NautobotKombuJSONEncoder
+from nautobot.core.celery import (
+    add_nautobot_log_handler,
+    app,
+    NautobotKombuJSONEncoder,
+    setup_nautobot_job_logging,
+)
+from nautobot.core.celery.control import refresh_git_repository
 from nautobot.core.models import BaseManager, BaseModel
-from nautobot.core.models.fields import AutoSlugField, JSONArrayField
+from nautobot.core.models.fields import JSONArrayField
 from nautobot.core.models.generics import OrganizationalModel, PrimaryModel
 from nautobot.core.utils.logging import sanitize
 from nautobot.extras.choices import (
     ButtonClassChoices,
     JobExecutionType,
     JobResultStatusChoices,
-    JobSourceChoices,
     LogLevelChoices,
 )
 from nautobot.extras.constants import (
@@ -36,20 +41,15 @@ from nautobot.extras.constants import (
     JOB_LOG_MAX_LOG_OBJECT_LENGTH,
     JOB_MAX_GROUPING_LENGTH,
     JOB_MAX_NAME_LENGTH,
-    JOB_MAX_SOURCE_LENGTH,
     JOB_OVERRIDABLE_FIELDS,
 )
-from nautobot.extras.models import ChangeLoggedModel
+from nautobot.extras.models import ChangeLoggedModel, GitRepository
 from nautobot.extras.models.mixins import NotesMixin
-from nautobot.extras.plugins.utils import import_object
 from nautobot.extras.managers import JobResultManager, ScheduledJobsManager
 from nautobot.extras.querysets import JobQuerySet, ScheduledJobExtendedQuerySet
 from nautobot.extras.utils import (
     ChangeLoggedModelsQuery,
-    FeatureQuery,
     extras_features,
-    get_job_content_type,
-    jobs_in_directory,
 )
 
 from .customfields import CustomFieldModel
@@ -86,23 +86,6 @@ class Job(PrimaryModel):
     """
 
     # Information used to locate the Job source code
-    source = models.CharField(
-        max_length=JOB_MAX_SOURCE_LENGTH,
-        choices=JobSourceChoices,
-        editable=False,
-        db_index=True,
-        help_text="Source of the Python code for this job - local, Git repository, or plugins",
-    )
-    git_repository = models.ForeignKey(
-        to="extras.GitRepository",
-        blank=True,
-        null=True,
-        default=None,
-        on_delete=models.SET_NULL,
-        db_index=True,
-        related_name="jobs",
-        help_text="Git repository that provides this job",
-    )
     module_name = models.CharField(
         max_length=JOB_MAX_NAME_LENGTH,
         editable=False,
@@ -116,11 +99,6 @@ class Job(PrimaryModel):
         help_text="Name of the Python class providing this job",
     )
 
-    slug = AutoSlugField(
-        max_length=JOB_MAX_NAME_LENGTH,
-        populate_from="name",
-    )
-
     # Human-readable information, potentially inherited from the source code
     # See also the docstring of nautobot.extras.jobs.BaseJob.Meta.
     grouping = models.CharField(
@@ -161,17 +139,17 @@ class Job(PrimaryModel):
     approval_required = models.BooleanField(
         default=False, help_text="Whether the job requires approval from another user before running"
     )
-    commit_default = models.BooleanField(
-        default=True, help_text="Whether the job defaults to committing changes when run, or defaults to a dry-run"
-    )
     hidden = models.BooleanField(
         default=False,
         db_index=True,
         help_text="Whether the job defaults to not being shown in the UI",
     )
     # Job.Meta.field_order is not overridable in this model
+    dryrun_default = models.BooleanField(
+        default=False, help_text="Whether the job defaults to running with dryrun argument set to true"
+    )
     read_only = models.BooleanField(
-        default=False, help_text="Whether the job is prevented from making lasting changes to the database"
+        default=False, editable=False, help_text="Set to true if the job does not make any changes to the environment"
     )
     soft_time_limit = models.FloatField(
         default=0,
@@ -191,6 +169,11 @@ class Job(PrimaryModel):
         blank=True,
         help_text="Comma separated list of task queues that this job can run on. A blank list will use the default queue",
     )
+    supports_dryrun = models.BooleanField(
+        default=False,
+        editable=False,
+        help_text="If supported, allows the job to bypass approval when running with dryrun argument set to true",
+    )
 
     # Flags to indicate whether the above properties are inherited from the source code or overridden by the database
     grouping_override = models.BooleanField(
@@ -205,12 +188,11 @@ class Job(PrimaryModel):
         default=False,
         help_text="If set, the configured description will remain even if the underlying Job source code changes",
     )
-
     approval_required_override = models.BooleanField(
         default=False,
         help_text="If set, the configured value will remain even if the underlying Job source code changes",
     )
-    commit_default_override = models.BooleanField(
+    dryrun_default_override = models.BooleanField(
         default=False,
         help_text="If set, the configured value will remain even if the underlying Job source code changes",
     )
@@ -218,10 +200,6 @@ class Job(PrimaryModel):
         default=False,
         help_text="If set, the configured value will remain even if the underlying Job source code changes",
     )
-    read_only_override = models.BooleanField(
-        default=False,
-        help_text="If set, the configured value will remain even if the underlying Job source code changes",
-    )
     soft_time_limit_override = models.BooleanField(
         default=False,
         help_text="If set, the configured value will remain even if the underlying Job source code changes",
@@ -244,90 +222,29 @@ class Job(PrimaryModel):
     class Meta:
         managed = True
         ordering = ["grouping", "name"]
-        unique_together = ["source", "git_repository", "module_name", "job_class_name"]
+        unique_together = ["module_name", "job_class_name"]
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        self._job_class = None
         self._latest_result = None
 
     def __str__(self):
         return self.name
 
-    def validate_unique(self, exclude=None):
-        """
-        Check for duplicate (source, module_name, job_class_name) in the case where git_repository is None.
-
-        This is needed because NULL != NULL and so the unique_together constraint will not flag this case.
-        """
-        if self.git_repository is None:
-            if Job.objects.exclude(pk=self.pk).filter(
-                source=self.source, module_name=self.module_name, job_class_name=self.job_class_name
-            ):
-                raise ValidationError(
-                    {"job_class_name": "A Job already exists with this source, module_name, and job_class_name"}
-                )
-
-        super().validate_unique(exclude=exclude)
-
-    @property
+    @cached_property
     def job_class(self):
         """Get the Job class (source code) associated with this Job model."""
         if not self.installed:
             return None
-        if self._job_class is None:
-            if self.source == JobSourceChoices.SOURCE_LOCAL:
-                path = settings.JOBS_ROOT
-                for job_info in jobs_in_directory(settings.JOBS_ROOT, module_name=self.module_name):
-                    if job_info.job_class_name == self.job_class_name:
-                        self._job_class = job_info.job_class
-                        break
-                else:
-                    logger.warning("Module %s job class %s not found!", self.module_name, self.job_class_name)
-            elif self.source == JobSourceChoices.SOURCE_GIT:
-                from nautobot.extras.datasources.git import ensure_git_repository
-
-                if self.git_repository is None:
-                    logger.warning("Job %s %s has no associated Git repository", self.module_name, self.job_class_name)
-                    return None
-                try:
-                    # In the case where we have multiple Nautobot instances, or multiple worker instances,
-                    # they are not required to share a common filesystem; therefore, we may need to refresh our local
-                    # clone of the Git repository to ensure that it is in sync with the latest repository clone
-                    # from any instance.
-                    ensure_git_repository(
-                        self.git_repository,
-                        head=self.git_repository.current_head,
-                        logger=logger,
-                    )
-                    path = os.path.join(self.git_repository.filesystem_path, "jobs")
-                    for job_info in jobs_in_directory(path, module_name=self.module_name):
-                        if job_info.job_class_name == self.job_class_name:
-                            self._job_class = job_info.job_class
-                            break
-                    else:
-                        logger.warning(
-                            "Module %s job class %s not found in repository %s",
-                            self.module_name,
-                            self.job_class_name,
-                            self.git_repository,
-                        )
-                except ObjectDoesNotExist:
-                    return None
-                except Exception as exc:
-                    logger.error(f"Error during local clone/refresh of Git repository {self.git_repository}: {exc}")
-                    return None
-            elif self.source == JobSourceChoices.SOURCE_PLUGIN:
-                # pkgutil.resolve_name is only available in Python 3.9 and later
-                self._job_class = import_object(f"{self.module_name}.{self.job_class_name}")
-
-        return self._job_class
+        try:
+            return self.job_task.__class__
+        except Exception as exc:
+            logger.error(str(exc))
+            return None
 
     @property
     def class_path(self):
-        if self.git_repository is not None:
-            return f"{self.source}.{self.git_repository.slug}/{self.module_name}/{self.job_class_name}"
-        return f"{self.source}/{self.module_name}/{self.job_class_name}"
+        return f"{self.module_name}.{self.job_class_name}"
 
     @property
     def latest_result(self):
@@ -341,12 +258,25 @@ class Job(PrimaryModel):
 
     @property
     def runnable(self):
-        return (
-            self.enabled
-            and self.installed
-            and self.job_class is not None
-            and not (self.has_sensitive_variables and self.approval_required)
-        )
+        return self.enabled and self.installed and not (self.has_sensitive_variables and self.approval_required)
+
+    @cached_property
+    def git_repository(self):
+        """GitRepository record, if any, that owns this Job."""
+        try:
+            return GitRepository.objects.get(slug=self.module_name.split(".")[0])
+        except GitRepository.DoesNotExist:
+            return None
+
+    @property
+    def job_task(self):
+        """Get the registered Celery task, refreshing it if necessary."""
+        if self.git_repository is not None:
+            # If this Job comes from a Git repository, make sure we have the correct version of said code.
+            refresh_git_repository(
+                state=None, repository_pk=self.git_repository.pk, head=self.git_repository.current_head
+            )
+        return app.tasks[f"{self.module_name}.{self.job_class_name}"]
 
     def clean(self):
         """For any non-overridden fields, make sure they get reset to the actual underlying class value if known."""
@@ -355,12 +285,7 @@ class Job(PrimaryModel):
                 if not getattr(self, f"{field_name}_override", False):
                     setattr(self, field_name, getattr(self.job_class, field_name))
 
-        if self.git_repository is not None and self.source != JobSourceChoices.SOURCE_GIT:
-            raise ValidationError('A Git repository may only be specified when the source is "git"')
-
         # Protect against invalid input when auto-creating Job records
-        if len(self.source) > JOB_MAX_SOURCE_LENGTH:
-            raise ValidationError(f"Source may not exceed {JOB_MAX_SOURCE_LENGTH} characters in length")
         if len(self.module_name) > JOB_MAX_NAME_LENGTH:
             raise ValidationError(f"Module name may not exceed {JOB_MAX_NAME_LENGTH} characters in length")
         if len(self.job_class_name) > JOB_MAX_NAME_LENGTH:
@@ -369,17 +294,12 @@ class Job(PrimaryModel):
             raise ValidationError(f"Grouping may not exceed {JOB_MAX_GROUPING_LENGTH} characters in length")
         if len(self.name) > JOB_MAX_NAME_LENGTH:
             raise ValidationError(f"Name may not exceed {JOB_MAX_NAME_LENGTH} characters in length")
-        if len(self.slug) > JOB_MAX_NAME_LENGTH:
-            raise ValidationError(f"Slug may not exceed {JOB_MAX_NAME_LENGTH} characters in length")
 
         if self.has_sensitive_variables is True and self.approval_required is True:
             raise ValidationError(
                 {"approval_required": "A job that may have sensitive variables cannot be marked as requiring approval"}
             )
 
-    def get_absolute_url(self):
-        return reverse("extras:job_detail", kwargs={"slug": self.slug})
-
 
 @extras_features("graphql")
 class JobHook(OrganizationalModel):
@@ -423,9 +343,6 @@ class JobHook(OrganizationalModel):
         if not self.type_create and not self.type_delete and not self.type_update:
             raise ValidationError("You must select at least one type: create, update, and/or delete.")
 
-    def get_absolute_url(self):
-        return reverse("extras:jobhook", kwargs={"pk": self.pk})
-
     @classmethod
     def check_for_conflicts(
         cls, instance=None, content_types=None, job=None, type_create=None, type_update=None, type_delete=None
@@ -484,7 +401,7 @@ class JobLogEntry(BaseModel):
 
     job_result = models.ForeignKey(to="extras.JobResult", on_delete=models.CASCADE, related_name="job_log_entries")
     log_level = models.CharField(
-        max_length=32, choices=LogLevelChoices, default=LogLevelChoices.LOG_DEFAULT, db_index=True
+        max_length=32, choices=LogLevelChoices, default=LogLevelChoices.LOG_INFO, db_index=True
     )
     grouping = models.CharField(max_length=JOB_LOG_MAX_GROUPING_LENGTH, default="main")
     message = models.TextField(blank=True)
@@ -496,8 +413,6 @@ class JobLogEntry(BaseModel):
     log_object = models.CharField(max_length=JOB_LOG_MAX_LOG_OBJECT_LENGTH, blank=True, default="")
     absolute_url = models.CharField(max_length=JOB_LOG_MAX_ABSOLUTE_URL_LENGTH, blank=True, default="")
 
-    csv_headers = ["created", "grouping", "log_level", "log_object", "message"]
-
     def __str__(self):
         return self.message
 
@@ -506,10 +421,6 @@ class JobLogEntry(BaseModel):
         get_latest_by = "created"
         verbose_name_plural = "job log entries"
 
-    def to_csv(self):
-        """Indicates model fields to return as csv."""
-        return (str(self.created), self.grouping, self.log_level, self.log_object, self.message)
-
 
 #
 # Job results
@@ -538,18 +449,8 @@ class JobResult(BaseModel, CustomFieldModel):
         db_index=True,
         help_text="Registered name of the Celery task for this job. Internal use only.",
     )
-    obj_type = models.ForeignKey(
-        to=ContentType,
-        related_name="job_results",
-        verbose_name="Object types",
-        limit_choices_to=FeatureQuery("job_results"),
-        help_text="The object type to which this job result applies",
-        on_delete=models.CASCADE,
-        null=True,
-        blank=True,
-    )
-    date_created = models.DateTimeField(auto_now_add=True)
-    date_done = models.DateTimeField(null=True, blank=True)
+    date_created = models.DateTimeField(auto_now_add=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
     )
@@ -563,23 +464,16 @@ class JobResult(BaseModel, CustomFieldModel):
     data = models.JSONField(encoder=DjangoJSONEncoder, null=True, blank=True)
     """
     Although "data" is technically an unstructured field, we have a standard structure that we try to adhere to.
-
     This structure is created loosely as a superset of the formats used by Scripts and Reports in NetBox 2.10.
-
     Log Messages now go to their own object, the JobLogEntry.
-
     data = {
         "output": <optional string, such as captured stdout/stderr>,
     }
     """
-    periodic_task_name = models.CharField(
-        null=True,
-        max_length=255,
-        help_text="Registered name of the Celery periodic task for this job. Internal use only.",
-    )
     worker = models.CharField(max_length=100, default=None, null=True)
-    task_args = models.JSONField(blank=True, null=True, encoder=NautobotKombuJSONEncoder)
-    task_kwargs = models.JSONField(blank=True, null=True, encoder=NautobotKombuJSONEncoder)
+    task_args = models.JSONField(blank=True, default=list, encoder=NautobotKombuJSONEncoder)
+    task_kwargs = models.JSONField(blank=True, default=dict, encoder=NautobotKombuJSONEncoder)
+    celery_kwargs = models.JSONField(blank=True, default=dict, encoder=NautobotKombuJSONEncoder)
     # TODO(jathan): This field is currently unused for Jobs, but we should coerce it to a JSONField
     # and set a contract that anything returned from a Job task MUST be JSON. In DCR core it is
     # expected to be encoded/decoded using `content_type` and `content_encoding` which we have
@@ -595,8 +489,6 @@ class JobResult(BaseModel, CustomFieldModel):
     meta = models.JSONField(null=True, default=None, editable=False)
     scheduled_job = models.ForeignKey(to="extras.ScheduledJob", on_delete=models.SET_NULL, null=True, blank=True)
 
-    task_id = models.UUIDField(unique=True)
-
     objects = JobResultManager()
 
     def __init__(self, *args, **kwargs):
@@ -606,14 +498,34 @@ class JobResult(BaseModel, CustomFieldModel):
     class Meta:
         ordering = ["-date_created"]
         get_latest_by = "date_created"
+        indexes = [
+            models.Index(
+                name="extras_jobresult_rcreated_idx",
+                fields=["-date_created"],
+            ),
+            models.Index(
+                name="extras_jr_rdone_idx",
+                fields=["-date_done"],
+            ),
+            models.Index(
+                name="extras_jr_statrcreate_idx",
+                fields=["status", "-date_created"],
+            ),
+            models.Index(
+                name="extras_jr_statrdone_idx",
+                fields=["status", "-date_done"],
+            ),
+        ]
+
+    natural_key_field_names = ["id"]
 
     def __str__(self):
-        return str(self.task_id)
+        return f"{self.name} started at {self.date_created} ({self.status})"
 
     def as_dict(self):
         """This is required by the django-celery-results DB backend."""
         return {
-            "task_id": self.task_id,
+            "id": self.id,
             "task_name": self.task_name,
             "task_args": self.task_args,
             "task_kwargs": self.task_kwargs,
@@ -635,92 +547,8 @@ class JobResult(BaseModel, CustomFieldModel):
 
         return f"{int(minutes)} minutes, {seconds:.2f} seconds"
 
-    @property
-    def related_object(self):
-        """Get the related object, if any, identified by the `obj_type`, `name`, and/or `task_id` fields.
-
-        If `obj_type` is extras.Job, then the `name` is used to look up an extras.jobs.Job subclass based on the
-        `class_path` of the Job subclass.
-        Note that this is **not** the extras.models.Job model class nor an instance thereof.
-
-        Else, if the the model class referenced by `obj_type` has a `name` field, our `name` field will be used
-        to look up a corresponding model instance. This is used, for example, to look up a related `GitRepository`;
-        more generally it can be used by any model that 1) has a unique `name` field and 2) needs to have a many-to-one
-        relationship between JobResults and model instances.
-
-        Else, the `obj_type` and `task_id` will be used together as a quasi-GenericForeignKey to look up a model
-        instance whose PK corresponds to the `task_id`. This behavior is currently unused in the Nautobot core,
-        but may be of use to plugin developers wishing to create JobResults that have a one-to-one relationship
-        to plugin model instances.
-
-        This method is potentially rather slow as get_job() may need to actually load the Job class from disk;
-        consider carefully whether you actually need to use it.
-        """
-        from nautobot.extras.jobs import get_job  # needed here to avoid a circular import issue
-
-        if self.obj_type == get_job_content_type():
-            # Related object is an extras.Job subclass, our `name` matches its `class_path`
-            return get_job(self.name)
-
-        if self.obj_type:
-            model_class = self.obj_type.model_class()
-        else:
-            model_class = None
-
-        if model_class is not None:
-            if hasattr(model_class, "name"):
-                # See if we have a many-to-one relationship from JobResult to model_class record, based on `name`
-                try:
-                    return model_class.objects.get(name=self.name)
-                except model_class.DoesNotExist:
-                    pass
-
-            # See if we have a one-to-one relationship from JobResult to model_class record based on `task_id`
-            try:
-                return model_class.objects.get(id=self.task_id)
-            except model_class.DoesNotExist:
-                pass
-
-        return None
-
-    @property
-    def related_name(self):
-        """
-        Similar to self.name, but if there's an appropriate `related_object`, use its name instead.
-
-        Since this calls related_object, the same potential performance concerns exist. Use with caution.
-        """
-        related_object = self.related_object
-        if not related_object:
-            return self.name
-        if hasattr(related_object, "name"):
-            return related_object.name
-        return str(related_object)
-
-    @property
-    def linked_record(self):
-        """
-        A newer alternative to self.related_object that looks up an extras.models.Job instead of an extras.jobs.Job.
-        """
-        if self.job_model is not None:
-            return self.job_model
-        model_class = self.obj_type.model_class()
-        if model_class is not None:
-            if hasattr(model_class, "name"):
-                try:
-                    return model_class.objects.get(name=self.name)
-                except model_class.DoesNotExist:
-                    pass
-            if hasattr(model_class, "class_path"):
-                try:
-                    return model_class.objects.get(class_path=self.name)
-                except model_class.DoesNotExist:
-                    pass
-        return None
-
-    def get_absolute_url(self):
-        return reverse("extras:jobresult", kwargs={"pk": self.pk})
-
+    # FIXME(jathan): This needs to go away. Need to think about that the impact
+    # will be in the JOB_RESULT_METRIC and how to compensate for it.
     def set_status(self, status):
         """
         Helper method to change the status of the job result. If the target status is terminal, the  completion
@@ -738,69 +566,118 @@ class JobResult(BaseModel, CustomFieldModel):
                 )
 
     @classmethod
-    def enqueue_job(cls, func, name, obj_type, user, *args, celery_kwargs=None, schedule=None, **kwargs):
+    def execute_job(cls, job_model, user, *job_args, celery_kwargs=None, profile=False, **job_kwargs):
         """
-        Create a JobResult instance and enqueue a job using the given callable
-
-        func: The callable object to be enqueued for execution
-        name: Name for the JobResult instance - corresponds to the desired Job class's "class_path" attribute,
-            if obj_type is extras.Job; for other funcs and obj_types it may differ.
-        obj_type: ContentType to link to the JobResult instance obj_type
-        user: User object to link to the JobResult instance
-        celery_kwargs: Dictionary of kwargs to pass as **kwargs to Celery when job is queued
-        args: additional args passed to the callable
-        schedule: Optional ScheduledJob instance to link to the JobResult
-        kwargs: additional kwargs passed to the callable
+        Create a JobResult instance and run a job in the current process, blocking until the job finishes.
+
+        Running tasks synchronously in celery is *NOT* supported and if possible `enqueue_job` with synchronous=False
+        should be used instead.
+
+        Args:
+            job_model (Job): The Job to be enqueued for execution
+            user (User): User object to link to the JobResult instance
+            celery_kwargs (dict, optional): Dictionary of kwargs to pass as **kwargs to Celery when job is run
+            profile (bool, optional): Whether to run cProfile on the job execution
+            *job_args: positional args passed to the job task
+            **job_kwargs: keyword args passed to the job task
+
+        Returns:
+            JobResult instance
+        """
+        return cls.enqueue_job(
+            job_model, user, *job_args, celery_kwargs=celery_kwargs, profile=profile, synchronous=True, **job_kwargs
+        )
+
+    @classmethod
+    def enqueue_job(
+        cls,
+        job_model,
+        user,
+        *job_args,
+        celery_kwargs=None,
+        profile=False,
+        schedule=None,
+        task_queue=None,
+        synchronous=False,
+        **job_kwargs,
+    ):
+        """Create a JobResult instance and enqueue a job to be executed asynchronously by a Celery worker.
+
+        Args:
+            job_model (Job): The Job to be enqueued for execution.
+            user (User): User object to link to the JobResult instance.
+            celery_kwargs (dict, optional): Dictionary of kwargs to pass as **kwargs to `apply_async()`/`apply()` when job is run.
+            profile (bool, optional): If True, dump cProfile stats on the job execution.
+            schedule (ScheduledJob, optional): ScheduledJob instance to link to the JobResult. Cannot be used with synchronous=True.
+            task_queue (str, optional): The celery queue to send the job to. If not set, use the default celery queue.
+            synchronous (bool, optional): If True, run the job in the current process, blocking until the job completes.
+            *job_args: positional args passed to the job task
+            **job_kwargs: keyword args passed to the job task
+
+        Returns:
+            JobResult instance
         """
-        # Discard "request" parameter from the kwargs that we save in the job_result, as it's not relevant to re-runs,
-        # and will likely go away in the future.
-        job_result_kwargs = {key: value for key, value in kwargs.items() if key != "request"}
+        if schedule is not None and synchronous:
+            raise ValueError("Scheduled jobs cannot be run synchronously")
+
         job_result = cls.objects.create(
-            name=name,
-            obj_type=obj_type,
-            user=user,
-            task_id=uuid.uuid4(),
+            name=job_model.name,
+            job_model=job_model,
             scheduled_job=schedule,
+            user=user,
         )
 
-        kwargs["job_result_pk"] = job_result.pk
+        if task_queue is None:
+            task_queue = settings.CELERY_TASK_DEFAULT_QUEUE
 
-        # Prepare kwargs that will be sent to Celery
-        if celery_kwargs is None:
-            celery_kwargs = {}
+        job_celery_kwargs = {
+            "nautobot_job_job_model_id": job_model.id,
+            "nautobot_job_profile": profile,
+            "nautobot_job_user_id": user.id,
+            "queue": task_queue,
+        }
 
-        if obj_type.app_label == "extras" and obj_type.model.lower() == "job":
-            try:
-                job_model = Job.objects.get_for_class_path(name)
-                if job_model.soft_time_limit > 0:
-                    celery_kwargs["soft_time_limit"] = job_model.soft_time_limit
-                if job_model.time_limit > 0:
-                    celery_kwargs["time_limit"] = job_model.time_limit
-                if not job_model.has_sensitive_variables:
-                    job_result.task_kwargs = job_result_kwargs
-                job_result.job_model = job_model
-                job_result.save()
-            except Job.DoesNotExist:
-                # 2.0 TODO: remove this fallback logic, database records should always exist
-                from nautobot.extras.jobs import get_job  # needed here to avoid a circular import issue
-
-                job_class = get_job(name)
-                if job_class is not None:
-                    logger.error("No Job instance found in the database corresponding to %s", name)
-                    if hasattr(job_class.Meta, "soft_time_limit"):
-                        celery_kwargs["soft_time_limit"] = job_class.Meta.soft_time_limit
-                    if hasattr(job_class.Meta, "time_limit"):
-                        celery_kwargs["time_limit"] = job_class.Meta.time_limit
-                    if not job_class.has_sensitive_variables:
-                        job_result.task_kwargs = job_result_kwargs
-                        job_result.save()
-                else:
-                    logger.error("Neither a Job database record nor a Job source class were found for %s", name)
-
-        # Jobs queued inside of a transaction need to run after the transaction completes and the JobResult is saved to the database
-        transaction.on_commit(
-            lambda: func.apply_async(args=args, kwargs=kwargs, task_id=str(job_result.task_id), **celery_kwargs)
-        )
+        if schedule is not None:
+            job_celery_kwargs["nautobot_job_schedule_id"] = schedule.id
+        if job_model.soft_time_limit > 0:
+            job_celery_kwargs["soft_time_limit"] = job_model.soft_time_limit
+        if job_model.time_limit > 0:
+            job_celery_kwargs["time_limit"] = job_model.time_limit
+
+        if celery_kwargs is not None:
+            job_celery_kwargs.update(celery_kwargs)
+
+        if synchronous:
+            # 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.save()
+
+            # setup synchronous task logging
+            redirect_logger = get_logger("celery.redirected")
+            add_nautobot_log_handler(redirect_logger)
+            setup_nautobot_job_logging(None, None, app.conf)
+
+            # redirect stdout/stderr to logger and run task
+            proxy = LoggingProxy(redirect_logger, app.conf.worker_redirect_stdouts_level)
+            with contextlib.redirect_stdout(proxy), contextlib.redirect_stderr(proxy):
+                eager_result = job_model.job_task.apply(
+                    args=job_args, kwargs=job_kwargs, task_id=str(job_result.id), **job_celery_kwargs
+                )
+
+            # copy fields from eager result to job result
+            job_result.refresh_from_db()
+            for field in ["status", "result", "traceback", "worker"]:
+                setattr(job_result, field, getattr(eager_result, field, None))
+            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
+            transaction.on_commit(
+                lambda: job_model.job_task.apply_async(
+                    args=job_args, kwargs=job_kwargs, task_id=str(job_result.id), **job_celery_kwargs
+                )
+            )
 
         return job_result
 
@@ -808,7 +685,7 @@ class JobResult(BaseModel, CustomFieldModel):
         self,
         message,
         obj=None,
-        level_choice=LogLevelChoices.LOG_DEFAULT,
+        level_choice=LogLevelChoices.LOG_INFO,
         grouping="main",
         logger=None,  # pylint: disable=redefined-outer-name
     ):
@@ -848,12 +725,7 @@ class JobResult(BaseModel, CustomFieldModel):
             log.save(using=JOB_LOGS)
 
         if logger:
-            if level_choice == LogLevelChoices.LOG_FAILURE:
-                log_level = logging.ERROR
-            elif level_choice == LogLevelChoices.LOG_WARNING:
-                log_level = logging.WARNING
-            else:
-                log_level = logging.INFO
+            log_level = getattr(logging, level_choice.upper(), logging.INFO)
             logger.log(log_level, message)
 
 
@@ -908,9 +780,6 @@ class JobButton(BaseModel, ChangeLoggedModel, NotesMixin):
     def __str__(self):
         return self.name
 
-    def get_absolute_url(self):
-        return reverse("extras:jobbutton", kwargs={"pk": self.pk})
-
 
 class ScheduledJobs(models.Model):
     """Helper table for tracking updates to scheduled tasks.
@@ -976,6 +845,7 @@ class ScheduledJob(BaseModel):
     interval = models.CharField(choices=JobExecutionType, max_length=255)
     args = models.JSONField(blank=True, default=list, encoder=NautobotKombuJSONEncoder)
     kwargs = models.JSONField(blank=True, default=dict, encoder=NautobotKombuJSONEncoder)
+    celery_kwargs = models.JSONField(blank=True, default=dict, encoder=NautobotKombuJSONEncoder)
     queue = models.CharField(
         max_length=200,
         blank=True,
@@ -1061,13 +931,11 @@ class ScheduledJob(BaseModel):
     def __str__(self):
         return f"{self.name}: {self.interval}"
 
-    def get_absolute_url(self):
-        return reverse("extras:scheduledjob", kwargs={"pk": self.pk})
+    # TODO: there's currently no natural key for ScheduledJob
+    natural_key_field_names = ["id"]
 
     def save(self, *args, **kwargs):
         self.queue = self.queue or ""
-        # pass pk to worker task in kwargs, celery doesn't provide the full object to the worker
-        self.kwargs["scheduled_job_pk"] = self.pk
         # make sure non-valid crontab doesn't get saved
         if self.interval == JobExecutionType.TYPE_CUSTOM:
             try: