sapiopycommons 2024.3.18a156__py3-none-any.whl → 2025.1.17a402__py3-none-any.whl

sapiopycommons/webhook/webhook_handlers.py

@@ -1,19 +1,49 @@
+from __future__ import annotations
+
+import json
+import sys
+import time
 import traceback
 from abc import abstractmethod
 from logging import Logger
 
+from sapiopylib.rest import UserManagerService, GroupManagerService, MessengerService
+from sapiopylib.rest.AccessionService import AccessionManager
+from sapiopylib.rest.CustomReportService import CustomReportManager
+from sapiopylib.rest.DashboardManager import DashboardManager
+from sapiopylib.rest.DataMgmtService import DataMgmtServer
 from sapiopylib.rest.DataRecordManagerService import DataRecordManager
+from sapiopylib.rest.DataService import DataManager
+from sapiopylib.rest.DataTypeService import DataTypeManager
+from sapiopylib.rest.ELNService import ElnManager
+from sapiopylib.rest.PicklistService import PickListManager
+from sapiopylib.rest.ReportManager import ReportManager
+from sapiopylib.rest.SesssionManagerService import SessionManager
+from sapiopylib.rest.User import SapioUser
 from sapiopylib.rest.WebhookService import AbstractWebhookHandler
-from sapiopylib.rest.pojo.webhook.ClientCallbackResult import FormEntryDialogResult
+from sapiopylib.rest.pojo.Message import VeloxLogMessage, VeloxLogLevel
+from sapiopylib.rest.pojo.webhook.ClientCallbackRequest import PopupType
 from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 from sapiopylib.rest.pojo.webhook.WebhookEnums import WebhookEndpointType
 from sapiopylib.rest.pojo.webhook.WebhookResult import SapioWebhookResult
+from sapiopylib.rest.utils.DataTypeCacheManager import DataTypeCacheManager
+from sapiopylib.rest.utils.FoundationAccessioning import FoundationAccessionManager
 from sapiopylib.rest.utils.recordmodel.RecordModelManager import RecordModelManager, RecordModelInstanceManager, \
     RecordModelRelationshipManager
 from sapiopylib.rest.utils.recordmodel.ancestry import RecordModelAncestorManager
+from sapiopylib.rest.utils.recordmodel.last_saved import LastSavedValueManager
 
-from sapiopycommons.general.exceptions import SapioUserErrorException, SapioCriticalErrorException
-from sapiopycommons.general.popup_util import PopupUtil
+from sapiopycommons.callbacks.callback_util import CallbackUtil
+from sapiopycommons.eln.experiment_handler import ExperimentHandler
+from sapiopycommons.general.directive_util import DirectiveUtil
+from sapiopycommons.general.exceptions import SapioUserErrorException, SapioCriticalErrorException, \
+    SapioUserCancelledException, SapioException, SapioDialogTimeoutException, MessageDisplayType
+from sapiopycommons.general.sapio_links import SapioNavigationLinker
+from sapiopycommons.general.time_util import TimeUtil
+from sapiopycommons.recordmodel.record_handler import RecordHandler
+from sapiopycommons.rules.eln_rule_handler import ElnRuleHandler
+from sapiopycommons.rules.on_save_rule_handler import OnSaveRuleHandler
+from sapiopycommons.webhook.webhook_context import ProcessQueueContext
 
 
 # FR-46064 - Initial port of PyWebhookUtils to sapiopycommons.
@@ -25,41 +55,213 @@ class CommonsWebhookHandler(AbstractWebhookHandler):
     """
     logger: Logger
 
+    _start_time: float
+    _start_time_epoch: int
+
+    user: SapioUser
+    """The user who invoked this webhook. Used for authenticating requests back to the Sapio server."""
+    group_name: str
+    """The name of the group that the user invoked this webhook with."""
+    user_utc_offset_seconds: int
+    """The number of seconds that the user is offset from the UTC timezone. Able to be used with TimeUtil to display
+    timestamps in the user's timezone."""
     context: SapioWebhookContext
+    """The context from the server of this webhook's invocation."""
 
+    # CR-47383: Include every manager from DataMgmtServer for easier access.
+    acc_man: AccessionManager
+    """A class for making requests to the accession webservice endpoints."""
+    fnd_acc_man: FoundationAccessionManager
+    """A class for making requests to the Foundations accession webservice endpoints."""
+    custom_report_man: CustomReportManager
+    """A class for making requests to the custom report webservice endpoints."""
+    dash_man: DashboardManager
+    """A class for making requests to the dashboard management webservice endpoints."""
+    xml_data_man: DataManager
+    """A class for making requests to the data record import/export via XML webservice endpoints."""
     dr_man: DataRecordManager
+    """A class for making requests to the data record webservice endpoints."""
+    dt_man: DataTypeManager
+    """A class for making requests to the data type webservice endpoints."""
+    eln_man: ElnManager
+    """A class for making requests to the ELN management webservice endpoints."""
+    group_man: GroupManagerService
+    """A class for making requests to the group management webservice endpoints."""
+    messenger: MessengerService
+    """A class for making requests to the message webservice endpoints."""
+    list_man: PickListManager
+    """A class for making requests to the pick list webservice endpoints."""
+    pdf_report_man: ReportManager
+    """A class for making requests to the report webservice endpoints."""
+    session_man: SessionManager
+    """A class for making requests to the session management webservice endpoints."""
+    user_man: UserManagerService
+    """A class for making requests to the user management webservice endpoints."""
+
     rec_man: RecordModelManager
+    """The record model manager. Used for committing record model changes to the system."""
     inst_man: RecordModelInstanceManager
+    """The record model instance manager. Used for adding record models to the cache."""
     rel_man: RecordModelRelationshipManager
+    """The record model relationship manager. Used for loading parent/child and side-link relationships between record
+    models."""
     # FR-46329: Add the ancestor manager to CommonsWebhookHandler.
     an_man: RecordModelAncestorManager
+    """The record model ancestor manager. Used for loading ancestor relationships between record models."""
+    saved_vals_man: LastSavedValueManager
+    """The last saved values manager. Used for determining what the record values were prior to this commit."""
+
+    dt_cache: DataTypeCacheManager
+    """A class that calls the same endpoints as the DataTypeManager (self.dt_man), except the results are cached so that
+    repeated calls to the same function don't result in duplicate webservice calls. """
+    rec_handler: RecordHandler
+    """A class that behaves like a combination between the DataRecordManager and RecordModelInstanceManager, allowing
+    you to query and wrap record as record models in a single function call, among other functions useful for dealing
+    with record models."""
+    callback: CallbackUtil
+    """A class for making requests to the client callback webservice endpoints."""
+    directive: DirectiveUtil
+    """A class for making directives that redirect the user to a new webpage after this webhook returns a result."""
+    exp_handler: ExperimentHandler | None
+    """If this webhook was invoked from within an ELN experiment, this variable will be populated with an
+    ExperimentHandler initialized from the context. """
+    rule_handler: OnSaveRuleHandler | ElnRuleHandler | None
+    """If this is an ELN or on save rule endpoint, this variable will be populated with an ElnRuleHandler or
+    OnSaveRuleHandler, depending on the endpoint type."""
+    custom_context: ProcessQueueContext | None
+    """If this is a custom endpoint, this variable will be populated with an object that parses the custom context
+    data."""
+
+    # FR-47390: Allow for classes that extend CommonsWebhookHandler to change how exception messages are displayed
+    # to the user be changing these variables instead of needing to override the exception handling functions.
+    default_user_error_display_type: MessageDisplayType
+    """The default message display type for user error exceptions. If a user error exception is thrown and doesn't
+    specify a display type, this type will be used."""
+    default_critical_error_display_type: MessageDisplayType
+    """The default message display type for critical error exceptions. If a critical error exception is thrown and
+    doesn't specify a display type, this type will be used."""
+    default_dialog_timeout_display_type: MessageDisplayType
+    """The default message display type for dialog timeout exceptions."""
+    default_unexpected_error_display_type: MessageDisplayType
+    """The default message display type for unexpected exceptions."""
+
+    default_user_error_title: str
+    """The default title to display to the user when a user error occurs. If a user error exception is thrown and
+    doesn't specify a title, this title will be used."""
+    default_critical_error_title: str
+    """The default title to display to the user when a critical error occurs. If a critical error exception is thrown
+    and doesn't specify a title, this title will be used."""
+    default_dialog_timeout_title: str
+    """The default title to display to the user when a dialog times out."""
+    default_unexpected_error_title: str
+    """The default title to display to the user when an unexpected exception occurs."""
+
+    default_dialog_timeout_message: str
+    """The default message to display to the user when a dialog times out."""
+    default_unexpected_error_message: str
+    """The default message to display to the user when an unexpected exception occurs."""
 
     def run(self, context: SapioWebhookContext) -> SapioWebhookResult:
+        # Timestamps used for measuring performance.
+        self._start_time = time.perf_counter()
+        self._start_time_epoch = TimeUtil.now_in_millis()
+
+        # Save the webhook context so that any function of this class can access it.
         self.context = context
-        self.logger = context.user.logger
 
+        # Save the user and commonly sought after user information.
+        self.user = context.user
+        self.group_name = self.user.session_additional_data.current_group_name
+        self.user_utc_offset_seconds = self.user.session_additional_data.utc_offset_seconds
+
+        # Get the logger from the user.
+        self.logger = self.user.logger
+
+        # Initialize basic manager classes from sapiopylib.
+        self.acc_man = DataMgmtServer.get_accession_manager(self.user)
+        self.custom_report_man = DataMgmtServer.get_custom_report_manager(self.user)
+        self.dash_man = DataMgmtServer.get_dashboard_manager(self.user)
+        self.xml_data_man = DataMgmtServer.get_data_manager(self.user)
         self.dr_man = context.data_record_manager
-        self.rec_man = RecordModelManager(context.user)
+        self.dt_man = DataMgmtServer.get_data_type_manager(self.user)
+        self.eln_man = context.eln_manager
+        self.group_man = DataMgmtServer.get_group_manager(self.user)
+        self.messenger = DataMgmtServer.get_messenger(self.user)
+        self.list_man = DataMgmtServer.get_picklist_manager(self.user)
+        self.pdf_report_man = DataMgmtServer.get_report_manager(self.user)
+        self.session_man = DataMgmtServer.get_session_manager(self.user)
+        self.user_man = DataMgmtServer.get_user_manager(self.user)
+
+        # Initialize record model managers.
+        self.rec_man = RecordModelManager(self.user)
         self.inst_man = self.rec_man.instance_manager
         self.rel_man = self.rec_man.relationship_manager
-        self.an_man = RecordModelAncestorManager(self.rec_man)
+        self.an_man = self.rec_man.ancestor_manager
+        self.saved_vals_man = self.rec_man.last_saved_manager
+
+        # Initialize more complex classes from sapiopylib and sapiopycommons.
+        self.fnd_acc_man = FoundationAccessionManager(self.user)
+        self.dt_cache = DataTypeCacheManager(self.user)
+        self.rec_handler = RecordHandler(context)
+        self.callback = CallbackUtil(context)
+        self.directive = DirectiveUtil(context)
+        if context.eln_experiment is not None:
+            self.exp_handler = ExperimentHandler(context)
+        else:
+            self.exp_handler = None
+        if self.is_on_save_rule():
+            self.rule_handler = OnSaveRuleHandler(context)
+        elif self.is_eln_rule():
+            self.rule_handler = ElnRuleHandler(context)
+        else:
+            self.rule_handler = None
+        if self.is_custom():
+            self.custom_context = ProcessQueueContext(context)
+        else:
+            self.custom_context = None
+
+        # Set the default display types, titles, and messages for each type of exception that can display a message.
+        self.default_user_error_display_type = MessageDisplayType.TOASTER_WARNING
+        self.default_critical_error_display_type = MessageDisplayType.DISPLAY_ERROR
+        self.default_dialog_timeout_display_type = MessageDisplayType.OK_DIALOG
+        self.default_unexpected_error_display_type = MessageDisplayType.TOASTER_WARNING
 
-        # Handle any client callback results that may have been sent due to an exception.
-        exception_result: SapioWebhookResult | None = self.handle_exception_callback()
-        if exception_result is not None:
-            return exception_result
+        self.default_user_error_title = ""
+        self.default_critical_error_title = ""
+        self.default_dialog_timeout_title = "Dialog Timeout"
+        self.default_unexpected_error_title = ""
+
+        self.default_dialog_timeout_message = ("You have remained idle for too long and this dialog has timed out. "
+                                               "Close and re-initiate it to continue.")
+        self.default_unexpected_error_message = ("Unexpected error occurred during webhook execution. Please contact "
+                                                 "Sapio support.")
 
         # Wrap the execution of each webhook in a try/catch. If an exception occurs, handle any special sapiopycommons
         # exceptions. Otherwise, return a generic message stating that an error occurred.
         try:
-            return self.execute(context)
+            self.initialize(context)
+            result = self.execute(context)
+            if result is None:
+                raise SapioException("Your execute function returned a None result! Don't forget your return statement!")
+            return result
         except SapioUserErrorException as e:
             return self.handle_user_error_exception(e)
         except SapioCriticalErrorException as e:
             return self.handle_critical_error_exception(e)
+        except SapioUserCancelledException as e:
+            return self.handle_user_cancelled_exception(e)
+        except SapioDialogTimeoutException as e:
+            return self.handle_dialog_timeout_exception(e)
         except Exception as e:
             return self.handle_unexpected_exception(e)
 
+    def initialize(self, context: SapioWebhookContext) -> None:
+        """
+        A function that can be optionally overridden by your webhooks to initialize additional instance variables,
+        or set up whatever else you wish to set up before the execute function is ran. Default behavior does nothing.
+        """
+        pass
+
     @abstractmethod
     def execute(self, context: SapioWebhookContext) -> SapioWebhookResult:
         """
@@ -69,102 +271,268 @@ class CommonsWebhookHandler(AbstractWebhookHandler):
 
     # CR-46153: Make CommonsWebhookHandler exception handling more easily overridable by splitting them out of
     # the run method and into their own functions.
-    def handle_exception_callback(self) -> SapioWebhookResult | None:
+    def handle_user_error_exception(self, e: SapioUserErrorException) -> SapioWebhookResult:
         """
-        Handle any client callbacks made as the result of exceptions. Whether a result is from an exception is
-        determined by reading the callback context data. Context data for exceptions should be something unique that
-        no programmer would use in practice so that we don't accidentally handle callbacks we shouldn't.
-        :return: A SapioWebhookResult for any handled exceptions. None if nothing was handled.
+        Handle a SapioUserErrorException.
+
+        Default behavior returns a false result and the error message as display text in a webhook result.
+
+        :param e: The exception that was raised.
+        :return: A SapioWebhookResult to end the webhook session with.
         """
-        # Catch any SapioCriticalErrorException results.
-        result = self.context.client_callback_result
+        result: SapioWebhookResult | None = self.handle_any_exception(e)
         if result is not None:
-            result_context = result.callback_context_data
-            if isinstance(result, FormEntryDialogResult) and result_context == "SapioCriticalErrorException":
-                return SapioWebhookResult(False)
-        return None
+            return result
+        self.log_error(traceback.format_exc())
+        self.handle_user_error_exception_extra(e)
 
-    def handle_user_error_exception(self, e: SapioUserErrorException) -> SapioWebhookResult:
+        display_type: MessageDisplayType = e.display_type if e.display_type else self.default_user_error_display_type
+        title: str = e.title if e.title is not None else self.default_user_error_title
+        return self._display_exception(e.msg, display_type, title)
+
+    def handle_user_error_exception_extra(self, e: SapioUserErrorException) -> None:
         """
-        Handle a SapioUserErrorException. Default behavior returns the error message as display text in a webhook
-        result.
+        An additional function that can be overridden to provide extra behavior when a SapioUserErrorException is thrown.
+        Default behavior does nothing.
+        """
+        pass
+
+    def handle_critical_error_exception(self, e: SapioCriticalErrorException) -> SapioWebhookResult:
+        """
+        Handle a SapioCriticalErrorException.
+
+        Default behavior makes a display_error client callback with the error message and returns a false result.
+
         :param e: The exception that was raised.
-        :return: A SapioWebhookResult reporting the exception to the user.
+        :return: A SapioWebhookResult to end the webhook session with.
         """
         result: SapioWebhookResult | None = self.handle_any_exception(e)
         if result is not None:
             return result
         self.log_error(traceback.format_exc())
-        return SapioWebhookResult(False, display_text=e.args[0])
+        self.handle_critical_error_exception_extra(e)
 
-    def handle_critical_error_exception(self, e: SapioCriticalErrorException) -> SapioWebhookResult:
+        display_type: MessageDisplayType = e.display_type if e.display_type else self.default_critical_error_display_type
+        title: str = e.title if e.title is not None else self.default_critical_error_title
+        return self._display_exception(e.msg, display_type, title)
+
+    def handle_critical_error_exception_extra(self, e: SapioCriticalErrorException) -> None:
         """
-        Handle a SapioCriticalErrorException. Default behavior returns a FormEntryDialogRequest with an uneditable
-        text entry containing the error message. This client callback for this request is handled by
-        handle_exception_callback.
+        An additional function that can be overridden to provide extra behavior when a SapioCriticalErrorException is
+        thrown. Default behavior does nothing.
+        """
+        pass
+
+    def handle_user_cancelled_exception(self, e: SapioUserCancelledException) -> SapioWebhookResult:
+        """
+        Handle a SapioUserCancelledException.
+
+        Default behavior simply ends the webhook session with a true result (since the user cancelling is a valid
+        action).
+
         :param e: The exception that was raised.
-        :return: A SapioWebhookResult reporting the exception to the user.
+        :return: A SapioWebhookResult to end the webhook session with.
         """
         result: SapioWebhookResult | None = self.handle_any_exception(e)
         if result is not None:
             return result
-        self.log_error(traceback.format_exc())
-        return PopupUtil.string_field_popup("Error", "", "Reason", e.args[0],
-                                            request_context="SapioCriticalErrorException", num_lines=10)
+        self.handle_user_cancelled_exception_extra(e)
+        # FR-47390: Return a False result for user cancelled exceptions so that transactional webhooks cancel the
+        # commit.
+        return SapioWebhookResult(False)
+
+    def handle_user_cancelled_exception_extra(self, e: SapioUserCancelledException) -> None:
+        """
+        An additional function that can be overridden to provide extra behavior when a SapioUserCancelledException is
+        thrown. Default behavior does nothing.
+        """
+        pass
+
+    def handle_dialog_timeout_exception(self, e: SapioDialogTimeoutException) -> SapioWebhookResult:
+        """
+        Handle a SapioDialogTimeoutException.
+
+        Default behavior displays an OK popup notifying the user that the dialog has timed out and returns a false
+        webhook result.
+
+        :param e: The exception that was raised.
+        :return: A SapioWebhookResult to end the webhook session with.
+        """
+        result: SapioWebhookResult | None = self.handle_any_exception(e)
+        if result is not None:
+            return result
+        self.handle_dialog_timeout_exception_extra(e)
+        return self._display_exception(self.default_dialog_timeout_message,
+                                       self.default_dialog_timeout_display_type,
+                                       self.default_dialog_timeout_title)
+
+    def handle_dialog_timeout_exception_extra(self, e: SapioDialogTimeoutException) -> None:
+        """
+        An additional function that can be overridden to provide extra behavior when a SapioDialogTimeoutException is
+        thrown. Default behavior does nothing.
+        """
+        pass
 
     def handle_unexpected_exception(self, e: Exception) -> SapioWebhookResult:
         """
-        Handle a generic exception which isn't a SapioUserErrorException or SapioCriticalErrorException. Default
-        behavior returns a generic error message as display text informing the user to contact Sapio support.
+        Handle a generic exception which isn't one of the handled Sapio exceptions.
+
+        Default behavior returns a false webhook result with a generic error message as display text informing the user
+        to contact Sapio support. Additionally, the stack trace of the exception that was thrown is logged to the
+        execution log for the webhook call in the system.
+
         :param e: The exception that was raised.
-        :return: A SapioWebhookResult reporting the exception to the user.
+        :return: A SapioWebhookResult to end the webhook session with.
         """
         result: SapioWebhookResult | None = self.handle_any_exception(e)
         if result is not None:
             return result
-        self.log_error(traceback.format_exc())
-        return SapioWebhookResult(False, display_text="Unexpected error occurred during webhook execution. "
-                                                      "Please contact Sapio support.")
+        msg: str = traceback.format_exc()
+        self.log_error(msg, True)
+        # FR-47079: Also log all unexpected exception messages to the webhook execution log within the platform.
+        self.log_error_to_webhook_execution_log(msg, True)
+        self.handle_unexpected_exception_extra(e)
+        return self._display_exception(self.default_unexpected_error_message,
+                                       self.default_unexpected_error_display_type,
+                                       self.default_unexpected_error_title)
+
+    def handle_unexpected_exception_extra(self, e: Exception) -> None:
+        """
+        An additional function that can be overridden to provide extra behavior when a generic exception is thrown.
+        Default behavior does nothing.
+        """
+        pass
 
-    # noinspection PyMethodMayBeStatic,PyUnusedLocal
     def handle_any_exception(self, e: Exception) -> SapioWebhookResult | None:
         """
         An exception handler which runs regardless of the type of exception that was raised. Can be used to "rollback"
         the client if an error occurs. Default behavior does nothing and returns None.
+
         :param e: The exception that was raised.
         :return: An optional SapioWebhookResult. May return a custom message to the client that wouldn't have been
-            sent by one of the normal exception handlers, or may return None if no result needs returned.
+            sent by one of the normal exception handlers, or may return None if no result needs returned. If a result is
+            returned, then the default behavior of other exception handlers is skipped.
         """
-        return None
+        pass
+
+    def display_message(self, msg: str, display_type: MessageDisplayType, title: str = "") -> bool:
+        """
+        Display a message to the user. The form that the message takes depends on the display type.
+
+        :param msg: The message to display to the user.
+        :param display_type: The manner in which the message should be displayed.
+        :param title: If the display type is able to have a title, this is the title that will be displayed.
+        :return: True if the message was displayed. False if the message could not be displayed (because this
+            webhook can't send client callbacks).
+        """
+        if not self.can_send_client_callback():
+            return False
+        if display_type == MessageDisplayType.TOASTER_SUCCESS:
+            self.callback.toaster_popup(msg, title, PopupType.Success)
+        elif display_type == MessageDisplayType.TOASTER_INFO:
+            self.callback.toaster_popup(msg, title, PopupType.Info)
+        elif display_type == MessageDisplayType.TOASTER_WARNING:
+            self.callback.toaster_popup(msg, title, PopupType.Warning)
+        elif display_type == MessageDisplayType.TOASTER_ERROR:
+            self.callback.toaster_popup(msg, title, PopupType.Error)
+        elif display_type == MessageDisplayType.OK_DIALOG:
+            self.callback.ok_dialog(title, msg)
+        elif display_type == MessageDisplayType.DISPLAY_INFO:
+            self.callback.display_info(msg)
+        elif display_type == MessageDisplayType.DISPLAY_WARNING:
+            self.callback.display_warning(msg)
+        elif display_type == MessageDisplayType.DISPLAY_ERROR:
+            self.callback.display_error(msg)
+        return True
+
+    def _display_exception(self, msg: str, display_type: MessageDisplayType, title: str) -> SapioWebhookResult:
+        """
+        Display an exception message to the user and return a webhook result to end the webhook invocation.
+        This handles the cases where the webhook invocation type is incapable of sending client callbacks and must
+        instead return the message in the webhook result, and the case where the display type is an OK dialog, which
+        may potentially cause a dialog timeout exception.
+        """
+        # If the display type is an OK dialog, then we need to handle the dialog timeout exception that could be thrown.
+        try:
+            # Set the dialog timeout to something low as to not hog the connection.
+            self.callback.set_dialog_timeout(60)
+            # If this invocation type can't send client callbacks, fallback to sending the message in the result.
+            if self.display_message(msg, display_type, title):
+                return SapioWebhookResult(False)
+            return SapioWebhookResult(False, display_text=msg)
+        except SapioDialogTimeoutException:
+            return SapioWebhookResult(False)
 
     def log_info(self, msg: str) -> None:
         """
-        Write an info message to the log. Log destination is stdout. This message will be prepended with the user's
-        username and the experiment ID of the experiment they are in, if any.
-        """
-        exp_id = None
-        if self.context.eln_experiment is not None:
-            exp_id = self.context.eln_experiment.notebook_experiment_id
-        # CR-46333: Add the user's group to the logging message.
-        user = self.context.user
-        username = user.username
-        group_name = user.session_additional_data.current_group_name
-        self.logger.info(f"(User: {username}, Group: {group_name}, Experiment: {exp_id}):\n{msg}")
-
-    def log_error(self, msg: str) -> None:
-        """
-        Write an error message to the log. Log destination is stderr. This message will be prepended with the user's
-        username and the experiment ID of the experiment they are in, if any.
-        """
-        exp_id = None
-        if self.context.eln_experiment is not None:
-            exp_id = self.context.eln_experiment.notebook_experiment_id
-        # CR-46333: Add the user's group to the logging message.
-        user = self.context.user
-        username = user.username
-        group_name = user.session_additional_data.current_group_name
+        Write an info message to the webhook server log. Log destination is stdout. This message will include
+        information about the user's group, their location in the system, the webhook invocation type, and other
+        important information that can be gathered from the context that is useful for debugging.
+        """
+        self.logger.info(self._format_log(msg, "log_info call"))
+
+    def log_error(self, msg: str, is_exception: bool = False) -> None:
+        """
+        Write an info message to the webhook server log. Log destination is stdout. This message will include
+        information about the user's group, their location in the system, the webhook invocation type, and other
+        important information that can be gathered from the context that is useful for debugging.
+        """
         # PR-46209: Use logger.error instead of logger.info when logging errors.
-        self.logger.error(f"(User: {username}, Group: {group_name}, Experiment: {exp_id}):\n{msg}")
+        self.logger.error(self._format_log(msg, "log_error call", is_exception))
+
+    def log_error_to_webhook_execution_log(self, msg: str, is_exception: bool = False) -> None:
+        """
+        Write an error message to the platform's webhook execution log. This can be reviewed by navigating to the
+        webhook configuration where the webhook that called this function is defined and clicking the "View Log"
+        button. From there, select one of the rows for the webhook executions and click "Download Log" from the right
+        side table.
+        """
+        msg = self._format_log(msg, "Error occurred during webhook execution.", is_exception)
+        self.messenger.log_message(VeloxLogMessage(msg, VeloxLogLevel.ERROR, self.__class__.__name__))
+
+    def _format_log(self, msg: str, prefix: str | None = None, is_exception: bool = False) -> str:
+        """
+        Given a message to log, populate it with some metadata about this particular webhook execution, including
+        the group of the user and the invocation type of the webhook call.
+        """
+        # Start the message with the provided prefix.
+        message: str = prefix + "\n" if prefix else ""
+
+        # Construct a summary of the current state of this webhook.
+        message += f"{WebhookStateSummary(self, is_exception)}\n"
+
+        # End the message with the provided msg parameter.
+        message += msg
+        return message
+
+    @property
+    def start_time(self) -> float:
+        """
+        :return: The time that this webhook was invoked, represented in seconds. This time comes from a performance
+            counter and is not guaranteed to correspond to a date. Only use in comparison to other performance counters.
+        """
+        return self._start_time
+
+    @property
+    def start_time_millis(self) -> int:
+        """
+        :return: The epoch timestamp in milliseconds for the time that this webhook was invoked.
+        """
+        return self._start_time_epoch
+
+    def elapsed_time(self) -> float:
+        """
+        :return: The number of seconds that have elapsed since this webhook was invoked to the time that this function
+            is called. Measures using a performance counter to a high degree of accuracy.
+        """
+        return time.perf_counter() - self._start_time
+
+    def elapsed_time_millis(self) -> int:
+        """
+        :return: The number of milliseconds that have elapsed since this webhook was invoked to the time that this
+            function is called.
+        """
+        return TimeUtil.now_in_millis() - self._start_time_epoch
 
     def is_main_toolbar(self) -> bool:
         """
@@ -240,3 +608,183 @@ class CommonsWebhookHandler(AbstractWebhookHandler):
         :return: True if this endpoint was invoked as a scheduled action.
         """
         return self.context.end_point_type == WebhookEndpointType.SCHEDULEDPLUGIN
+
+    def is_action_button_field(self) -> bool:
+        """
+        :return: True if this endpoint was invoked as an action button field.
+        """
+        return self.context.end_point_type == WebhookEndpointType.ACTIONDATAFIELD
+
+    def is_action_text_field(self) -> bool:
+        """
+        :return: True if this endpoint was invoked as an action text field.
+        """
+        return self.context.end_point_type == WebhookEndpointType.ACTION_TEXT_FIELD
+
+    def is_custom(self) -> bool:
+        """
+        :return: True if this endpoint was invoked from a custom point, such as a custom queue.
+        """
+        return self.context.end_point_type == WebhookEndpointType.CUSTOM
+
+    def is_calendar_event_click_handler(self) -> bool:
+        """
+        :return: True if this endpoint was invoked from a calendar event click handler.
+        """
+        return self.context.end_point_type == WebhookEndpointType.CALENDAR_EVENT_CLICK_HANDLER
+
+    def is_eln_menu_grabber(self) -> bool:
+        """
+        :return: True if this endpoint was invoked as a notebook entry grabber.
+        """
+        return self.context.end_point_type == WebhookEndpointType.NOTEBOOKEXPERIMENTGRABBER
+
+    def is_conversation_bot(self) -> bool:
+        """
+        :return: True if this endpoint was invoked as from a conversation bot.
+        """
+        return self.context.end_point_type == WebhookEndpointType.CONVERSATION_BOT
+
+    def is_multi_data_type_table_toolbar(self) -> bool:
+        """
+        :return: True if this endpoint was invoked as a multi data type table toolbar button.
+        """
+        return self.context.end_point_type == WebhookEndpointType.REPORTTOOLBAR
+
+    def can_send_client_callback(self) -> bool:
+        """
+        :return: Whether client callbacks and directives can be sent from this webhook's endpoint type.
+        """
+        return self.context.is_client_callback_available
+
+
+# FR-47390: Move the gathering of webhook information out of log_error_to_webhook_execution_log and into its own class.
+class WebhookStateSummary:
+    """
+    A class that summarizes the state of a webhook at the time that it is created. This class is useful for logging
+    information about the webhook invocation to the execution log.
+    """
+    username: str
+    """The username of the user who invoked the webhook."""
+    user_group: str
+    """The group that the user is currently in."""
+    start_timestamp: int
+    """The epoch timestamp in milliseconds for when the webhook was invoked."""
+    start_utc_time: str
+    """The time that the webhook was invoked in UTC."""
+    start_server_time: str | None
+    """The time that the webhook was invoked on the server, if the TimeUtil class has a default timezone set."""
+    start_user_time: str
+    """The time that the webhook was invoked for the user, adjusted for their timezone."""
+    timestamp: int
+    """The current epoch timestamp in milliseconds."""
+    utc_time: str
+    """The current time in UTC."""
+    server_time: str | None
+    """The current time on the webhook server, if the TimeUtil class has a default timezone set."""
+    user_time: str
+    """The current time for the user, adjusted for their timezone."""
+    invocation_type: str
+    """The type of endpoint that this webhook was invoked from."""
+    class_name: str
+    """The name of the class that this webhook is an instance of."""
+    link: str | None
+    """A link to the location that the webhook was invoked from, if applicable."""
+    exc_summary: str | None
+    """A summary of the exception that occurred, if this summary is being created for an exception."""
+
+    def __init__(self, webhook: CommonsWebhookHandler, summarize_exception: bool = False):
+        """
+        :param webhook: The webhook that this summary is being created for.
+        :param summarize_exception: If true, then this summary will include information about the most recent exception
+            that occurred during the execution of the webhook.
+        """
+        # User information.
+        self.username = webhook.user.username
+        self.user_group = webhook.group_name
+
+        # Time information.
+        fmt: str = "%Y-%m-%d %H:%M:%S.%f"
+        self.start_timestamp = webhook.start_time_millis
+        self.start_utc_time = TimeUtil.millis_to_format(self.start_timestamp, fmt, "UTC")
+        self.start_server_time = None
+        self.start_user_time = TimeUtil.millis_to_format(self.start_timestamp, fmt, webhook.user_utc_offset_seconds)
+
+        self.timestamp = TimeUtil.now_in_millis()
+        self.utc_time = TimeUtil.millis_to_format(self.timestamp, fmt, "UTC")
+        self.server_time = None
+        self.user_time = TimeUtil.millis_to_format(self.timestamp, fmt, webhook.user_utc_offset_seconds)
+
+        if TimeUtil.get_default_timezone():
+            self.start_server_time = TimeUtil.millis_to_format(self.start_timestamp, fmt)
+            self.server_time = TimeUtil.millis_to_format(self.timestamp, fmt)
+
+        # Webhook invocation information.
+        self.invocation_type = webhook.context.end_point_type.display_name
+        self.class_name = webhook.__class__.__name__
+
+        # User location information.
+        self.link = None
+        context = webhook.context
+        navigator = SapioNavigationLinker(context)
+        if context.eln_experiment is not None:
+            self.link = navigator.experiment(context.eln_experiment)
+        elif context.base_data_record:
+            self.link = navigator.data_record(context.base_data_record)
+        elif context.data_record and not context.data_record_list:
+            self.link = navigator.data_record(context.data_record)
+
+        # If this is logging an exception, get the system's info on the most recent exception and produce a summary.
+        self.exc_summary = None
+        if summarize_exception:
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+
+            # If this is a SapioServerException, then it can contain json with the exception message from the server.
+            # This provides a more useful summary than args[0] does, so use it instead.
+            exception_name: str = exc_type.__name__
+            if exception_name == "SapioServerException":
+                # Sometimes the SapioServerException is HTML instead of JSON. If that's the case, just try/catch the
+                # failure to parse the JSON and continue to use args[0] as the exception message.
+                try:
+                    exc_str: str = str(exc_value)
+                    exception_msg = json.loads(exc_str[exc_str.find("{"):]).get("message")
+                except Exception:
+                    exception_msg = exc_value.args[0]
+            else:
+                # For all other exceptions, assume that the first argument is a message.
+                exception_msg = exc_value.args[0]
+
+            self.exc_summary = f"{exception_name}: {exception_msg}"
+            del (exc_type, exc_value, exc_traceback)
+
+    def __str__(self) -> str:
+        message: str = ""
+
+        # Record the time that the webhook was started and this state was created.
+        message += "Webhook Invocation Time:\n"
+        message += f"\tUTC: {self.start_utc_time}\n"
+        if TimeUtil.get_default_timezone() is not None:
+            message += f"\tServer: {self.start_server_time}\n"
+        message += f"\tUser: {self.start_user_time}\n"
+
+        message += "Current Time:\n"
+        message += f"\tUTC: {self.utc_time}\n"
+        if TimeUtil.get_default_timezone() is not None:
+            message += f"\tServer: {self.server_time}\n"
+        message += f"\tUser: {self.user_time}\n"
+
+        # Record information about the user and how the webhook was invoked.
+        message += f"Username: {self.username}\n"
+        message += f"User group: {self.user_group}\n"
+        message += f"Webhook invocation type: {self.invocation_type}\n"
+        message += f"Class name: {self.class_name}\n"
+
+        # If we're able to, provide a link to the location that the error occurred at.
+        if self.link:
+            message += f"User location: {self.link}\n"
+
+        # If this state summary is for an exception, include the exception summary.
+        if self.exc_summary:
+            message += f"{self.exc_summary}\n"
+
+        return message