first commit

core/modules/dblog/css/dblog.module.css

@@ -0,0 +1,37 @@
+/**
+ * @file
+ * Admin styles for the Database Logging module.
+ */
+.dblog-filter-form .form-item-type,
+.dblog-filter-form .form-item-severity {
+  display: inline-block;
+  max-width: 30%;
+  margin: 0.1em 0.9em 0.1em 0.1em; /* LTR */
+}
+[dir="rtl"] .dblog-filter-form .form-item-type,
+[dir="rtl"] .dblog-filter-form .form-item-severity {
+  margin: 0.1em 0.1em 0.1em 0.9em;
+}
+.dblog-filter-form .form-actions {
+  display: inline-block;
+  padding: 3ex 0 0;
+  vertical-align: top;
+}
+.admin-dblog .icon,
+.admin-dblog .dblog-warning .icon,
+.admin-dblog .dblog-error .icon,
+.admin-dblog .dblog-critical .icon,
+.admin-dblog .dblog-alert .icon,
+.admin-dblog .dblog-emergency .icon {
+  width: 16px;
+  background: no-repeat center;
+}
+.admin-dblog .dblog-warning .icon {
+  background-image: url(../../../misc/icons/e29700/warning.svg);
+}
+.admin-dblog .dblog-error .icon,
+.admin-dblog .dblog-critical .icon,
+.admin-dblog .dblog-alert .icon,
+.admin-dblog .dblog-emergency .icon {
+  background-image: url(../../../misc/icons/e32700/error.svg);
+}

core/modules/dblog/dblog.admin.inc

@@ -0,0 +1,43 @@
+<?php
+
+/**
+ * @file
+ * Administrative page callbacks for the Database Logging module.
+ */
+
+use Drupal\Core\Logger\RfcLogLevel;
+
+/**
+ * Creates a list of database log administration filters that can be applied.
+ *
+ * @return array
+ *   Associative array of filters. The top-level keys are used as the form
+ *   element names for the filters, and the values are arrays with the following
+ *   elements:
+ *   - title: Title of the filter.
+ *   - where: The filter condition.
+ *   - options: Array of options for the select list for the filter.
+ */
+function dblog_filters() {
+  $filters = [];
+
+  foreach (_dblog_get_message_types() as $type) {
+    $types[$type] = t($type);
+  }
+
+  if (!empty($types)) {
+    $filters['type'] = [
+      'title' => t('Type'),
+      'where' => "w.type = ?",
+      'options' => $types,
+    ];
+  }
+
+  $filters['severity'] = [
+    'title' => t('Severity'),
+    'where' => 'w.severity = ?',
+    'options' => RfcLogLevel::getLevels(),
+  ];
+
+  return $filters;
+}

core/modules/dblog/dblog.info.yml

@@ -0,0 +1,11 @@
+name: 'Database Logging'
+type: module
+description: 'Logs system events in the database.'
+package: Core
+# version: VERSION
+configure: system.logging_settings
+
+# Information added by Drupal.org packaging script on 2024-07-04
+version: '10.3.1'
+project: 'drupal'
+datestamp: 1720094222

core/modules/dblog/dblog.install

@@ -0,0 +1,135 @@
+<?php
+
+/**
+ * @file
+ * Install, update and uninstall functions for the dblog module.
+ */
+
+/**
+ * Implements hook_schema().
+ */
+function dblog_schema() {
+  $schema['watchdog'] = [
+    'description' => 'Table that contains logs of all system events.',
+    'fields' => [
+      'wid' => [
+        'type' => 'serial',
+        'not null' => TRUE,
+        'size' => 'big',
+        'description' => 'Primary Key: Unique watchdog event ID.',
+      ],
+      'uid' => [
+        'type' => 'int',
+        'unsigned' => TRUE,
+        'not null' => TRUE,
+        'default' => 0,
+        'description' => 'The {users}.uid of the user who triggered the event.',
+      ],
+      'type' => [
+        'type' => 'varchar_ascii',
+        'length' => 64,
+        'not null' => TRUE,
+        'default' => '',
+        'description' => 'Type of log message, for example "user" or "page not found."',
+      ],
+      'message' => [
+        'type' => 'text',
+        'not null' => TRUE,
+        'size' => 'big',
+        'description' => 'Text of log message to be passed into the t() function.',
+      ],
+      'variables' => [
+        'type' => 'blob',
+        'not null' => TRUE,
+        'size' => 'big',
+        'description' => 'Serialized array of variables that match the message string and that is passed into the t() function.',
+      ],
+      'severity' => [
+        'type' => 'int',
+        'unsigned' => TRUE,
+        'not null' => TRUE,
+        'default' => 0,
+        'size' => 'tiny',
+        'description' => 'The severity level of the event; ranges from 0 (Emergency) to 7 (Debug)',
+      ],
+      'link' => [
+        'type' => 'text',
+        'not null' => FALSE,
+        'description' => 'Link to view the result of the event.',
+      ],
+      'location'  => [
+        'type' => 'text',
+        'not null' => TRUE,
+        'description' => 'URL of the origin of the event.',
+      ],
+      'referer' => [
+        'type' => 'text',
+        'not null' => FALSE,
+        'description' => 'URL of referring page.',
+      ],
+      'hostname' => [
+        'type' => 'varchar_ascii',
+        'length' => 128,
+        'not null' => TRUE,
+        'default' => '',
+        'description' => 'Hostname of the user who triggered the event.',
+      ],
+      'timestamp' => [
+        'type' => 'int',
+        'not null' => TRUE,
+        'default' => 0,
+        'description' => 'Unix timestamp of when event occurred.',
+        'size' => 'big',
+      ],
+    ],
+    'primary key' => ['wid'],
+    'indexes' => [
+      'type' => ['type'],
+      'uid' => ['uid'],
+      'severity' => ['severity'],
+    ],
+  ];
+
+  return $schema;
+}
+
+/**
+ * Implements hook_update_last_removed().
+ */
+function dblog_update_last_removed() {
+  return 8600;
+}
+
+/**
+ * Remove the year 2038 date limitation.
+ */
+function dblog_update_10100(&$sandbox = NULL) {
+  $connection = \Drupal::database();
+  if ($connection->schema()->tableExists('watchdog') && $connection->databaseType() != 'sqlite') {
+    $new = [
+      'type' => 'int',
+      'not null' => TRUE,
+      'default' => 0,
+      'description' => 'Unix timestamp of when event occurred.',
+      'size' => 'big',
+    ];
+    $connection->schema()->changeField('watchdog', 'timestamp', 'timestamp', $new);
+  }
+}
+
+/**
+ * Converts the 'wid' of the 'watchdog' table to a big integer.
+ */
+function dblog_update_10101(&$sandbox = NULL) {
+  $connection = \Drupal::database();
+  if ($connection->databaseType() != 'sqlite') {
+    // Increase the size of the field.
+    $new_specification = [
+      'size' => 'big',
+      'type' => 'serial',
+      'not null' => TRUE,
+      'description' => 'Primary Key: Unique watchdog event ID.',
+    ];
+    $connection->schema()->changeField('watchdog', 'wid', 'wid', $new_specification);
+  }
+}

core/modules/dblog/dblog.libraries.yml

@@ -0,0 +1,5 @@
+drupal.dblog:
+  version: VERSION
+  css:
+    component:
+      css/dblog.module.css: {}

core/modules/dblog/dblog.links.menu.yml

@@ -0,0 +1,16 @@
+dblog.overview:
+  title: 'Recent log messages'
+  parent: system.admin_reports
+  description: 'View events that have recently been logged.'
+  route_name: dblog.overview
+  weight: -1
+dblog.page_not_found:
+  title: 'Top ''page not found'' errors'
+  route_name: dblog.page_not_found
+  parent: system.admin_reports
+  description: 'View ''page not found'' errors (404s).'
+dblog.access_denied:
+  title: 'Top ''access denied'' errors'
+  route_name: dblog.access_denied
+  description: 'View ''access denied'' errors (403s).'
+  parent: system.admin_reports

core/modules/dblog/dblog.links.task.yml

@@ -0,0 +1,8 @@
+dblog.view_logs:
+  title: 'View'
+  route_name: dblog.overview
+  base_route: dblog.overview
+dblog.clear_logs:
+  title: 'Delete'
+  route_name: dblog.confirm
+  base_route: dblog.overview

core/modules/dblog/dblog.module

@@ -0,0 +1,120 @@
+<?php
+
+/**
+ * @file
+ * System monitoring and logging for administrators.
+ *
+ * The Database Logging module monitors your site and keeps a list of recorded
+ * events containing usage and performance data, errors, warnings, and similar
+ * operational information.
+ */
+
+use Drupal\Core\Url;
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\Core\Routing\RouteMatchInterface;
+use Drupal\Core\StringTranslation\TranslatableMarkup;
+use Drupal\views\ViewExecutable;
+
+/**
+ * Implements hook_help().
+ */
+function dblog_help($route_name, RouteMatchInterface $route_match) {
+  switch ($route_name) {
+    case 'help.page.dblog':
+      $output = '';
+      $output .= '<h2>' . t('About') . '</h2>';
+      $output .= '<p>' . t('The Database Logging module logs system events in the Drupal database. For more information, see the <a href=":dblog">online documentation for the Database Logging module</a>.', [':dblog' => 'https://www.drupal.org/documentation/modules/dblog']) . '</p>';
+      $output .= '<h2>' . t('Uses') . '</h2>';
+      $output .= '<dl>';
+      $output .= '<dt>' . t('Monitoring your site') . '</dt>';
+      $output .= '<dd>' . t('The Database Logging module allows you to view an event log on the <a href=":dblog">Recent log messages</a> page. The log is a chronological list of recorded events containing usage data, performance data, errors, warnings and operational information. Administrators should check the log on a regular basis to ensure their site is working properly.', [':dblog' => Url::fromRoute('dblog.overview')->toString()]) . '</dd>';
+      $output .= '<dt>' . t('Debugging site problems') . '</dt>';
+      $output .= '<dd>' . t('In case of errors or problems with the site, the <a href=":dblog">Recent log messages</a> page can be useful for debugging, since it shows the sequence of events. The log messages include usage information, warnings, and errors.', [':dblog' => Url::fromRoute('dblog.overview')->toString()]) . '</dd>';
+      $output .= '<dt>' . t('This log is not persistent') . '</dt>';
+      $output .= '<dd>' . t('The Database Logging module logs may be cleared by administrators and automated cron tasks, so they should not be used for <a href=":audit_trail_wiki">forensic logging</a>. For forensic purposes, use the Syslog module.', [':audit_trail_wiki' => 'https://en.wikipedia.org/wiki/Audit_trail']) . '</dd>';
+      $output .= '</dl>';
+      return $output;
+
+    case 'dblog.overview':
+      return '<p>' . t('The Database Logging module logs system events in the Drupal database. Monitor your site or debug site problems on this page.') . '</p>';
+  }
+}
+
+/**
+ * Implements hook_menu_links_discovered_alter().
+ */
+function dblog_menu_links_discovered_alter(&$links) {
+  if (\Drupal::moduleHandler()->moduleExists('search')) {
+    $links['dblog.search'] = [
+      'title' => new TranslatableMarkup('Top search phrases'),
+      'route_name' => 'dblog.search',
+      'description' => new TranslatableMarkup('View most popular search phrases.'),
+      'parent' => 'system.admin_reports',
+    ];
+  }
+
+  return $links;
+}
+
+/**
+ * Implements hook_cron().
+ *
+ * Controls the size of the log table, paring it to 'dblog_row_limit' messages.
+ */
+function dblog_cron() {
+  // Cleanup the watchdog table.
+  $row_limit = \Drupal::config('dblog.settings')->get('row_limit');
+
+  // For row limit n, get the wid of the nth row in descending wid order.
+  // Counting the most recent n rows avoids issues with wid number sequences,
+  // e.g. auto_increment value > 1 or rows deleted directly from the table.
+  if ($row_limit > 0) {
+    $connection = \Drupal::database();
+    $min_row = $connection->select('watchdog', 'w')
+      ->fields('w', ['wid'])
+      ->orderBy('wid', 'DESC')
+      ->range($row_limit - 1, 1)
+      ->execute()->fetchField();
+
+    // Delete all table entries older than the nth row, if nth row was found.
+    if ($min_row) {
+      $connection->delete('watchdog')
+        ->condition('wid', $min_row, '<')
+        ->execute();
+    }
+  }
+}
+
+/**
+ * Gathers a list of uniquely defined database log message types.
+ *
+ * @return array
+ *   List of uniquely defined database log message types.
+ */
+function _dblog_get_message_types() {
+  return \Drupal::database()->query('SELECT DISTINCT([type]) FROM {watchdog} ORDER BY [type]')
+    ->fetchAllKeyed(0, 0);
+}
+
+/**
+ * Implements hook_form_FORM_ID_alter() for system_logging_settings().
+ */
+function dblog_form_system_logging_settings_alter(&$form, FormStateInterface $form_state) {
+  $row_limits = [100, 1000, 10000, 100000, 1000000];
+  $form['dblog_row_limit'] = [
+    '#type' => 'select',
+    '#title' => t('Database log messages to keep'),
+    '#config_target' => 'dblog.settings:row_limit',
+    '#options' => [0 => t('All')] + array_combine($row_limits, $row_limits),
+    '#description' => t('The maximum number of messages to keep in the database log. Requires a <a href=":cron">cron maintenance task</a>.', [':cron' => Url::fromRoute('system.status')->toString()]),
+  ];
+}
+
+/**
+ * Implements hook_views_pre_render().
+ */
+function dblog_views_pre_render(ViewExecutable $view) {
+  if (isset($view) && ($view->storage->get('base_table') == 'watchdog')) {
+    $view->element['#attached']['library'][] = 'dblog/drupal.dblog';
+  }
+}

core/modules/dblog/dblog.post_update.php

@@ -0,0 +1,15 @@
+<?php
+
+/**
+ * @file
+ * Post update functions for the Database Logging module.
+ */
+
+/**
+ * Implements hook_removed_post_updates().
+ */
+function dblog_removed_post_updates() {
+  return [
+    'dblog_post_update_convert_recent_messages_to_view' => '9.0.0',
+  ];
+}

core/modules/dblog/dblog.routing.yml

@@ -0,0 +1,51 @@
+dblog.overview:
+  path: '/admin/reports/dblog'
+  defaults:
+    _controller: '\Drupal\dblog\Controller\DbLogController::overview'
+    _title: 'Recent log messages'
+  requirements:
+    _permission: 'access site reports'
+
+dblog.confirm:
+  path: '/admin/reports/dblog/confirm'
+  defaults:
+    _form: '\Drupal\dblog\Form\DblogClearLogConfirmForm'
+    _title: 'Confirm delete recent log messages'
+  requirements:
+    _permission: 'access site reports'
+
+dblog.event:
+  path: '/admin/reports/dblog/event/{event_id}'
+  defaults:
+    _controller: '\Drupal\dblog\Controller\DbLogController::eventDetails'
+    _title: 'Details'
+  requirements:
+    _permission: 'access site reports'
+
+dblog.page_not_found:
+  path: '/admin/reports/page-not-found'
+  defaults:
+    _title: "Top 'page not found' errors"
+    _controller: '\Drupal\dblog\Controller\DbLogController::topLogMessages'
+    type: 'page not found'
+  requirements:
+    _permission: 'access site reports'
+
+dblog.access_denied:
+  path: '/admin/reports/access-denied'
+  defaults:
+    _title: "Top 'access denied' errors"
+    _controller: '\Drupal\dblog\Controller\DbLogController::topLogMessages'
+    type: 'access denied'
+  requirements:
+    _permission: 'access site reports'
+
+dblog.search:
+  path: '/admin/reports/search'
+  defaults:
+    _controller: '\Drupal\dblog\Controller\DbLogController::topLogMessages'
+    _title: 'Top search phrases'
+    type: 'search'
+  requirements:
+    _module_dependencies: 'search'
+    _permission: 'access site reports'

core/modules/dblog/dblog.services.yml

@@ -0,0 +1,7 @@
+services:
+  logger.dblog:
+    class: Drupal\dblog\Logger\DbLog
+    arguments: ['@database', '@logger.log_message_parser']
+    tags:
+      - { name: logger }
+      - { name: backend_overridable }

core/modules/dblog/dblog.views.inc

@@ -0,0 +1,215 @@
+<?php
+
+/**
+ * @file
+ * Provide views data for dblog.module.
+ */
+
+/**
+ * Implements hook_views_data().
+ */
+function dblog_views_data() {
+  $data = [];
+
+  $data['watchdog']['table']['group'] = t('Watchdog');
+  $data['watchdog']['table']['wizard_id'] = 'watchdog';
+
+  $data['watchdog']['table']['base'] = [
+    'field' => 'wid',
+    'title' => t('Log entries'),
+    'help' => t('Contains a list of log entries.'),
+  ];
+
+  $data['watchdog']['wid'] = [
+    'title' => t('WID'),
+    'help' => t('Unique watchdog event ID.'),
+    'field' => [
+      'id' => 'standard',
+    ],
+    'filter' => [
+      'id' => 'numeric',
+    ],
+    'argument' => [
+      'id' => 'numeric',
+    ],
+    'sort' => [
+      'id' => 'standard',
+    ],
+  ];
+
+  $data['watchdog']['uid'] = [
+    'title' => t('UID'),
+    'help' => t('The user ID of the user on which the log entry was written.'),
+    'field' => [
+      'id' => 'standard',
+    ],
+    'filter' => [
+      'id' => 'numeric',
+    ],
+    'argument' => [
+      'id' => 'numeric',
+    ],
+    'relationship' => [
+      'title' => t('User'),
+      'help' => t('The user on which the log entry as written.'),
+      'base' => 'users_field_data',
+      'base field' => 'uid',
+      'id' => 'standard',
+    ],
+  ];
+
+  $data['watchdog']['type'] = [
+    'title' => t('Type'),
+    'help' => t('The type of the log entry, for example "user" or "page not found".'),
+    'field' => [
+      'id' => 'standard',
+    ],
+    'argument' => [
+      'id' => 'string',
+    ],
+    'filter' => [
+      'id' => 'dblog_types',
+    ],
+    'sort' => [
+      'id' => 'standard',
+    ],
+  ];
+
+  $data['watchdog']['message'] = [
+    'title' => t('Message'),
+    'help' => t('The actual message of the log entry.'),
+    'field' => [
+      'id' => 'dblog_message',
+    ],
+    'argument' => [
+      'id' => 'string',
+    ],
+    'filter' => [
+      'id' => 'string',
+    ],
+    'sort' => [
+      'id' => 'standard',
+    ],
+  ];
+
+  $data['watchdog']['variables'] = [
+    'title' => t('Variables'),
+    'help' => t('The variables of the log entry in a serialized format.'),
+    'field' => [
+      'id' => 'serialized',
+      'click sortable' => FALSE,
+    ],
+    'argument' => [
+      'id' => 'string',
+    ],
+    'filter' => [
+      'id' => 'string',
+    ],
+    'sort' => [
+      'id' => 'standard',
+    ],
+  ];
+
+  $data['watchdog']['severity'] = [
+    'title' => t('Severity level'),
+    'help' => t('The severity level of the event; ranges from 0 (Emergency) to 7 (Debug).'),
+    'field' => [
+      'id' => 'machine_name',
+      'options callback' => 'Drupal\dblog\Controller\DbLogController::getLogLevelClassMap',
+    ],
+    'filter' => [
+      'id' => 'in_operator',
+      'options callback' => 'Drupal\Core\Logger\RfcLogLevel::getLevels',
+    ],
+    'sort' => [
+      'id' => 'standard',
+    ],
+  ];
+
+  $data['watchdog']['link'] = [
+    'title' => t('Operations'),
+    'help' => t('Operation links for the event.'),
+    'field' => [
+      'id' => 'dblog_operations',
+    ],
+    'argument' => [
+      'id' => 'string',
+    ],
+    'filter' => [
+      'id' => 'string',
+    ],
+    'sort' => [
+      'id' => 'standard',
+    ],
+  ];
+
+  $data['watchdog']['location'] = [
+    'title' => t('Location'),
+    'help' => t('URL of the origin of the event.'),
+    'field' => [
+      'id' => 'standard',
+    ],
+    'argument' => [
+      'id' => 'string',
+    ],
+    'filter' => [
+      'id' => 'string',
+    ],
+    'sort' => [
+      'id' => 'standard',
+    ],
+  ];
+
+  $data['watchdog']['referer'] = [
+    'title' => t('Referer'),
+    'help' => t('URL of the previous page.'),
+    'field' => [
+      'id' => 'standard',
+    ],
+    'argument' => [
+      'id' => 'string',
+    ],
+    'filter' => [
+      'id' => 'string',
+    ],
+    'sort' => [
+      'id' => 'standard',
+    ],
+  ];
+
+  $data['watchdog']['hostname'] = [
+    'title' => t('Hostname'),
+    'help' => t('Hostname of the user who triggered the event.'),
+    'field' => [
+      'id' => 'standard',
+    ],
+    'argument' => [
+      'id' => 'string',
+    ],
+    'filter' => [
+      'id' => 'string',
+    ],
+    'sort' => [
+      'id' => 'standard',
+    ],
+  ];
+
+  $data['watchdog']['timestamp'] = [
+    'title' => t('Timestamp'),
+    'help' => t('Date when the event occurred.'),
+    'field' => [
+      'id' => 'date',
+    ],
+    'argument' => [
+      'id' => 'date',
+    ],
+    'filter' => [
+      'id' => 'date',
+    ],
+    'sort' => [
+      'id' => 'date',
+    ],
+  ];
+
+  return $data;
+}

core/modules/dblog/migrations/d6_dblog_settings.yml

@@ -0,0 +1,15 @@
+id: d6_dblog_settings
+label: Database logging configuration
+migration_tags:
+  - Drupal 6
+  - Configuration
+source:
+  plugin: variable
+  variables:
+    - dblog_row_limit
+  source_module: dblog
+process:
+  row_limit: dblog_row_limit
+destination:
+  plugin: config
+  config_name: dblog.settings

core/modules/dblog/migrations/d7_dblog_settings.yml

@@ -0,0 +1,15 @@
+id: d7_dblog_settings
+label: Database logging configuration
+migration_tags:
+  - Drupal 7
+  - Configuration
+source:
+  plugin: variable
+  variables:
+    - dblog_row_limit
+  source_module: dblog
+process:
+  row_limit: dblog_row_limit
+destination:
+  plugin: config
+  config_name: dblog.settings

core/modules/dblog/migrations/state/dblog.migrate_drupal.yml

@@ -0,0 +1,5 @@
+finished:
+  6:
+    dblog: dblog
+  7:
+    dblog: dblog

core/modules/dblog/src/Controller/DbLogController.php

@@ -0,0 +1,461 @@
+<?php
+
+namespace Drupal\dblog\Controller;
+
+use Drupal\Component\Render\FormattableMarkup;
+use Drupal\Component\Utility\Html;
+use Drupal\Component\Utility\Unicode;
+use Drupal\Component\Utility\Xss;
+use Drupal\Component\Utility\UrlHelper;
+use Drupal\Core\Controller\ControllerBase;
+use Drupal\Core\Database\Connection;
+use Drupal\Core\Database\Query\PagerSelectExtender;
+use Drupal\Core\Database\Query\TableSortExtender;
+use Drupal\Core\Datetime\DateFormatterInterface;
+use Drupal\Core\Extension\ModuleHandlerInterface;
+use Drupal\Core\Form\FormBuilderInterface;
+use Drupal\Core\Logger\RfcLogLevel;
+use Drupal\Core\Url;
+use Drupal\user\Entity\User;
+use Symfony\Component\HttpFoundation\Request;
+use Drupal\Core\Link;
+use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
+
+/**
+ * Returns responses for dblog routes.
+ */
+class DbLogController extends ControllerBase {
+
+  /**
+   * The database service.
+   *
+   * @var \Drupal\Core\Database\Connection
+   */
+  protected $database;
+
+  /**
+   * The date formatter service.
+   *
+   * @var \Drupal\Core\Datetime\DateFormatterInterface
+   */
+  protected $dateFormatter;
+
+  /**
+   * The user storage.
+   *
+   * @var \Drupal\user\UserStorageInterface
+   */
+  protected $userStorage;
+
+  /**
+   * Constructs a DbLogController object.
+   *
+   * @param \Drupal\Core\Database\Connection $database
+   *   A database connection.
+   * @param \Drupal\Core\Extension\ModuleHandlerInterface $module_handler
+   *   A module handler.
+   * @param \Drupal\Core\Datetime\DateFormatterInterface $date_formatter
+   *   The date formatter service.
+   * @param \Drupal\Core\Form\FormBuilderInterface $form_builder
+   *   The form builder service.
+   */
+  public function __construct(Connection $database, ModuleHandlerInterface $module_handler, DateFormatterInterface $date_formatter, FormBuilderInterface $form_builder) {
+    $this->database = $database;
+    $this->moduleHandler = $module_handler;
+    $this->dateFormatter = $date_formatter;
+    $this->formBuilder = $form_builder;
+    $this->userStorage = $this->entityTypeManager()->getStorage('user');
+  }
+
+  /**
+   * Gets an array of log level classes.
+   *
+   * @return array
+   *   An array of log level classes.
+   */
+  public static function getLogLevelClassMap() {
+    return [
+      RfcLogLevel::DEBUG => 'dblog-debug',
+      RfcLogLevel::INFO => 'dblog-info',
+      RfcLogLevel::NOTICE => 'dblog-notice',
+      RfcLogLevel::WARNING => 'dblog-warning',
+      RfcLogLevel::ERROR => 'dblog-error',
+      RfcLogLevel::CRITICAL => 'dblog-critical',
+      RfcLogLevel::ALERT => 'dblog-alert',
+      RfcLogLevel::EMERGENCY => 'dblog-emergency',
+    ];
+  }
+
+  /**
+   * Displays a listing of database log messages.
+   *
+   * Messages are truncated at 56 chars.
+   * Full-length messages can be viewed on the message details page.
+   *
+   * @param \Symfony\Component\HttpFoundation\Request $request
+   *   The request.
+   *
+   * @return array
+   *   A render array as expected by
+   *   \Drupal\Core\Render\RendererInterface::render().
+   *
+   * @see Drupal\dblog\Form\DblogClearLogConfirmForm
+   * @see Drupal\dblog\Controller\DbLogController::eventDetails()
+   */
+  public function overview(Request $request) {
+
+    $filter = $this->buildFilterQuery($request);
+    $rows = [];
+
+    $classes = static::getLogLevelClassMap();
+
+    $this->moduleHandler()->loadInclude('dblog', 'admin.inc');
+
+    $build['dblog_filter_form'] = $this->formBuilder()->getForm('Drupal\dblog\Form\DblogFilterForm');
+
+    $header = [
+      // Icon column.
+      '',
+      [
+        'data' => $this->t('Type'),
+        'field' => 'w.type',
+        'class' => [RESPONSIVE_PRIORITY_MEDIUM],
+      ],
+      [
+        'data' => $this->t('Date'),
+        'field' => 'w.wid',
+        'sort' => 'desc',
+        'class' => [RESPONSIVE_PRIORITY_LOW],
+      ],
+      $this->t('Message'),
+      [
+        'data' => $this->t('User'),
+        'field' => 'ufd.name',
+        'class' => [RESPONSIVE_PRIORITY_MEDIUM],
+      ],
+      [
+        'data' => $this->t('Operations'),
+        'class' => [RESPONSIVE_PRIORITY_LOW],
+      ],
+    ];
+
+    $query = $this->database->select('watchdog', 'w')
+      ->extend(PagerSelectExtender::class)
+      ->extend(TableSortExtender::class);
+    $query->fields('w', [
+      'wid',
+      'uid',
+      'severity',
+      'type',
+      'timestamp',
+      'message',
+      'variables',
+      'link',
+    ]);
+    $query->leftJoin('users_field_data', 'ufd', '[w].[uid] = [ufd].[uid]');
+
+    if (!empty($filter['where'])) {
+      $query->where($filter['where'], $filter['args']);
+    }
+    $result = $query
+      ->limit(50)
+      ->orderByHeader($header)
+      ->execute();
+
+    foreach ($result as $dblog) {
+      $message = $this->formatMessage($dblog);
+      if ($message && isset($dblog->wid)) {
+        $title = Unicode::truncate(Html::decodeEntities(strip_tags($message)), 256, TRUE, TRUE);
+        $log_text = Unicode::truncate($title, 56, TRUE, TRUE);
+        // The link generator will escape any unsafe HTML entities in the final
+        // text.
+        $message = Link::fromTextAndUrl($log_text, new Url('dblog.event', ['event_id' => $dblog->wid], [
+          'attributes' => [
+            // Provide a title for the link for useful hover hints. The
+            // Attribute object will escape any unsafe HTML entities in the
+            // final text.
+            'title' => $title,
+          ],
+        ]))->toString();
+      }
+      $username = [
+        '#theme' => 'username',
+        '#account' => $this->userStorage->load($dblog->uid),
+      ];
+      $rows[] = [
+        'data' => [
+          // Cells.
+          ['class' => ['icon']],
+          $this->t($dblog->type),
+          $this->dateFormatter->format($dblog->timestamp, 'short'),
+          $message,
+          ['data' => $username],
+          ['data' => ['#markup' => $dblog->link]],
+        ],
+        // Attributes for table row.
+        'class' => [Html::getClass('dblog-' . $dblog->type), $classes[$dblog->severity]],
+      ];
+    }
+
+    $build['dblog_table'] = [
+      '#type' => 'table',
+      '#header' => $header,
+      '#rows' => $rows,
+      '#attributes' => ['id' => 'admin-dblog', 'class' => ['admin-dblog']],
+      '#empty' => $this->t('No log messages available.'),
+      '#attached' => [
+        'library' => ['dblog/drupal.dblog'],
+      ],
+    ];
+    $build['dblog_pager'] = ['#type' => 'pager'];
+
+    return $build;
+
+  }
+
+  /**
+   * Displays details about a specific database log message.
+   *
+   * @param int $event_id
+   *   Unique ID of the database log message.
+   *
+   * @return array
+   *   If the ID is located in the Database Logging table, a build array in the
+   *   format expected by \Drupal\Core\Render\RendererInterface::render().
+   *
+   * @throws \Symfony\Component\HttpKernel\Exception\NotFoundHttpException
+   *   If no event found for the given ID.
+   */
+  public function eventDetails($event_id) {
+    $dblog = $this->database->query('SELECT [w].*, [u].[uid] FROM {watchdog} [w] LEFT JOIN {users} [u] ON [u].[uid] = [w].[uid] WHERE [w].[wid] = :id', [':id' => $event_id])->fetchObject();
+
+    if (empty($dblog)) {
+      throw new NotFoundHttpException();
+    }
+
+    $build = [];
+    $severity = RfcLogLevel::getLevels();
+    $message = $this->formatMessage($dblog);
+    $username = [
+      '#theme' => 'username',
+      '#account' => $dblog->uid ? $this->userStorage->load($dblog->uid) : User::getAnonymousUser(),
+    ];
+    $rows = [
+      [
+        ['data' => $this->t('Type'), 'header' => TRUE],
+        $this->t($dblog->type),
+      ],
+      [
+        ['data' => $this->t('Date'), 'header' => TRUE],
+        $this->dateFormatter->format($dblog->timestamp, 'long'),
+      ],
+      [
+        ['data' => $this->t('User'), 'header' => TRUE],
+        ['data' => $username],
+      ],
+      [
+        ['data' => $this->t('Location'), 'header' => TRUE],
+        $this->createLink($dblog->location),
+      ],
+      [
+        ['data' => $this->t('Referrer'), 'header' => TRUE],
+        $this->createLink($dblog->referer),
+      ],
+      [
+        ['data' => $this->t('Message'), 'header' => TRUE],
+        $message,
+      ],
+      [
+        ['data' => $this->t('Severity'), 'header' => TRUE],
+        $severity[$dblog->severity],
+      ],
+      [
+        ['data' => $this->t('Hostname'), 'header' => TRUE],
+        $dblog->hostname,
+      ],
+      [
+        ['data' => $this->t('Operations'), 'header' => TRUE],
+        ['data' => ['#markup' => $dblog->link]],
+      ],
+    ];
+    if (isset($dblog->backtrace)) {
+      $rows[] = [
+        ['data' => $this->t('Backtrace'), 'header' => TRUE],
+        $dblog->backtrace,
+      ];
+    }
+    $build['dblog_table'] = [
+      '#type' => 'table',
+      '#rows' => $rows,
+      '#attributes' => ['class' => ['dblog-event']],
+      '#attached' => [
+        'library' => ['dblog/drupal.dblog'],
+      ],
+    ];
+
+    return $build;
+  }
+
+  /**
+   * Builds a query for database log administration filters based on session.
+   *
+   * @param \Symfony\Component\HttpFoundation\Request $request
+   *   The request.
+   *
+   * @return array|null
+   *   An associative array with keys 'where' and 'args' or NULL if there were
+   *   no filters set.
+   */
+  protected function buildFilterQuery(Request $request) {
+    $session_filters = $request->getSession()->get('dblog_overview_filter', []);
+    if (empty($session_filters)) {
+      return;
+    }
+
+    $this->moduleHandler()->loadInclude('dblog', 'admin.inc');
+
+    $filters = dblog_filters();
+
+    // Build query.
+    $where = $args = [];
+    foreach ($session_filters as $key => $filter) {
+      $filter_where = [];
+      foreach ($filter as $value) {
+        $filter_where[] = $filters[$key]['where'];
+        $args[] = $value;
+      }
+      if (!empty($filter_where)) {
+        $where[] = '(' . implode(' OR ', $filter_where) . ')';
+      }
+    }
+    $where = !empty($where) ? implode(' AND ', $where) : '';
+
+    return [
+      'where' => $where,
+      'args' => $args,
+    ];
+  }
+
+  /**
+   * Formats a database log message.
+   *
+   * @param object $row
+   *   The record from the watchdog table. The object properties are: wid, uid,
+   *   severity, type, timestamp, message, variables, link, name.
+   *
+   *   If the variables contain a @backtrace_string placeholder which is not
+   *   used in the message, the formatted backtrace will be assigned to a new
+   *   backtrace property on the row object which can be displayed separately.
+   *
+   * @return string|\Drupal\Core\StringTranslation\TranslatableMarkup|false
+   *   The formatted log message or FALSE if the message or variables properties
+   *   are not set.
+   */
+  public function formatMessage($row) {
+    // Check for required properties.
+    if (isset($row->message, $row->variables)) {
+      $variables = @unserialize($row->variables);
+      // Messages without variables or user specified text.
+      if ($variables === NULL) {
+        $message = Xss::filterAdmin($row->message);
+      }
+      elseif (!is_array($variables)) {
+        $message = $this->t('Log data is corrupted and cannot be unserialized: @message', ['@message' => Xss::filterAdmin($row->message)]);
+      }
+      // Message to translate with injected variables.
+      else {
+        // Ensure backtrace strings are properly formatted.
+        if (isset($variables['@backtrace_string'])) {
+          $variables['@backtrace_string'] = new FormattableMarkup(
+            '<pre class="backtrace">@backtrace_string</pre>', $variables
+          );
+          // Save a reference so the backtrace can be displayed separately.
+          if (!str_contains($row->message, '@backtrace_string')) {
+            $row->backtrace = $variables['@backtrace_string'];
+          }
+        }
+        $message = $this->t(Xss::filterAdmin($row->message), $variables);
+      }
+    }
+    else {
+      $message = FALSE;
+    }
+    return $message;
+  }
+
+  /**
+   * Creates a Link object if the provided URI is valid.
+   *
+   * @param string|null $uri
+   *   The uri string to convert into link if valid.
+   *
+   * @return \Drupal\Core\Link|string|null
+   *   Return a Link object if the uri can be converted as a link. In case of
+   *   empty uri or invalid, fallback to the provided $uri.
+   */
+  protected function createLink($uri) {
+    if ($uri !== NULL && UrlHelper::isValid($uri, TRUE)) {
+      return new Link($uri, Url::fromUri($uri));
+    }
+    return $uri;
+  }
+
+  /**
+   * Shows the most frequent log messages of a given event type.
+   *
+   * Messages are not truncated on this page because events detailed herein do
+   * not have links to a detailed view.
+   *
+   * @param string $type
+   *   Type of database log events to display (e.g., 'search').
+   *
+   * @return array
+   *   A build array in the format expected by
+   *   \Drupal\Core\Render\RendererInterface::render().
+   */
+  public function topLogMessages($type) {
+    $header = [
+      ['data' => $this->t('Count'), 'field' => 'count', 'sort' => 'desc'],
+      ['data' => $this->t('Message'), 'field' => 'message'],
+    ];
+
+    $count_query = $this->database->select('watchdog');
+    $count_query->addExpression('COUNT(DISTINCT([message]))');
+    $count_query->condition('type', $type);
+
+    $query = $this->database->select('watchdog', 'w')
+      ->extend(PagerSelectExtender::class)
+      ->extend(TableSortExtender::class);
+    $query->addExpression('COUNT([wid])', 'count');
+    $query = $query
+      ->fields('w', ['message', 'variables'])
+      ->condition('w.type', $type)
+      ->groupBy('message')
+      ->groupBy('variables')
+      ->limit(30)
+      ->orderByHeader($header);
+    $query->setCountQuery($count_query);
+    $result = $query->execute();
+
+    $rows = [];
+    foreach ($result as $dblog) {
+      if ($message = $this->formatMessage($dblog)) {
+        $rows[] = [$dblog->count, $message];
+      }
+    }
+
+    $build['dblog_top_table'] = [
+      '#type' => 'table',
+      '#header' => $header,
+      '#rows' => $rows,
+      '#empty' => $this->t('No log messages available.'),
+      '#attached' => [
+        'library' => ['dblog/drupal.dblog'],
+      ],
+    ];
+    $build['dblog_top_pager'] = ['#type' => 'pager'];
+
+    return $build;
+  }
+
+}

core/modules/dblog/src/Form/DblogClearLogConfirmForm.php

@@ -0,0 +1,75 @@
+<?php
+
+namespace Drupal\dblog\Form;
+
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\Core\Url;
+use Drupal\Core\Database\Connection;
+use Drupal\Core\Form\ConfirmFormBase;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * Provides a confirmation form before clearing out the logs.
+ *
+ * @internal
+ */
+class DblogClearLogConfirmForm extends ConfirmFormBase {
+
+  /**
+   * The database connection.
+   *
+   * @var \Drupal\Core\Database\Connection
+   */
+  protected $connection;
+
+  /**
+   * Constructs a new DblogClearLogConfirmForm.
+   *
+   * @param \Drupal\Core\Database\Connection $connection
+   *   The database connection.
+   */
+  public function __construct(Connection $connection) {
+    $this->connection = $connection;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function create(ContainerInterface $container) {
+    return new static(
+      $container->get('database')
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getFormId() {
+    return 'dblog_confirm';
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getQuestion() {
+    return $this->t('Are you sure you want to delete the recent logs?');
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getCancelUrl() {
+    return new Url('dblog.overview');
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function submitForm(array &$form, FormStateInterface $form_state) {
+    $this->getRequest()->getSession()->remove('dblog_overview_filter');
+    $this->connection->truncate('watchdog')->execute();
+    $this->messenger()->addStatus($this->t('Database log cleared.'));
+    $form_state->setRedirectUrl($this->getCancelUrl());
+  }
+
+}

core/modules/dblog/src/Form/DblogFilterForm.php

@@ -0,0 +1,102 @@
+<?php
+
+namespace Drupal\dblog\Form;
+
+use Drupal\Core\Form\FormBase;
+use Drupal\Core\Form\FormStateInterface;
+
+/**
+ * Provides the database logging filter form.
+ *
+ * @internal
+ */
+class DblogFilterForm extends FormBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getFormId() {
+    return 'dblog_filter_form';
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function buildForm(array $form, FormStateInterface $form_state) {
+    $filters = dblog_filters();
+
+    $form['filters'] = [
+      '#type' => 'details',
+      '#title' => $this->t('Filter log messages'),
+      '#open' => TRUE,
+    ];
+    $session_filters = $this->getRequest()->getSession()->get('dblog_overview_filter', []);
+    foreach ($filters as $key => $filter) {
+      $form['filters']['status'][$key] = [
+        '#title' => $filter['title'],
+        '#type' => 'select',
+        '#multiple' => TRUE,
+        '#size' => 8,
+        '#options' => $filter['options'],
+      ];
+
+      if (!empty($session_filters[$key])) {
+        $form['filters']['status'][$key]['#default_value'] = $session_filters[$key];
+      }
+    }
+
+    $form['filters']['actions'] = [
+      '#type' => 'actions',
+      '#attributes' => ['class' => ['container-inline']],
+    ];
+    $form['filters']['actions']['submit'] = [
+      '#type' => 'submit',
+      '#value' => $this->t('Filter'),
+    ];
+    if (!empty($session_filters)) {
+      $form['filters']['actions']['reset'] = [
+        '#type' => 'submit',
+        '#value' => $this->t('Reset'),
+        '#limit_validation_errors' => [],
+        '#submit' => ['::resetForm'],
+      ];
+    }
+    return $form;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function validateForm(array &$form, FormStateInterface $form_state) {
+    if ($form_state->isValueEmpty('type') && $form_state->isValueEmpty('severity')) {
+      $form_state->setErrorByName('type', $this->t('You must select something to filter by.'));
+    }
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function submitForm(array &$form, FormStateInterface $form_state) {
+    $filters = dblog_filters();
+    $session_filters = $this->getRequest()->getSession()->get('dblog_overview_filter', []);
+    foreach ($filters as $name => $filter) {
+      if ($form_state->hasValue($name)) {
+        $session_filters[$name] = $form_state->getValue($name);
+      }
+    }
+    $this->getRequest()->getSession()->set('dblog_overview_filter', $session_filters);
+  }
+
+  /**
+   * Resets the filter form.
+   *
+   * @param array $form
+   *   An associative array containing the structure of the form.
+   * @param \Drupal\Core\Form\FormStateInterface $form_state
+   *   The current state of the form.
+   */
+  public function resetForm(array &$form, FormStateInterface $form_state) {
+    $this->getRequest()->getSession()->remove('dblog_overview_filter');
+  }
+
+}

core/modules/dblog/src/Logger/DbLog.php

@@ -0,0 +1,111 @@
+<?php
+
+namespace Drupal\dblog\Logger;
+
+use Drupal\Core\Database\Connection;
+use Drupal\Core\Database\Database;
+use Drupal\Core\Database\DatabaseException;
+use Drupal\Core\DependencyInjection\DependencySerializationTrait;
+use Drupal\Core\Logger\LogMessageParserInterface;
+use Drupal\Core\Logger\RfcLoggerTrait;
+use Psr\Log\LoggerInterface;
+
+/**
+ * Logs events in the watchdog database table.
+ */
+class DbLog implements LoggerInterface {
+  use RfcLoggerTrait;
+  use DependencySerializationTrait;
+
+  /**
+   * The dedicated database connection target to use for log entries.
+   */
+  const DEDICATED_DBLOG_CONNECTION_TARGET = 'dedicated_dblog';
+
+  /**
+   * The database connection object.
+   *
+   * @var \Drupal\Core\Database\Connection
+   */
+  protected $connection;
+
+  /**
+   * The message's placeholders parser.
+   *
+   * @var \Drupal\Core\Logger\LogMessageParserInterface
+   */
+  protected $parser;
+
+  /**
+   * Constructs a DbLog object.
+   *
+   * @param \Drupal\Core\Database\Connection $connection
+   *   The database connection object.
+   * @param \Drupal\Core\Logger\LogMessageParserInterface $parser
+   *   The parser to use when extracting message variables.
+   */
+  public function __construct(Connection $connection, LogMessageParserInterface $parser) {
+    $this->connection = $connection;
+    $this->parser = $parser;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function log($level, string|\Stringable $message, array $context = []): void {
+    // Remove backtrace and exception since they may contain an unserializable variable.
+    unset($context['backtrace'], $context['exception']);
+
+    // Convert PSR3-style messages to \Drupal\Component\Render\FormattableMarkup
+    // style, so they can be translated too in runtime.
+    $message_placeholders = $this->parser->parseMessagePlaceholders($message, $context);
+
+    try {
+      $this->connection
+        ->insert('watchdog')
+        ->fields([
+          'uid' => $context['uid'],
+          'type' => mb_substr($context['channel'], 0, 64),
+          'message' => $message,
+          'variables' => serialize($message_placeholders),
+          'severity' => $level,
+          'link' => $context['link'],
+          'location' => $context['request_uri'],
+          'referer' => $context['referer'],
+          'hostname' => mb_substr($context['ip'], 0, 128),
+          'timestamp' => $context['timestamp'],
+        ])
+        ->execute();
+    }
+    catch (\Exception $e) {
+      // When running Drupal on MySQL or MariaDB you can run into several errors
+      // that corrupt the database connection. Some examples for these kind of
+      // errors on the database layer are "1100 - Table 'xyz' was not locked
+      // with LOCK TABLES" and "1153 - Got a packet bigger than
+      // 'max_allowed_packet' bytes". If such an error happens, the MySQL server
+      // invalidates the connection and answers all further requests in this
+      // connection with "2006 - MySQL server had gone away". In that case the
+      // insert statement above results in a database exception. To ensure that
+      // the causal error is written to the log we try once to open a dedicated
+      // connection and write again.
+      if (
+        // Only handle database related exceptions.
+        ($e instanceof DatabaseException || $e instanceof \PDOException) &&
+        // Avoid an endless loop of re-write attempts.
+        $this->connection->getTarget() != self::DEDICATED_DBLOG_CONNECTION_TARGET
+      ) {
+        // Open a dedicated connection for logging.
+        $key = $this->connection->getKey();
+        $info = Database::getConnectionInfo($key);
+        Database::addConnectionInfo($key, self::DEDICATED_DBLOG_CONNECTION_TARGET, $info['default']);
+        $this->connection = Database::getConnection(self::DEDICATED_DBLOG_CONNECTION_TARGET, $key);
+        // Now try once to log the error again.
+        $this->log($level, $message, $context);
+      }
+      else {
+        throw $e;
+      }
+    }
+  }
+
+}

core/modules/dblog/src/Plugin/rest/resource/DbLogResource.php

@@ -0,0 +1,55 @@
+<?php
+
+namespace Drupal\dblog\Plugin\rest\resource;
+
+use Drupal\Core\Database\Database;
+use Drupal\Core\StringTranslation\TranslatableMarkup;
+use Drupal\rest\Attribute\RestResource;
+use Drupal\rest\Plugin\ResourceBase;
+use Drupal\rest\ResourceResponse;
+use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
+use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
+
+/**
+ * Provides a resource for database watchdog log entries.
+ */
+#[RestResource(
+  id: "dblog",
+  label: new TranslatableMarkup("Watchdog database log"),
+  uri_paths: [
+    "canonical" => "/dblog/{id}",
+  ]
+)]
+class DbLogResource extends ResourceBase {
+
+  /**
+   * Responds to GET requests.
+   *
+   * Returns a watchdog log entry for the specified ID.
+   *
+   * @param int $id
+   *   The ID of the watchdog log entry.
+   *
+   * @return \Drupal\rest\ResourceResponse
+   *   The response containing the log entry.
+   *
+   * @throws \Symfony\Component\HttpKernel\Exception\NotFoundHttpException
+   *   Thrown when the log entry was not found.
+   * @throws \Symfony\Component\HttpKernel\Exception\BadRequestHttpException
+   *   Thrown when no log entry was provided.
+   */
+  public function get($id = NULL) {
+    if ($id) {
+      $record = Database::getConnection()->query("SELECT * FROM {watchdog} WHERE [wid] = :wid", [':wid' => $id])
+        ->fetchAssoc();
+      if (!empty($record)) {
+        return new ResourceResponse($record);
+      }
+
+      throw new NotFoundHttpException("Log entry with ID '$id' was not found");
+    }
+
+    throw new BadRequestHttpException('No log entry ID was provided');
+  }
+
+}

core/modules/dblog/src/Plugin/views/field/DblogMessage.php

@@ -0,0 +1,70 @@
+<?php
+
+namespace Drupal\dblog\Plugin\views\field;
+
+use Drupal\Component\Render\FormattableMarkup;
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\views\Attribute\ViewsField;
+use Drupal\views\Plugin\views\field\FieldPluginBase;
+use Drupal\views\ResultRow;
+use Drupal\views\ViewExecutable;
+use Drupal\views\Plugin\views\display\DisplayPluginBase;
+
+/**
+ * Provides a field handler that renders a log event with replaced variables.
+ *
+ * @ingroup views_field_handlers
+ */
+#[ViewsField("dblog_message")]
+class DblogMessage extends FieldPluginBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function init(ViewExecutable $view, DisplayPluginBase $display, ?array &$options = NULL) {
+    parent::init($view, $display, $options);
+
+    if ($this->options['replace_variables']) {
+      $this->additional_fields['variables'] = 'variables';
+    }
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function defineOptions() {
+    $options = parent::defineOptions();
+    $options['replace_variables'] = ['default' => TRUE];
+
+    return $options;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function buildOptionsForm(&$form, FormStateInterface $form_state) {
+    parent::buildOptionsForm($form, $form_state);
+
+    $form['replace_variables'] = [
+      '#title' => $this->t('Replace variables'),
+      '#type' => 'checkbox',
+      '#default_value' => $this->options['replace_variables'],
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function render(ResultRow $values) {
+    $value = $this->getValue($values);
+
+    if ($this->options['replace_variables']) {
+      $variables = unserialize($this->getvalue($values, 'variables'));
+      return new FormattableMarkup($value, (array) $variables);
+    }
+    else {
+      return $this->sanitizeValue($value);
+    }
+  }
+
+}

core/modules/dblog/src/Plugin/views/field/DblogOperations.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace Drupal\dblog\Plugin\views\field;
+
+use Drupal\views\Attribute\ViewsField;
+use Drupal\views\Plugin\views\field\FieldPluginBase;
+use Drupal\views\ResultRow;
+
+/**
+ * Provides a field handler that renders operation link markup.
+ *
+ * @ingroup views_field_handlers
+ */
+#[ViewsField("dblog_operations")]
+class DblogOperations extends FieldPluginBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function clickSortable() {
+    return FALSE;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function render(ResultRow $values) {
+    $value = $this->getValue($values);
+    return $this->sanitizeValue($value, 'xss_admin');
+  }
+
+}

core/modules/dblog/src/Plugin/views/filter/DblogTypes.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace Drupal\dblog\Plugin\views\filter;
+
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\views\Attribute\ViewsFilter;
+use Drupal\views\Plugin\views\filter\InOperator;
+
+/**
+ * Exposes log types to views module.
+ */
+#[ViewsFilter("dblog_types")]
+class DblogTypes extends InOperator {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getValueOptions() {
+    if (!isset($this->valueOptions)) {
+      $this->valueOptions = _dblog_get_message_types();
+    }
+    return $this->valueOptions;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function valueForm(&$form, FormStateInterface $form_state) {
+    parent::valueForm($form, $form_state);
+    $form['value']['#access'] = !empty($form['value']['#options']);
+  }
+
+}

core/modules/dblog/src/Plugin/views/wizard/Watchdog.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace Drupal\dblog\Plugin\views\wizard;
+
+use Drupal\Core\StringTranslation\TranslatableMarkup;
+use Drupal\views\Attribute\ViewsWizard;
+use Drupal\views\Plugin\views\wizard\WizardPluginBase;
+
+/**
+ * Defines a wizard for the watchdog table.
+ */
+#[ViewsWizard(
+  id: 'watchdog',
+  title: new TranslatableMarkup('Log entries'),
+  base_table: 'watchdog'
+)]
+class Watchdog extends WizardPluginBase {
+
+  /**
+   * Set the created column.
+   *
+   * @var string
+   */
+  protected $createdColumn = 'timestamp';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function defaultDisplayOptions() {
+    $display_options = parent::defaultDisplayOptions();
+
+    // Add permission-based access control.
+    $display_options['access']['type'] = 'perm';
+    $display_options['access']['options']['perm'] = 'access site reports';
+
+    return $display_options;
+  }
+
+}

core/modules/dblog/tests/modules/dblog_test_views/dblog_test_views.info.yml

@@ -0,0 +1,13 @@
+name: 'Dblog test views'
+type: module
+description: 'Provides default views for views dblog tests.'
+package: Testing
+# version: VERSION
+dependencies:
+  - drupal:dblog
+  - drupal:views
+
+# Information added by Drupal.org packaging script on 2024-07-04
+version: '10.3.1'
+project: 'drupal'
+datestamp: 1720094222

core/modules/dblog/tests/modules/dblog_test_views/test_views/views.view.dblog_integration_test.yml

@@ -0,0 +1,504 @@
+langcode: en
+status: true
+dependencies:
+  module:
+    - dblog
+    - user
+id: dblog_integration_test
+label: dblog_integration_test
+module: views
+description: ''
+tag: ''
+base_table: watchdog
+base_field: wid
+display:
+  default:
+    display_plugin: default
+    id: default
+    display_title: Default
+    position: 0
+    display_options:
+      access:
+        type: perm
+        options:
+          perm: 'access site reports'
+      cache:
+        type: tag
+        options: {  }
+      query:
+        type: views_query
+        options:
+          disable_sql_rewrite: false
+          distinct: false
+          replica: false
+          query_comment: ''
+          query_tags: {  }
+      exposed_form:
+        type: basic
+        options:
+          submit_button: Filter
+          reset_button: false
+          reset_button_label: Reset
+          exposed_sorts_label: 'Sort by'
+          expose_sort_order: true
+          sort_asc_label: Asc
+          sort_desc_label: Desc
+      pager:
+        type: mini
+        options:
+          items_per_page: 10
+          offset: 0
+          id: 0
+          total_pages: null
+          expose:
+            items_per_page: false
+            items_per_page_label: 'Items per page'
+            items_per_page_options: '5, 10, 25, 50'
+            items_per_page_options_all: false
+            items_per_page_options_all_label: '- All -'
+            offset: false
+            offset_label: Offset
+          tags:
+            previous: ‹‹
+            next: ››
+      style:
+        type: default
+      row:
+        type: fields
+      fields:
+        wid:
+          table: watchdog
+          field: wid
+          id: wid
+          entity_type: null
+          entity_field: null
+          plugin_id: standard
+          relationship: none
+          group_type: group
+          admin_label: ''
+          label: ''
+          exclude: false
+          alter:
+            alter_text: false
+            text: ''
+            make_link: false
+            path: ''
+            absolute: false
+            external: false
+            replace_spaces: false
+            path_case: none
+            trim_whitespace: false
+            alt: ''
+            rel: ''
+            link_class: ''
+            prefix: ''
+            suffix: ''
+            target: ''
+            nl2br: false
+            max_length: 0
+            word_boundary: true
+            ellipsis: true
+            more_link: false
+            more_link_text: ''
+            more_link_path: ''
+            strip_tags: false
+            trim: false
+            preserve_tags: ''
+            html: false
+          element_type: ''
+          element_class: ''
+          element_label_type: ''
+          element_label_class: ''
+          element_label_colon: true
+          element_wrapper_type: ''
+          element_wrapper_class: ''
+          element_default_classes: true
+          empty: ''
+          hide_empty: false
+          empty_zero: false
+          hide_alter_empty: true
+        message:
+          id: message
+          table: watchdog
+          field: message
+          relationship: none
+          group_type: group
+          admin_label: ''
+          label: ''
+          exclude: false
+          alter:
+            alter_text: false
+            text: ''
+            make_link: false
+            path: ''
+            absolute: false
+            external: false
+            replace_spaces: false
+            path_case: none
+            trim_whitespace: false
+            alt: ''
+            rel: ''
+            link_class: ''
+            prefix: ''
+            suffix: ''
+            target: ''
+            nl2br: false
+            max_length: 0
+            word_boundary: true
+            ellipsis: true
+            more_link: false
+            more_link_text: ''
+            more_link_path: ''
+            strip_tags: false
+            trim: false
+            preserve_tags: ''
+            html: false
+          element_type: ''
+          element_class: ''
+          element_label_type: ''
+          element_label_class: ''
+          element_label_colon: false
+          element_wrapper_type: ''
+          element_wrapper_class: ''
+          element_default_classes: true
+          empty: ''
+          hide_empty: false
+          empty_zero: false
+          hide_alter_empty: true
+          replace_variables: true
+          plugin_id: dblog_message
+        link:
+          id: link
+          table: watchdog
+          field: link
+          relationship: none
+          group_type: group
+          admin_label: ''
+          label: ''
+          exclude: false
+          alter:
+            alter_text: false
+            text: ''
+            make_link: false
+            path: ''
+            absolute: false
+            external: false
+            replace_spaces: false
+            path_case: none
+            trim_whitespace: false
+            alt: ''
+            rel: ''
+            link_class: ''
+            prefix: ''
+            suffix: ''
+            target: ''
+            nl2br: false
+            max_length: 0
+            word_boundary: true
+            ellipsis: true
+            more_link: false
+            more_link_text: ''
+            more_link_path: ''
+            strip_tags: false
+            trim: false
+            preserve_tags: ''
+            html: false
+          element_type: ''
+          element_class: ''
+          element_label_type: ''
+          element_label_class: ''
+          element_label_colon: false
+          element_wrapper_type: ''
+          element_wrapper_class: ''
+          element_default_classes: true
+          empty: ''
+          hide_empty: false
+          empty_zero: false
+          hide_alter_empty: true
+          plugin_id: dblog_operations
+        severity:
+          id: severity
+          table: watchdog
+          field: severity
+          relationship: none
+          group_type: group
+          admin_label: ''
+          label: ''
+          exclude: false
+          alter:
+            alter_text: false
+            text: ''
+            make_link: false
+            path: ''
+            absolute: false
+            external: false
+            replace_spaces: false
+            path_case: none
+            trim_whitespace: false
+            alt: ''
+            rel: ''
+            link_class: ''
+            prefix: ''
+            suffix: ''
+            target: ''
+            nl2br: false
+            max_length: 0
+            word_boundary: true
+            ellipsis: true
+            more_link: false
+            more_link_text: ''
+            more_link_path: ''
+            strip_tags: false
+            trim: false
+            preserve_tags: ''
+            html: false
+          element_type: ''
+          element_class: ''
+          element_label_type: ''
+          element_label_class: ''
+          element_label_colon: false
+          element_wrapper_type: ''
+          element_wrapper_class: ''
+          element_default_classes: true
+          empty: ''
+          hide_empty: false
+          empty_zero: false
+          hide_alter_empty: true
+          machine_name: false
+          plugin_id: machine_name
+        type:
+          id: type
+          table: watchdog
+          field: type
+          relationship: none
+          group_type: group
+          admin_label: ''
+          label: ''
+          exclude: false
+          alter:
+            alter_text: false
+            text: ''
+            make_link: false
+            path: ''
+            absolute: false
+            external: false
+            replace_spaces: false
+            path_case: none
+            trim_whitespace: false
+            alt: ''
+            rel: ''
+            link_class: ''
+            prefix: ''
+            suffix: ''
+            target: ''
+            nl2br: false
+            max_length: 0
+            word_boundary: true
+            ellipsis: true
+            more_link: false
+            more_link_text: ''
+            more_link_path: ''
+            strip_tags: false
+            trim: false
+            preserve_tags: ''
+            html: false
+          element_type: ''
+          element_class: ''
+          element_label_type: ''
+          element_label_class: ''
+          element_label_colon: false
+          element_wrapper_type: ''
+          element_wrapper_class: ''
+          element_default_classes: true
+          empty: ''
+          hide_empty: false
+          empty_zero: false
+          hide_alter_empty: true
+          plugin_id: standard
+        name:
+          id: name
+          table: users_field_data
+          field: name
+          relationship: uid
+          group_type: group
+          admin_label: ''
+          label: ''
+          exclude: false
+          alter:
+            alter_text: false
+            text: ''
+            make_link: false
+            path: ''
+            absolute: false
+            external: false
+            replace_spaces: false
+            path_case: none
+            trim_whitespace: false
+            alt: ''
+            rel: ''
+            link_class: ''
+            prefix: ''
+            suffix: ''
+            target: ''
+            nl2br: false
+            max_length: 0
+            word_boundary: true
+            ellipsis: true
+            more_link: false
+            more_link_text: ''
+            more_link_path: ''
+            strip_tags: false
+            trim: false
+            preserve_tags: ''
+            html: false
+          element_type: ''
+          element_class: ''
+          element_label_type: ''
+          element_label_class: ''
+          element_label_colon: false
+          element_wrapper_type: ''
+          element_wrapper_class: ''
+          element_default_classes: true
+          empty: ''
+          hide_empty: false
+          empty_zero: false
+          hide_alter_empty: true
+          click_sort_column: value
+          type: user_name
+          settings:
+            link_to_entity: true
+          group_column: value
+          group_columns: {  }
+          group_rows: true
+          delta_limit: 0
+          delta_offset: 0
+          delta_reversed: false
+          delta_first_last: false
+          multi_type: separator
+          separator: ', '
+          field_api_classes: false
+          entity_type: user
+          entity_field: name
+          plugin_id: field
+      filters:
+        severity:
+          id: severity
+          table: watchdog
+          field: severity
+          relationship: none
+          group_type: group
+          admin_label: ''
+          operator: in
+          value: {  }
+          group: 1
+          exposed: true
+          expose:
+            operator_id: severity_op
+            label: 'Severity level'
+            description: ''
+            use_operator: false
+            operator: severity_op
+            identifier: severity
+            required: false
+            remember: false
+            multiple: true
+            remember_roles:
+              authenticated: authenticated
+              anonymous: '0'
+              administrator: '0'
+            reduce: false
+          is_grouped: false
+          group_info:
+            label: ''
+            description: ''
+            identifier: ''
+            optional: true
+            widget: select
+            multiple: false
+            remember: false
+            default_group: All
+            default_group_multiple: {  }
+            group_items: {  }
+          plugin_id: in_operator
+        type:
+          id: type
+          table: watchdog
+          field: type
+          relationship: none
+          group_type: group
+          admin_label: ''
+          operator: in
+          value: {  }
+          group: 1
+          exposed: true
+          expose:
+            operator_id: type_op
+            label: Type
+            description: ''
+            use_operator: false
+            operator: type_op
+            identifier: type
+            required: false
+            remember: false
+            multiple: true
+            remember_roles:
+              authenticated: authenticated
+              anonymous: '0'
+              administrator: '0'
+            reduce: false
+          is_grouped: false
+          group_info:
+            label: ''
+            description: ''
+            identifier: ''
+            optional: true
+            widget: select
+            multiple: false
+            remember: false
+            default_group: All
+            default_group_multiple: {  }
+            group_items: {  }
+          plugin_id: dblog_types
+      sorts: {  }
+      title: dblog_integration_test
+      header: {  }
+      footer: {  }
+      empty: {  }
+      relationships:
+        uid:
+          id: uid
+          table: watchdog
+          field: uid
+          relationship: none
+          group_type: group
+          admin_label: uid
+          required: false
+          plugin_id: standard
+      arguments: {  }
+      display_extenders: {  }
+    cache_metadata:
+      max-age: -1
+      contexts:
+        - 'languages:language_content'
+        - 'languages:language_interface'
+        - url
+        - url.query_args
+        - user.permissions
+      tags: {  }
+  page_1:
+    display_plugin: page
+    id: page_1
+    display_title: Page
+    position: 1
+    display_options:
+      display_extenders: {  }
+      path: dblog-integration-test
+    cache_metadata:
+      max-age: -1
+      contexts:
+        - 'languages:language_content'
+        - 'languages:language_interface'
+        - url
+        - url.query_args
+        - user.permissions
+      tags: {  }

core/modules/dblog/tests/modules/dblog_test_views/test_views/views.view.test_dblog.yml

@@ -0,0 +1,64 @@
+langcode: en
+status: true
+dependencies:
+  module:
+    - dblog
+id: test_dblog
+label: test_dblog
+module: views
+description: ''
+tag: ''
+base_table: watchdog
+base_field: wid
+display:
+  default:
+    display_plugin: default
+    id: default
+    display_title: Default
+    position: null
+    display_options:
+      access:
+        type: none
+      cache:
+        type: tag
+      query:
+        type: views_query
+      exposed_form:
+        type: basic
+      pager:
+        type: full
+      style:
+        type: default
+      row:
+        type: fields
+      fields:
+        wid:
+          id: wid
+          table: watchdog
+          field: wid
+          plugin_id: standard
+        message:
+          id: message
+          table: watchdog
+          field: message
+          plugin_id: dblog_message
+        link:
+          id: link
+          table: watchdog
+          field: link
+          plugin_id: dblog_operations
+      filters: {  }
+      sorts:
+        wid:
+          id: wid
+          table: watchdog
+          field: wid
+          order: ASC
+          plugin_id: standard
+  page_1:
+    display_plugin: page
+    id: page_1
+    display_title: Page
+    position: null
+    display_options:
+      path: test-dblog

core/modules/dblog/tests/src/Functional/DbLogResourceTest.php

@@ -0,0 +1,171 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\dblog\Functional;
+
+use Drupal\Component\Serialization\Json;
+use Drupal\Core\Cache\CacheableMetadata;
+use Drupal\Core\Database\Database;
+use Drupal\Core\Url;
+use Drupal\Tests\rest\Functional\CookieResourceTestTrait;
+use Drupal\Tests\rest\Functional\ResourceTestBase;
+
+/**
+ * Tests the watchdog database log resource.
+ *
+ * @group dblog
+ */
+class DbLogResourceTest extends ResourceTestBase {
+
+  use CookieResourceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected $defaultTheme = 'stark';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $auth = 'cookie';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $resourceConfigId = 'dblog';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $modules = ['rest', 'dblog'];
+
+  /**
+   * The entity type ID.
+   *
+   * @var string
+   */
+  protected static $entityTypeId = '';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp(): void {
+    parent::setUp();
+
+    $auth = isset(static::$auth) ? [static::$auth] : [];
+    $this->provisionResource([static::$format], $auth);
+  }
+
+  /**
+   * Writes a log messages and retrieves it via the REST API.
+   */
+  public function testWatchdog(): void {
+    // Write a log message to the DB.
+    $this->container->get('logger.channel.rest')->notice('Test message');
+    // Get the ID of the written message.
+    $id = Database::getConnection()->select('watchdog', 'w')
+      ->fields('w', ['wid'])
+      ->condition('type', 'rest')
+      ->orderBy('wid', 'DESC')
+      ->range(0, 1)
+      ->execute()
+      ->fetchField();
+
+    $this->initAuthentication();
+    $url = Url::fromRoute(
+      'rest.dblog.GET',
+      ['id' => $id, '_format' => static::$format]
+    );
+    $request_options = $this->getAuthenticationRequestOptions('GET');
+
+    $response = $this->request('GET', $url, $request_options);
+    $this->assertResourceErrorResponse(
+      403,
+      "The 'restful get dblog' permission is required.",
+      $response,
+      ['4xx-response', 'http_response'],
+      ['user.permissions']
+    );
+
+    // Create a user account that has the required permissions to read
+    // the watchdog resource via the REST API.
+    $this->setUpAuthorization('GET');
+
+    $response = $this->request('GET', $url, $request_options);
+    $this->assertResourceResponse(
+      200,
+      FALSE,
+      $response,
+      ['config:rest.resource.dblog', 'http_response'],
+      ['user.permissions'],
+      FALSE,
+      'MISS'
+    );
+    $log = Json::decode((string) $response->getBody());
+    $this->assertEquals($id, $log['wid'], 'Log ID is correct.');
+    $this->assertEquals('rest', $log['type'], 'Type of log message is correct.');
+    $this->assertEquals('Test message', $log['message'], 'Log message text is correct.');
+
+    // Request an unknown log entry.
+    $url->setRouteParameter('id', 9999);
+    $response = $this->request('GET', $url, $request_options);
+    $this->assertResourceErrorResponse(404, "Log entry with ID '9999' was not found", $response);
+
+    // Make a bad request (a true malformed request would never be a route
+    // match).
+    $url->setRouteParameter('id', 0);
+    $response = $this->request('GET', $url, $request_options);
+    $this->assertResourceErrorResponse(400, 'No log entry ID was provided', $response);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUpAuthorization($method) {
+    switch ($method) {
+      case 'GET':
+        $this->grantPermissionsToTestedRole(['restful get dblog']);
+        break;
+
+      default:
+        throw new \UnexpectedValueException();
+    }
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function assertNormalizationEdgeCases($method, Url $url, array $request_options): void {}
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getExpectedUnauthorizedAccessMessage($method) {
+    switch ($method) {
+      case 'GET':
+        return "The 'restful get dblog' permission is required.";
+
+      default:
+        return parent::getExpectedUnauthorizedAccessMessage($method);
+    }
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getExpectedUnauthorizedAccessCacheability() {
+    return (new CacheableMetadata())
+      ->setCacheTags(['4xx-response', 'http_response'])
+      ->setCacheContexts(['user.permissions']);
+  }
+
+  /**
+   * Empty function.
+   *
+   * Needed by PHPStan for unused function
+   * CookieResourceTestTrait::assertResponseWhenMissingAuthentication().
+   */
+  protected function getExpectedUnauthorizedEntityAccessCacheability($is_authenticated) {}
+
+}

core/modules/dblog/tests/src/Functional/DbLogTest.php

@@ -0,0 +1,926 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\dblog\Functional;
+
+use Drupal\Component\Render\FormattableMarkup;
+use Drupal\Component\Utility\Unicode;
+use Drupal\Core\Database\Database;
+use Drupal\Core\Logger\RfcLogLevel;
+use Drupal\Core\Link;
+use Drupal\Core\Url;
+use Drupal\dblog\Controller\DbLogController;
+use Drupal\error_test\Controller\ErrorTestController;
+use Drupal\Tests\BrowserTestBase;
+use Drupal\Tests\system\Functional\Menu\AssertBreadcrumbTrait;
+
+/**
+ * Verifies log entries and user access based on permissions.
+ *
+ * @group dblog
+ * @group #slow
+ */
+class DbLogTest extends BrowserTestBase {
+  use FakeLogEntries;
+  use AssertBreadcrumbTrait;
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  protected static $modules = [
+    'dblog',
+    'error_test',
+    'node',
+    'help',
+    'block',
+  ];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected $defaultTheme = 'stark';
+
+  /**
+   * A user with some relevant administrative permissions.
+   *
+   * @var \Drupal\user\UserInterface
+   */
+  protected $adminUser;
+
+  /**
+   * A user without any permissions.
+   *
+   * @var \Drupal\user\UserInterface
+   */
+  protected $webUser;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp(): void {
+    parent::setUp();
+    $this->drupalPlaceBlock('system_breadcrumb_block');
+    $this->drupalPlaceBlock('page_title_block');
+
+    // Create users with specific permissions.
+    $this->adminUser = $this->drupalCreateUser([
+      'administer site configuration',
+      'access administration pages',
+      'access help pages',
+      'access site reports',
+      'administer users',
+    ]);
+    $this->webUser = $this->drupalCreateUser([]);
+  }
+
+  /**
+   * Tests Database Logging module functionality through interfaces.
+   *
+   * First logs in users, then creates database log events, and finally tests
+   * Database Logging module functionality through both the admin and user
+   * interfaces.
+   */
+  public function testDbLog(): void {
+    // Log in the admin user.
+    $this->drupalLogin($this->adminUser);
+
+    $row_limit = 100;
+    $this->verifyRowLimit($row_limit);
+    $this->verifyEvents();
+    $this->verifyReports();
+    $this->verifyBreadcrumbs();
+    $this->verifyLinkEscaping();
+    // Verify the overview table sorting.
+    $orders = ['Date', 'Type', 'User'];
+    $sorts = ['asc', 'desc'];
+    foreach ($orders as $order) {
+      foreach ($sorts as $sort) {
+        $this->verifySort($sort, $order);
+      }
+    }
+
+    // Log in the regular user.
+    $this->drupalLogin($this->webUser);
+    $this->verifyReports(403);
+  }
+
+  /**
+   * Tests individual log event page.
+   */
+  public function testLogEventPage(): void {
+    // Login the admin user.
+    $this->drupalLogin($this->adminUser);
+
+    // Since referrer and location links vary by how the tests are run, inject
+    // fake log data to test these.
+    $context = [
+      'request_uri' => 'http://example.com?dblog=1',
+      'referer' => 'http://example.org?dblog=2',
+      'uid' => 0,
+      'channel' => 'testing',
+      'link' => 'foo/bar',
+      'ip' => '0.0.1.0',
+      'timestamp' => \Drupal::time()->getRequestTime(),
+    ];
+    \Drupal::service('logger.dblog')->log(RfcLogLevel::NOTICE, 'Test message', $context);
+    $query = Database::getConnection()->select('watchdog');
+    $query->addExpression('MAX([wid])');
+    $wid = $query->execute()->fetchField();
+
+    // Verify the links appear correctly.
+    $this->drupalGet('admin/reports/dblog/event/' . $wid);
+    $this->assertSession()->linkByHrefExists($context['request_uri']);
+    $this->assertSession()->linkByHrefExists($context['referer']);
+
+    // Verify hostname.
+    $this->assertSession()->pageTextContains($context['ip']);
+
+    // Verify location.
+    $this->assertSession()->pageTextContains($context['request_uri']);
+
+    // Verify severity.
+    $this->assertSession()->pageTextContains('Notice');
+  }
+
+  /**
+   * Tests that the details page displays the backtrace for a logged \Throwable.
+   */
+  public function testOnError(): void {
+    // Log in as the admin user.
+    $this->drupalLogin($this->adminUser);
+
+    // Load a page that throws an exception in the controller, and includes its
+    // function arguments in the exception backtrace.
+    $this->drupalGet('error-test/trigger-exception');
+
+    // Load the details page for the most recent event logged by the "php"
+    // logger.
+    $query = Database::getConnection()->select('watchdog')
+      ->condition('type', 'php');
+    $query->addExpression('MAX([wid])');
+    $wid = $query->execute()->fetchField();
+    $this->drupalGet('admin/reports/dblog/event/' . $wid);
+
+    // Verify the page displays a dblog-event table with a "Type" header.
+    $table = $this->assertSession()->elementExists('xpath', "//table[@class='dblog-event']");
+    $type = "//tr/th[contains(text(), 'Type')]/../td";
+    $this->assertSession()->elementsCount('xpath', $type, 1, $table);
+
+    // Verify that the backtrace row exists and is HTML-encoded.
+    $backtrace = "//tr//pre[contains(@class, 'backtrace')]";
+    $this->assertCount(1, $table->findAll('xpath', $backtrace));
+    $this->assertSession()->responseContains('&lt;script&gt;alert(&#039;xss&#039;)&lt;/script&gt;');
+  }
+
+  /**
+   * Tests that a 403 event is logged with the exception triggering it.
+   */
+  public function test403LogEventPage(): void {
+    $assert_session = $this->assertSession();
+    $uri = 'admin/reports';
+
+    $this->drupalLogin($this->webUser);
+    $this->drupalGet($uri);
+    $assert_session->statusCodeEquals(403);
+
+    $this->drupalLogin($this->adminUser);
+
+    $query = Database::getConnection()->select('watchdog')
+      ->condition('type', 'access denied');
+    $query->addExpression('MAX([wid])');
+    $wid = $query->execute()->fetchField();
+    $this->drupalGet('admin/reports/dblog/event/' . $wid);
+
+    $table = $this->assertSession()->elementExists('xpath', "//table[@class='dblog-event']");
+
+    // Verify type, severity and location.
+    $type = "//tr/th[contains(text(), 'Type')]/../td";
+    $this->assertSession()->elementsCount('xpath', $type, 1, $table);
+    $this->assertEquals('access denied', $table->findAll('xpath', $type)[0]->getText());
+    $severity = "//tr/th[contains(text(), 'Severity')]/../td";
+    $this->assertSession()->elementsCount('xpath', $severity, 1, $table);
+    $this->assertEquals('Warning', $table->findAll('xpath', $severity)[0]->getText());
+    $location = $table->findAll('xpath', "//tr/th[contains(text(), 'Location')]/../td/a");
+    $this->assertCount(1, $location);
+    $href = $location[0]->getAttribute('href');
+    $this->assertEquals($this->baseUrl . '/' . $uri, $href);
+
+    // Verify message.
+    $message = $table->findAll('xpath', "//tr/th[contains(text(), 'Message')]/../td");
+    $this->assertCount(1, $message);
+    $regex = "@Path: .+admin/reports\. Drupal\\\\Core\\\\Http\\\\Exception\\\\CacheableAccessDeniedHttpException: The 'access site reports' permission is required\. in Drupal\\\\Core\\\\Routing\\\\AccessAwareRouter->checkAccess\(\) \(line \d+ of .+/core/lib/Drupal/Core/Routing/AccessAwareRouter\.php\)\.@";
+    $this->assertMatchesRegularExpression($regex, $message[0]->getText());
+  }
+
+  /**
+   * Tests not-existing log event page.
+   */
+  public function testLogEventNotFoundPage(): void {
+    // Login the admin user.
+    $this->drupalLogin($this->adminUser);
+
+    // Try to read details of non-existent event.
+    $this->drupalGet('admin/reports/dblog/event/999999');
+    // Verify 404 response.
+    $this->assertSession()->statusCodeEquals(404);
+  }
+
+  /**
+   * Tests individual log event page with missing log attributes.
+   *
+   * In some cases few log attributes are missing. For example:
+   * - Missing referer: When request is made to a specific URL directly and
+   *   error occurred. In this case there is no referer.
+   * - Incorrect location: When location attribute is incorrect uri which can
+   *   not be used to generate a valid link.
+   */
+  public function testLogEventPageWithMissingInfo(): void {
+    $this->drupalLogin($this->adminUser);
+    $connection = Database::getConnection();
+
+    // Test log event page with missing referer.
+    $this->generateLogEntries(1, [
+      'referer' => NULL,
+    ]);
+    $query = $connection->select('watchdog');
+    $query->addExpression('MAX([wid])');
+    $wid = $query->execute()->fetchField();
+    $this->drupalGet('admin/reports/dblog/event/' . $wid);
+
+    // Verify table headers are present, even though the referrer is missing.
+    $this->assertSession()->pageTextContains('Referrer');
+
+    // Verify severity.
+    $this->assertSession()->pageTextContains('Notice');
+
+    // Test log event page with incorrect location.
+    $request_uri = '/some/incorrect/url';
+    $this->generateLogEntries(1, [
+      'request_uri' => $request_uri,
+    ]);
+    $query = $connection->select('watchdog');
+    $query->addExpression('MAX([wid])');
+    $wid = $query->execute()->fetchField();
+    $this->drupalGet('admin/reports/dblog/event/' . $wid);
+
+    // Verify table headers are present.
+    $this->assertSession()->pageTextContains('Location');
+
+    // Verify severity.
+    $this->assertSession()->pageTextContains('Notice');
+
+    // Verify location is available as plain text.
+    $this->assertEquals($request_uri, $this->cssSelect('table.dblog-event > tbody > tr:nth-child(4) > td')[0]->getHtml());
+    $this->assertSession()->linkNotExists($request_uri);
+  }
+
+  /**
+   * Test that twig errors are displayed correctly.
+   */
+  public function testMessageParsing(): void {
+    $this->drupalLogin($this->adminUser);
+    // Log a common twig error with {{ }} and { } variables.
+    \Drupal::service('logger.factory')->get("php")
+      ->error('Incorrect parameter {{foo}} in path {path}: {value}',
+        ['foo' => 'bar', 'path' => '/baz', 'value' => 'horse']
+      );
+    // View the log page to verify it's correct.
+    $wid = \Drupal::database()->query('SELECT MAX(wid) FROM {watchdog}')->fetchField();
+    $this->drupalGet('admin/reports/dblog/event/' . $wid);
+    $this->assertSession()
+      ->responseContains('Incorrect parameter {bar} in path /baz: horse');
+  }
+
+  /**
+   * Verifies setting of the database log row limit.
+   *
+   * @param int $row_limit
+   *   The row limit.
+   */
+  private function verifyRowLimit($row_limit) {
+    // Change the database log row limit.
+    $edit = [];
+    $edit['dblog_row_limit'] = $row_limit;
+    $this->drupalGet('admin/config/development/logging');
+    $this->submitForm($edit, 'Save configuration');
+    $this->assertSession()->statusMessageContains('The configuration options have been saved.');
+    $this->assertSession()->statusCodeEquals(200);
+
+    // Check row limit variable.
+    $current_limit = $this->config('dblog.settings')->get('row_limit');
+    $this->assertEquals($current_limit, $row_limit, "[Cache] Row limit variable of $current_limit equals row limit of $row_limit");
+  }
+
+  /**
+   * Clear the entry logs by clicking on 'Clear log messages' button.
+   */
+  protected function clearLogsEntries() {
+    $this->drupalGet(Url::fromRoute('dblog.confirm'));
+  }
+
+  /**
+   * Filters the logs according to the specific severity and log entry type.
+   *
+   * @param string $type
+   *   (optional) The log entry type.
+   * @param string $severity
+   *   (optional) The log entry severity.
+   */
+  protected function filterLogsEntries($type = NULL, $severity = NULL) {
+    $edit = [];
+    if (isset($type)) {
+      $edit['type[]'] = $type;
+    }
+    if (isset($severity)) {
+      $edit['severity[]'] = $severity;
+    }
+    $this->submitForm($edit, 'Filter');
+  }
+
+  /**
+   * Confirms that database log reports are displayed at the correct paths.
+   *
+   * @param int $response
+   *   (optional) HTTP response code. Defaults to 200.
+   */
+  private function verifyReports($response = 200) {
+    // View the database log help page.
+    $this->drupalGet('admin/help/dblog');
+    $this->assertSession()->statusCodeEquals($response);
+    if ($response == 200) {
+      $this->assertSession()->pageTextContains('Database Logging');
+    }
+
+    // View the database log report page.
+    $this->drupalGet('admin/reports/dblog');
+    $this->assertSession()->statusCodeEquals($response);
+    if ($response == 200) {
+      $this->assertSession()->pageTextContains('Recent log messages');
+    }
+
+    $this->drupalGet('admin/reports/dblog/confirm');
+    $this->assertSession()->statusCodeEquals($response);
+    if ($response == 200) {
+      $this->assertSession()->pageTextContains('Are you sure you want to delete the recent logs?');
+    }
+
+    // View the database log page-not-found report page.
+    $this->drupalGet('admin/reports/page-not-found');
+    $this->assertSession()->statusCodeEquals($response);
+    if ($response == 200) {
+      $this->assertSession()->pageTextContains("Top 'page not found' errors");
+    }
+
+    // View the database log access-denied report page.
+    $this->drupalGet('admin/reports/access-denied');
+    $this->assertSession()->statusCodeEquals($response);
+    if ($response == 200) {
+      $this->assertSession()->pageTextContains("Top 'access denied' errors");
+    }
+
+    // View the database log event page.
+    $query = Database::getConnection()->select('watchdog');
+    $query->addExpression('MIN([wid])');
+    $wid = $query->execute()->fetchField();
+    $this->drupalGet('admin/reports/dblog/event/' . $wid);
+    $this->assertSession()->statusCodeEquals($response);
+    if ($response == 200) {
+      $this->assertSession()->pageTextContains('Details');
+    }
+  }
+
+  /**
+   * Generates and then verifies breadcrumbs.
+   */
+  private function verifyBreadcrumbs() {
+    // View the database log event page.
+    $query = Database::getConnection()->select('watchdog');
+    $query->addExpression('MIN([wid])');
+    $wid = $query->execute()->fetchField();
+    $trail = [
+      '' => 'Home',
+      'admin' => 'Administration',
+      'admin/reports' => 'Reports',
+      'admin/reports/dblog' => 'Recent log messages',
+    ];
+    $this->assertBreadcrumb('admin/reports/dblog/event/' . $wid, $trail);
+  }
+
+  /**
+   * Generates and then verifies various types of events.
+   */
+  private function verifyEvents() {
+    // Invoke events.
+    $this->doUser();
+    $this->drupalCreateContentType(['type' => 'article', 'name' => 'Article']);
+    $this->drupalCreateContentType(['type' => 'page', 'name' => 'Basic page']);
+    $this->doNode('article');
+    $this->doNode('page');
+
+    // When a user account is canceled, any content they created remains but the
+    // uid = 0. Records in the watchdog table related to that user have the uid
+    // set to zero.
+  }
+
+  /**
+   * Verifies the sorting functionality of the database logging reports table.
+   *
+   * @param string $sort
+   *   The sort direction.
+   * @param string $order
+   *   The order by which the table should be sorted.
+   */
+  public function verifySort($sort = 'asc', $order = 'Date') {
+    $this->drupalGet('admin/reports/dblog', ['query' => ['sort' => $sort, 'order' => $order]]);
+    $this->assertSession()->statusCodeEquals(200);
+    $this->assertSession()->pageTextContains('Recent log messages');
+  }
+
+  /**
+   * Tests link escaping in the operation row of a database log detail page.
+   */
+  private function verifyLinkEscaping() {
+    $link = Link::fromTextAndUrl('View', Url::fromRoute('entity.node.canonical', ['node' => 1]))->toString();
+    $message = 'Log entry added to do the verifyLinkEscaping test.';
+    $this->generateLogEntries(1, [
+      'message' => $message,
+      'link' => $link,
+    ]);
+
+    $result = Database::getConnection()->select('watchdog', 'w')->fields('w', ['wid'])->orderBy('wid', 'DESC')->range(0, 1)->execute();
+    $this->drupalGet('admin/reports/dblog/event/' . $result->fetchField());
+
+    // Check if the link exists (unescaped).
+    $this->assertSession()->responseContains($link);
+  }
+
+  /**
+   * Generates and then verifies some user events.
+   */
+  private function doUser() {
+    // Set user variables.
+    $name = $this->randomMachineName();
+    $pass = \Drupal::service('password_generator')->generate();
+    // Add a user using the form to generate an add user event (which is not
+    // triggered by drupalCreateUser).
+    $edit = [];
+    $edit['name'] = $name;
+    $edit['mail'] = $name . '@example.com';
+    $edit['pass[pass1]'] = $pass;
+    $edit['pass[pass2]'] = $pass;
+    $edit['status'] = 1;
+    $this->drupalGet('admin/people/create');
+    $this->submitForm($edit, 'Create new account');
+    $this->assertSession()->statusCodeEquals(200);
+    // Retrieve the user object.
+    $user = user_load_by_name($name);
+    $this->assertNotNull($user, "User $name was loaded");
+    // pass_raw property is needed by drupalLogin.
+    $user->passRaw = $pass;
+    // Log in user.
+    $this->drupalLogin($user);
+    // Log out user.
+    $this->drupalLogout();
+    // Fetch the row IDs in watchdog that relate to the user.
+    $result = Database::getConnection()->select('watchdog', 'w')->fields('w', ['wid'])->condition('uid', $user->id())->execute();
+    foreach ($result as $row) {
+      $ids[] = $row->wid;
+    }
+    $count_before = (isset($ids)) ? count($ids) : 0;
+    $this->assertGreaterThan(0, $count_before, "DBLog contains $count_before records for {$user->getAccountName()}");
+
+    // Log in the admin user.
+    $this->drupalLogin($this->adminUser);
+    // Delete the user created at the start of this test.
+    // We need to POST here to invoke batch_process() in the internal browser.
+    $this->drupalGet('user/' . $user->id() . '/cancel');
+    $this->submitForm(['user_cancel_method' => 'user_cancel_reassign'], 'Confirm');
+
+    // View the database log report.
+    $this->drupalGet('admin/reports/dblog');
+    $this->assertSession()->statusCodeEquals(200);
+
+    // Verify that the expected events were recorded.
+    // Add user.
+    // Default display includes name and email address; if too long, the email
+    // address is replaced by three periods.
+    $this->assertLogMessage("New user: $name <{$user->getEmail()}>.", 'DBLog event was recorded: [add user]');
+    // Log in user.
+    $this->assertLogMessage("Session opened for $name.", 'DBLog event was recorded: [login user]');
+    // Log out user.
+    $this->assertLogMessage("Session closed for $name.", 'DBLog event was recorded: [logout user]');
+    // Delete user.
+    $message = "Deleted user: $name <{$user->getEmail()}>.";
+    $message_text = Unicode::truncate($message, 56, TRUE, TRUE);
+    // Verify that the full message displays on the details page.
+    $link = FALSE;
+    if ($links = $this->xpath('//a[text()="' . $message_text . '"]')) {
+      // Found link with the message text.
+      $links = array_shift($links);
+      $value = $links->getAttribute('href');
+
+      // Extract link to details page.
+      $link = mb_substr($value, strpos($value, 'admin/reports/dblog/event/'));
+      $this->drupalGet($link);
+      // Check for full message text on the details page.
+      $this->assertSession()->pageTextContains($message);
+    }
+    $this->assertNotEmpty($link, 'DBLog event was recorded: [delete user]');
+    // Visit random URL (to generate page not found event).
+    $not_found_url = $this->randomMachineName(60);
+    $this->drupalGet($not_found_url);
+    $this->assertSession()->statusCodeEquals(404);
+    // View the database log page-not-found report page.
+    $this->drupalGet('admin/reports/page-not-found');
+    $this->assertSession()->statusCodeEquals(200);
+    // Check that full-length URL displayed.
+    $this->assertSession()->pageTextContains($not_found_url);
+  }
+
+  /**
+   * Generates and then verifies some node events.
+   *
+   * @param string $type
+   *   A node type (e.g., 'article' or 'page').
+   */
+  private function doNode($type) {
+    // Create user.
+    $perm = ['create ' . $type . ' content', 'edit own ' . $type . ' content', 'delete own ' . $type . ' content'];
+    $user = $this->drupalCreateUser($perm);
+    // Log in user.
+    $this->drupalLogin($user);
+
+    // Create a node using the form in order to generate an add content event
+    // (which is not triggered by drupalCreateNode).
+    $edit = [
+      'title[0][value]' => $this->randomMachineName(8),
+      'body[0][value]'  => $this->randomMachineName(32),
+    ];
+    $title = $edit['title[0][value]'];
+    $this->drupalGet('node/add/' . $type);
+    $this->submitForm($edit, 'Save');
+    $this->assertSession()->statusCodeEquals(200);
+    // Retrieve the node object.
+    $node = $this->drupalGetNodeByTitle($title);
+    $this->assertNotNull($node, "Node $title was loaded");
+    // Edit the node.
+    $edit = [
+      'body[0][value]' => $this->randomMachineName(32),
+    ];
+    $this->drupalGet('node/' . $node->id() . '/edit');
+    $this->submitForm($edit, 'Save');
+    $this->assertSession()->statusCodeEquals(200);
+    // Delete the node.
+    $this->drupalGet('node/' . $node->id() . '/delete');
+    $this->submitForm([], 'Delete');
+    $this->assertSession()->statusCodeEquals(200);
+    // View the node (to generate page not found event).
+    $this->drupalGet('node/' . $node->id());
+    $this->assertSession()->statusCodeEquals(404);
+    // View the database log report (to generate access denied event).
+    $this->drupalGet('admin/reports/dblog');
+    $this->assertSession()->statusCodeEquals(403);
+
+    // Log in the admin user.
+    $this->drupalLogin($this->adminUser);
+    // View the database log report.
+    $this->drupalGet('admin/reports/dblog');
+    $this->assertSession()->statusCodeEquals(200);
+
+    // Verify that node events were recorded.
+    // Was node content added?
+    $this->assertLogMessage("$type: added $title.", 'DBLog event was recorded: [content added]');
+    // Was node content updated?
+    $this->assertLogMessage("$type: updated $title.", 'DBLog event was recorded: [content updated]');
+    // Was node content deleted?
+    $this->assertLogMessage("$type: deleted $title.", 'DBLog event was recorded: [content deleted]');
+
+    // View the database log access-denied report page.
+    $this->drupalGet('admin/reports/access-denied');
+    $this->assertSession()->statusCodeEquals(200);
+    // Verify that the 'access denied' event was recorded.
+    $this->assertSession()->pageTextContains('admin/reports/dblog');
+
+    // View the database log page-not-found report page.
+    $this->drupalGet('admin/reports/page-not-found');
+    $this->assertSession()->statusCodeEquals(200);
+    // Verify that the 'page not found' event was recorded.
+    $this->assertSession()->pageTextContains('node/' . $node->id());
+  }
+
+  /**
+   * Tests the addition and clearing of log events through the admin interface.
+   *
+   * Logs in the admin user, creates a database log event, and tests the
+   * functionality of clearing the database log through the admin interface.
+   */
+  public function testDBLogAddAndClear(): void {
+    global $base_root;
+    $connection = Database::getConnection();
+    // Get a count of how many watchdog entries already exist.
+    $count = $connection->select('watchdog')->countQuery()->execute()->fetchField();
+    $log = [
+      'channel'     => 'system',
+      'message'     => 'Log entry added to test the doClearTest clear down.',
+      'variables'   => [],
+      'severity'    => RfcLogLevel::NOTICE,
+      'link'        => NULL,
+      'uid'         => $this->adminUser->id(),
+      'request_uri' => $base_root . \Drupal::request()->getRequestUri(),
+      'referer'     => \Drupal::request()->server->get('HTTP_REFERER'),
+      'ip'          => '127.0.0.1',
+      'timestamp'   => \Drupal::time()->getRequestTime(),
+    ];
+    // Add a watchdog entry.
+    $this->container->get('logger.dblog')->log($log['severity'], $log['message'], $log);
+    // Make sure the table count has actually been incremented.
+    $this->assertEquals($count + 1, (int) $connection->select('watchdog')->countQuery()->execute()->fetchField(), '\Drupal\dblog\Logger\DbLog->log() added an entry to the dblog ' . $count);
+    // Log in the admin user.
+    $this->drupalLogin($this->adminUser);
+    // Post in order to clear the database table.
+    $this->clearLogsEntries();
+    // Confirm that the logs should be cleared.
+    $this->submitForm([], 'Confirm');
+    // Count the rows in watchdog that previously related to the deleted user.
+    $count = $connection->select('watchdog')->countQuery()->execute()->fetchField();
+    $this->assertEquals(0, $count, "DBLog contains $count records after a clear.");
+  }
+
+  /**
+   * Tests the database log filter functionality at admin/reports/dblog.
+   */
+  public function testFilter(): void {
+    $this->drupalLogin($this->adminUser);
+
+    // Clear the log to ensure that only generated entries will be found.
+    Database::getConnection()->delete('watchdog')->execute();
+
+    // Generate 9 random watchdog entries.
+    $type_names = [];
+    $types = [];
+    for ($i = 0; $i < 3; $i++) {
+      $type_names[] = $type_name = $this->randomMachineName();
+      $severity = RfcLogLevel::EMERGENCY;
+      for ($j = 0; $j < 3; $j++) {
+        $types[] = $type = [
+          'count' => $j + 1,
+          'type' => $type_name,
+          'severity' => $severity++,
+        ];
+        $this->generateLogEntries($type['count'], [
+          'channel' => $type['type'],
+          'severity' => $type['severity'],
+        ]);
+      }
+    }
+
+    // View the database log page.
+    $this->drupalGet('admin/reports/dblog');
+
+    // Confirm that all the entries are displayed.
+    $count = $this->getTypeCount($types);
+    foreach ($types as $key => $type) {
+      $this->assertEquals($type['count'], $count[$key], 'Count matched');
+    }
+
+    // Filter by each type and confirm that entries with various severities are
+    // displayed.
+    foreach ($type_names as $type_name) {
+      $this->filterLogsEntries($type_name);
+
+      // Count the number of entries of this type.
+      $type_count = 0;
+      foreach ($types as $type) {
+        if ($type['type'] == $type_name) {
+          $type_count += $type['count'];
+        }
+      }
+
+      $count = $this->getTypeCount($types);
+      $this->assertEquals($type_count, array_sum($count), 'Count matched');
+    }
+
+    // Set the filter to match each of the two filter-type attributes and
+    // confirm the correct number of entries are displayed.
+    foreach ($types as $type) {
+      $this->filterLogsEntries($type['type'], $type['severity']);
+
+      $count = $this->getTypeCount($types);
+      $this->assertEquals($type['count'], array_sum($count), 'Count matched');
+    }
+
+    $this->drupalGet('admin/reports/dblog', ['query' => ['order' => 'Type']]);
+    $this->assertSession()->statusCodeEquals(200);
+    $this->assertSession()->pageTextContains('Operations');
+    $this->assertSession()->fieldExists('edit-type');
+
+    // Clear all logs and make sure the confirmation message is found.
+    $this->clearLogsEntries();
+    // Confirm that the logs should be cleared.
+    $this->submitForm([], 'Confirm');
+    $this->assertSession()->pageTextContains('Database log cleared.');
+    $this->assertSession()->fieldNotExists('edit-type');
+  }
+
+  /**
+   * Gets the database log event information from the browser page.
+   *
+   * @return array
+   *   List of log events where each event is an array with following keys:
+   *   - severity: (int) A database log severity constant.
+   *   - type: (string) The type of database log event.
+   *   - message: (string) The message for this database log event.
+   *   - user: (string) The user associated with this database log event.
+   */
+  protected function getLogEntries() {
+    $entries = [];
+    if ($table = $this->getLogsEntriesTable()) {
+      foreach ($table as $row) {
+        $cells = $row->findAll('css', 'td');
+        $entries[] = [
+          'severity' => $this->getSeverityConstant($row->getAttribute('class')),
+          'type' => $cells[1]->getText(),
+          'message' => $cells[3]->getText(),
+          'user' => $cells[4]->getText(),
+        ];
+      }
+    }
+    return $entries;
+  }
+
+  /**
+   * Find the Logs table in the DOM.
+   *
+   * @return \SimpleXMLElement[]
+   *   The return value of a xpath search.
+   */
+  protected function getLogsEntriesTable() {
+    return $this->xpath('.//table[@id="admin-dblog"]/tbody/tr');
+  }
+
+  /**
+   * Gets the count of database log entries by database log event type.
+   *
+   * @param array $types
+   *   The type information to compare against.
+   *
+   * @return array
+   *   The count of each type keyed by the key of the $types array.
+   */
+  protected function getTypeCount(array $types) {
+    $entries = $this->getLogEntries();
+    $count = array_fill(0, count($types), 0);
+    foreach ($entries as $entry) {
+      foreach ($types as $key => $type) {
+        if ($entry['type'] == $type['type'] && $entry['severity'] == $type['severity']) {
+          $count[$key]++;
+          break;
+        }
+      }
+    }
+    return $count;
+  }
+
+  /**
+   * Gets the watchdog severity constant corresponding to the CSS class.
+   *
+   * @param string $class
+   *   CSS class attribute.
+   *
+   * @return int|null
+   *   The watchdog severity constant or NULL if not found.
+   */
+  protected function getSeverityConstant($class) {
+    $map = array_flip(DbLogController::getLogLevelClassMap());
+
+    // Find the class that contains the severity.
+    $classes = explode(' ', $class);
+    foreach ($classes as $class) {
+      if (isset($map[$class])) {
+        return $map[$class];
+      }
+    }
+    return NULL;
+  }
+
+  /**
+   * Confirms that a log message appears on the database log overview screen.
+   *
+   * This function should only be used for the admin/reports/dblog page, because
+   * it checks for the message link text truncated to 56 characters. Other log
+   * pages have no detail links so they contain the full message text.
+   *
+   * @param string $log_message
+   *   The database log message to check.
+   * @param string $message
+   *   A message to display if the assertion fails.
+   *
+   * @internal
+   */
+  protected function assertLogMessage(string $log_message, string $message): void {
+    $message_text = Unicode::truncate($log_message, 56, TRUE, TRUE);
+    $this->assertSession()->linkExists($message_text, 0, $message);
+  }
+
+  /**
+   * Tests that the details page displays correctly for a temporary user.
+   */
+  public function testTemporaryUser(): void {
+    // Create a temporary user.
+    $temporary_user = $this->drupalCreateUser();
+    $temporary_user_uid = $temporary_user->id();
+
+    // Log in as the admin user.
+    $this->drupalLogin($this->adminUser);
+
+    // Generate a single watchdog entry.
+    $this->generateLogEntries(1, ['user' => $temporary_user, 'uid' => $temporary_user_uid]);
+    $query = Database::getConnection()->select('watchdog');
+    $query->addExpression('MAX([wid])');
+    $wid = $query->execute()->fetchField();
+
+    // Check if the full message displays on the details page.
+    $this->drupalGet('admin/reports/dblog/event/' . $wid);
+    $this->assertSession()->pageTextContains('Dblog test log message');
+
+    // Delete the user.
+    $temporary_user->delete();
+    $this->drupalGet('user/' . $temporary_user_uid);
+    $this->assertSession()->statusCodeEquals(404);
+
+    // Check if the full message displays on the details page.
+    $this->drupalGet('admin/reports/dblog/event/' . $wid);
+    $this->assertSession()->pageTextContains('Dblog test log message');
+  }
+
+  /**
+   * Make sure HTML tags are filtered out in the log overview links.
+   */
+  public function testOverviewLinks(): void {
+    $this->drupalLogin($this->adminUser);
+    // cSpell:disable-next-line
+    $this->generateLogEntries(1, ['message' => "&lt;script&gt;alert('foo');&lt;/script&gt;<strong>Lorem</strong> ipsum dolor sit amet, consectetur adipiscing & elit."]);
+    $this->drupalGet('admin/reports/dblog');
+    $this->assertSession()->statusCodeEquals(200);
+    // Make sure HTML tags are filtered out.
+    $this->assertSession()->responseContains('title="alert(&#039;foo&#039;);Lorem');
+    $this->assertSession()->responseNotContains("<script>alert('foo');</script>");
+
+    // Make sure HTML tags are filtered out in admin/reports/dblog/event/ too.
+    $this->generateLogEntries(1, ['message' => "<script>alert('foo');</script> <strong>Lorem ipsum</strong>"]);
+    $query = Database::getConnection()->select('watchdog');
+    $query->addExpression('MAX([wid])');
+    $wid = $query->execute()->fetchField();
+    $this->drupalGet('admin/reports/dblog/event/' . $wid);
+    $this->assertSession()->responseNotContains("<script>alert('foo');</script>");
+    $this->assertSession()->responseContains("alert('foo'); <strong>Lorem ipsum</strong>");
+  }
+
+  /**
+   * Tests sorting for entries with the same timestamp.
+   */
+  public function testSameTimestampEntries(): void {
+    $this->drupalLogin($this->adminUser);
+
+    $this->generateLogEntries(1, ['timestamp' => 1498062000, 'type' => 'same_time', 'message' => 'First']);
+    $this->generateLogEntries(1, ['timestamp' => 1498062000, 'type' => 'same_time', 'message' => 'Second']);
+    $this->generateLogEntries(1, ['timestamp' => 1498062000, 'type' => 'same_time', 'message' => 'Third']);
+
+    $this->drupalGet('admin/reports/dblog');
+
+    $entries = $this->getLogEntries();
+    $this->assertEquals('Third Entry #0', $entries[0]['message']);
+    $this->assertEquals('Second Entry #0', $entries[1]['message']);
+    $this->assertEquals('First Entry #0', $entries[2]['message']);
+  }
+
+  /**
+   * Tests that the details page displays correctly backtrace.
+   */
+  public function testBacktrace(): void {
+    $this->drupalLogin($this->adminUser);
+    $this->drupalGet('/error-test/generate-warnings');
+
+    $query = Database::getConnection()->select('watchdog');
+    $query->addExpression('MAX([wid])');
+    $wid = $query->execute()->fetchField();
+    $this->drupalGet('admin/reports/dblog/event/' . $wid);
+
+    $error_user_notice = [
+      '%type' => 'User warning',
+      '@message' => 'Drupal & awesome',
+      '%function' => ErrorTestController::class . '->generateWarnings()',
+      '%file' => $this->getModulePath('error_test') . '/error_test.module',
+    ];
+
+    // Check if the full message displays on the details page and backtrace is a
+    // pre-formatted text.
+    $message = new FormattableMarkup('%type: @message in %function (line', $error_user_notice);
+    $this->assertSession()->responseContains($message);
+    $this->assertSession()->responseContains('<pre class="backtrace">');
+  }
+
+}

core/modules/dblog/tests/src/Functional/DbLogViewsTest.php

@@ -0,0 +1,72 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\dblog\Functional;
+
+use Drupal\views\Views;
+
+/**
+ * Verifies user access to log reports based on permissions.
+ *
+ * @see Drupal\dblog\Tests\DbLogTest
+ *
+ * @group dblog
+ * @group #slow
+ */
+class DbLogViewsTest extends DbLogTest {
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  protected static $modules = [
+    'dblog',
+    'node',
+    'help',
+    'block',
+    'views',
+  ];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected $defaultTheme = 'stark';
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getLogsEntriesTable() {
+    return $this->xpath('.//div[contains(@class, "views-element-container")]//table/tbody/tr');
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function filterLogsEntries($type = NULL, $severity = NULL) {
+    $query = [];
+    if (isset($type)) {
+      $query['type[]'] = $type;
+    }
+    if (isset($severity)) {
+      $query['severity[]'] = $severity;
+    }
+
+    $this->drupalGet('admin/reports/dblog', ['query' => $query]);
+  }
+
+  /**
+   * Tests the empty text for the watchdog view is not using an input format.
+   */
+  public function testEmptyText(): void {
+    $view = Views::getView('watchdog');
+    $data = $view->storage->toArray();
+    $area = $data['display']['default']['display_options']['empty']['area'];
+
+    $this->assertEquals('text_custom', $area['plugin_id']);
+    $this->assertEquals('area_text_custom', $area['field']);
+    $this->assertEquals('No log messages available.', $area['content']);
+  }
+
+}

core/modules/dblog/tests/src/Functional/FakeLogEntries.php

@@ -0,0 +1,66 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\dblog\Functional;
+
+use Drupal\Core\Logger\RfcLogLevel;
+use Drupal\Core\Session\AnonymousUserSession;
+
+/**
+ * Provides methods to generate log entries.
+ *
+ * This trait is meant to be used only by test classes.
+ */
+trait FakeLogEntries {
+
+  /**
+   * Generates a number of random database log events.
+   *
+   * @param int $count
+   *   Number of watchdog entries to generate.
+   * @param array $options
+   *   These options are used to override the defaults for the test.
+   *   An associative array containing any of the following keys:
+   *   - 'channel': String identifying the log channel to be output to.
+   *     If the channel is not set, the default of 'custom' will be used.
+   *   - 'message': String containing a message to be output to the log.
+   *     A simple default message is used if not provided.
+   *   - 'variables': Array of variables that match the message string.
+   *   - 'severity': Log severity level as defined in logging_severity_levels.
+   *   - 'link': String linking to view the result of the event.
+   *   - 'uid': Int identifying the user id for the user.
+   *   - 'request_uri': String identifying the location of the request.
+   *   - 'referer': String identifying the referring URL.
+   *   - 'ip': String The ip address of the client machine triggering the log
+   *     entry.
+   *   - 'timestamp': Int unix timestamp.
+   */
+  private function generateLogEntries($count, $options = []) {
+    global $base_root;
+
+    $user = !empty($this->adminUser) ? $this->adminUser : new AnonymousUserSession();
+
+    // Prepare the fields to be logged.
+    $log = $options + [
+      'channel'     => 'custom',
+      'message'     => 'Dblog test log message',
+      'variables'   => [],
+      'severity'    => RfcLogLevel::NOTICE,
+      'link'        => NULL,
+      'uid'         => $user->id(),
+      'request_uri' => $base_root . \Drupal::request()->getRequestUri(),
+      'referer'     => \Drupal::request()->server->get('HTTP_REFERER'),
+      'ip'          => '127.0.0.1',
+      'timestamp'   => \Drupal::time()->getRequestTime(),
+    ];
+
+    $logger = $this->container->get('logger.dblog');
+    $message = $log['message'] . ' Entry #';
+    for ($i = 0; $i < $count; $i++) {
+      $log['message'] = $message . $i;
+      $logger->log($log['severity'], $log['message'], $log);
+    }
+  }
+
+}

core/modules/dblog/tests/src/Functional/GenericTest.php

@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\dblog\Functional;
+
+use Drupal\Tests\system\Functional\Module\GenericModuleTestBase;
+
+/**
+ * Generic module test for dblog.
+ *
+ * @group dblog
+ */
+class GenericTest extends GenericModuleTestBase {}

core/modules/dblog/tests/src/Functional/UpdatePathTest.php

@@ -0,0 +1,85 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\dblog\Functional;
+
+use Drupal\Core\Database\Database;
+use Drupal\Core\Logger\RfcLogLevel;
+use Drupal\FunctionalTests\Update\UpdatePathTestBase;
+
+/**
+ * Tests update functions for the Database Logging module.
+ *
+ * @group dblog
+ */
+class UpdatePathTest extends UpdatePathTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setDatabaseDumpFiles() {
+    $this->databaseDumpFiles = [
+      __DIR__ . '/../../../../system/tests/fixtures/update/drupal-9.4.0.bare.standard.php.gz',
+    ];
+  }
+
+  /**
+   * Tests that, after update 10101, the 'wid' column can be a 64-bit integer.
+   */
+  public function testLogEntryWithBigId(): void {
+    if (PHP_INT_SIZE < 8) {
+      $this->markTestSkipped('This test can only be run on a system that supports 64-bit integers (i.e., PHP_INT_SIZE is 8).');
+    }
+    $this->runUpdates();
+
+    global $base_root;
+
+    $connection = Database::getConnection();
+    // Insert a row with a big value for wid.
+    $insert = $connection->insert('watchdog');
+    $insert->fields([
+      'wid'         => 2147483647000,
+      'message'     => 'Dblog test log message with big WID',
+      'type'        => 'test',
+      'variables'   => '',
+      'severity'    => RfcLogLevel::NOTICE,
+      'uid'         => 1,
+      'location'    => $base_root . \Drupal::request()->getRequestUri(),
+      'hostname'    => $base_root,
+      'timestamp'   => \Drupal::time()->getRequestTime(),
+    ]);
+    $insert->execute();
+
+    // Insert another row without a value for wid, to test auto-increment.
+    $insert = $connection->insert('watchdog');
+    $insert->fields([
+      'message'     => 'Dblog test log message with big WID',
+      'type'        => 'test',
+      'variables'   => '',
+      'severity'    => RfcLogLevel::NOTICE,
+      'uid'         => 1,
+      'location'    => $base_root . \Drupal::request()->getRequestUri(),
+      'hostname'    => $base_root,
+      'timestamp'   => \Drupal::time()->getRequestTime(),
+    ]);
+    $insert->execute();
+
+    // Test that the first row exists with the expected value for wid.
+    $result = $connection->select('watchdog')
+      ->fields('watchdog', ['wid'])
+      ->condition('wid', 2147483647000)
+      ->execute()
+      ->fetchAssoc();
+    $this->assertNotEmpty($result, 'The row with a big value for wid exists.');
+
+    // Test that the second row exists with the expected value for wid.
+    $result = $connection->select('watchdog')
+      ->fields('watchdog', ['wid'])
+      ->condition('wid', 2147483647000 + 1)
+      ->execute()
+      ->fetchAssoc();
+    $this->assertNotEmpty($result, 'The row without a value for wid exists, and has the correct auto-incremented value for wid.');
+  }
+
+}

core/modules/dblog/tests/src/Kernel/ConnectionFailureTest.php

@@ -0,0 +1,51 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\dblog\Kernel;
+
+use Drupal\Core\Database\Database;
+use Drupal\KernelTests\KernelTestBase;
+
+/**
+ * Tests logging of connection failures.
+ *
+ * @group dblog
+ */
+class ConnectionFailureTest extends KernelTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $modules = ['dblog'];
+
+  /**
+   * Tests logging of connection failures.
+   */
+  public function testConnectionFailureLogging(): void {
+    $this->installSchema('dblog', ['watchdog']);
+
+    // MySQL errors like "1153 - Got a packet bigger than 'max_allowed_packet'
+    // bytes" or "1100 - Table 'xyz' was not locked with LOCK TABLES" lead to a
+    // database connection unusable for further requests. All further request
+    // will result in a "2006 - MySQL server had gone away" error. As a
+    // consequence it's impossible to use this connection to log the causing
+    // initial error itself. Using Database::closeConnection() we simulate such
+    // a corrupted connection. In this case dblog has to establish a different
+    // connection by itself to be able to write the log entry.
+    Database::closeConnection();
+
+    // Create a log entry.
+    $this->container->get('logger.factory')->get('php')->error('testConnectionFailureLogging');
+
+    // Re-establish the default database connection.
+    $database = Database::getConnection();
+
+    $query = $database->select('watchdog')
+      ->condition('message', 'testConnectionFailureLogging');
+    $query->addExpression('MAX([wid])');
+    $wid = $query->execute()->fetchField();
+    $this->assertNotEmpty($wid, 'Watchdog entry has been stored in database.');
+  }
+
+}

core/modules/dblog/tests/src/Kernel/DbLogControllerTest.php

@@ -0,0 +1,84 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\dblog\Kernel;
+
+use Drupal\dblog\Controller\DbLogController;
+use Drupal\KernelTests\KernelTestBase;
+
+/**
+ * Tests for the DbLogController class.
+ *
+ * @group dblog
+ */
+class DbLogControllerTest extends KernelTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $modules = ['dblog', 'user'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp(): void {
+    parent::setUp();
+    $this->installEntitySchema('user');
+    $this->installSchema('dblog', ['watchdog']);
+  }
+
+  /**
+   * Tests links with non latin characters.
+   */
+  public function testNonLatinCharacters(): void {
+
+    $link = 'hello-
+      科州的小九寨沟绝美高山湖泊酱凉拌素鸡照烧鸡黄玫瑰
+      科州的小九寨沟绝美高山湖泊酱凉拌素鸡照烧鸡黄玫瑰
+      科州的小九寨沟绝美高山湖泊酱凉拌素鸡照烧鸡黄玫瑰
+      科州的小九寨沟绝美高山湖泊酱凉拌素鸡照烧鸡黄玫瑰
+      科州的小九寨沟绝美高山湖泊酱凉拌素鸡照烧鸡黄玫瑰
+      科州的小九寨沟绝美高山湖泊酱凉拌素鸡照烧鸡黄玫瑰
+      科州的小九寨沟绝美高山湖泊酱凉拌素鸡照烧鸡黄玫瑰
+      科州的小九寨沟绝美高山湖泊酱凉拌素鸡照烧鸡黄玫瑰
+      科州的小九寨沟绝美高山湖泊酱凉拌素鸡照烧鸡黄玫瑰
+      科州的小九寨沟绝美高山湖泊酱凉拌素鸡照烧鸡黄玫瑰
+      科州的小九寨沟绝美高山湖泊酱凉拌素鸡照烧鸡黄玫瑰
+      科州的小九寨沟绝美高山湖泊酱凉拌素鸡照烧鸡黄玫瑰
+      科州的小九寨沟绝美高山湖泊酱凉拌素鸡照烧鸡黄玫瑰
+      科州的小九寨沟绝美高山湖泊酱凉拌素鸡照烧鸡黄玫瑰';
+
+    \Drupal::logger('my_module')->warning('test', ['link' => $link]);
+
+    $log = \Drupal::database()
+      ->select('watchdog', 'w')
+      ->fields('w', ['link'])
+      ->condition('link', '', '<>')
+      ->execute()
+      ->fetchField();
+
+    $this->assertEquals($log, $link);
+  }
+
+  /**
+   * Tests corrupted log entries can still display available data.
+   */
+  public function testDbLogCorrupted(): void {
+    $dblog_controller = DbLogController::create($this->container);
+
+    // Check message with properly serialized data.
+    $message = (object) [
+      'message' => 'Sample message with placeholder: @placeholder',
+      'variables' => serialize(['@placeholder' => 'test placeholder']),
+    ];
+
+    $this->assertEquals('Sample message with placeholder: test placeholder', $dblog_controller->formatMessage($message));
+
+    // Check that controller work with corrupted data.
+    $message->variables = 'BAD SERIALIZED DATA';
+    $formatted = $dblog_controller->formatMessage($message);
+    $this->assertEquals('Log data is corrupted and cannot be unserialized: Sample message with placeholder: @placeholder', $formatted);
+  }
+
+}

core/modules/dblog/tests/src/Kernel/DbLogFormInjectionTest.php

@@ -0,0 +1,109 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\dblog\Kernel;
+
+use Drupal\Core\DependencyInjection\DependencySerializationTrait;
+use Drupal\Core\Form\FormInterface;
+use Drupal\Core\Form\FormState;
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\KernelTests\KernelTestBase;
+use Drupal\user\Entity\User;
+
+/**
+ * Tests serializing a form with an injected dblog logger instance.
+ *
+ * @group dblog
+ */
+class DbLogFormInjectionTest extends KernelTestBase implements FormInterface {
+
+  use DependencySerializationTrait;
+
+  /**
+   * A Dblog logger instance.
+   *
+   * @var \Psr\Log\LoggerInterface
+   */
+  protected $logger;
+
+  /**
+   * Modules to enable.
+   *
+   * @var array
+   */
+  protected static $modules = ['system', 'dblog', 'user'];
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getFormId() {
+    return 'dblog_test_injection_form';
+  }
+
+  /**
+   * Process callback.
+   *
+   * @param array $element
+   *   Form element
+   *
+   * @return array
+   *   Processed element.
+   */
+  public function process($element) {
+    return $element;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function buildForm(array $form, FormStateInterface $form_state) {
+    $form['#process'][] = [$this, 'process'];
+    return $form;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function validateForm(array &$form, FormStateInterface $form_state) {}
+
+  /**
+   * {@inheritdoc}
+   */
+  public function submitForm(array &$form, FormStateInterface $form_state) {
+    $form_state->setRebuild();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp(): void {
+    parent::setUp();
+    $this->installSchema('dblog', ['watchdog']);
+    $this->installEntitySchema('user');
+    $this->logger = \Drupal::logger('test_logger');
+    $test_user = User::create([
+      'name' => 'foobar',
+      'mail' => 'foobar@example.com',
+    ]);
+    $test_user->save();
+    \Drupal::service('current_user')->setAccount($test_user);
+  }
+
+  /**
+   * Tests db log injection serialization.
+   */
+  public function testLoggerSerialization(): void {
+    $form_state = new FormState();
+
+    // Forms are only serialized during POST requests.
+    $form_state->setRequestMethod('POST');
+    $form_state->setCached();
+    $form_builder = $this->container->get('form_builder');
+    $form_id = $form_builder->getFormId($this, $form_state);
+    $form = $form_builder->retrieveForm($form_id, $form_state);
+    $form_builder->prepareForm($form_id, $form, $form_state);
+    $form_builder->processForm($form_id, $form, $form_state);
+  }
+
+}

core/modules/dblog/tests/src/Kernel/DbLogTest.php

@@ -0,0 +1,106 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\dblog\Kernel;
+
+use Drupal\Core\Database\Database;
+use Drupal\KernelTests\KernelTestBase;
+use Drupal\Tests\dblog\Functional\FakeLogEntries;
+
+/**
+ * Generate events and verify dblog entries.
+ *
+ * @group dblog
+ */
+class DbLogTest extends KernelTestBase {
+
+  use FakeLogEntries;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $modules = ['dblog', 'system'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp(): void {
+    parent::setUp();
+
+    $this->installSchema('dblog', ['watchdog']);
+    $this->installConfig(['system']);
+  }
+
+  /**
+   * Tests that cron correctly applies the database log row limit.
+   */
+  public function testDbLogCron(): void {
+    $row_limit = 100;
+    // Generate additional log entries.
+    $this->generateLogEntries($row_limit + 10);
+    // Verify that the database log row count exceeds the row limit.
+    $count = Database::getConnection()->select('watchdog')->countQuery()->execute()->fetchField();
+    $this->assertGreaterThan($row_limit, $count, "Dblog row count of $count exceeds row limit of $row_limit");
+
+    // Get the number of enabled modules. Cron adds a log entry for each module.
+    $implementation_count = 0;
+    \Drupal::moduleHandler()->invokeAllWith(
+      'cron',
+      function (callable $hook, string $module) use (&$implementation_count) {
+        $implementation_count++;
+      }
+    );
+
+    $cron_detailed_count = $this->runCron();
+    $expected_count = $implementation_count + 2;
+    $this->assertEquals($expected_count, $cron_detailed_count, "Cron added $cron_detailed_count of $expected_count new log entries");
+
+    // Test disabling of detailed cron logging.
+    $this->config('system.cron')->set('logging', FALSE)->save();
+    $cron_count = $this->runCron();
+    $this->assertEquals(1, $cron_count, "Cron added $cron_count of 1 new log entries");
+  }
+
+  /**
+   * Tests that only valid placeholders are stored in the variables column.
+   */
+  public function testInvalidPlaceholders(): void {
+    \Drupal::logger('my_module')->warning('Hello @string @array @object', ['@string' => '', '@array' => [], '@object' => new \stdClass()]);
+    $variables = \Drupal::database()
+      ->select('watchdog', 'w')
+      ->fields('w', ['variables'])
+      ->orderBy('wid', 'DESC')
+      ->range(0, 1)
+      ->execute()
+      ->fetchField();
+    $this->assertSame(serialize(['@string' => '']), $variables);
+  }
+
+  /**
+   * Runs cron and returns number of new log entries.
+   *
+   * @return int
+   *   Number of new watchdog entries.
+   */
+  private function runCron() {
+    $connection = Database::getConnection();
+    // Get last ID to compare against; log entries get deleted, so we can't
+    // reliably add the number of newly created log entries to the current count
+    // to measure number of log entries created by cron.
+    $query = $connection->select('watchdog');
+    $query->addExpression('MAX([wid])');
+    $last_id = $query->execute()->fetchField();
+
+    // Run a cron job.
+    $this->container->get('cron')->run();
+
+    // Get last ID after cron was run.
+    $query = $connection->select('watchdog');
+    $query->addExpression('MAX([wid])');
+    $current_id = $query->execute()->fetchField();
+
+    return $current_id - $last_id;
+  }
+
+}

core/modules/dblog/tests/src/Kernel/Migrate/d6/MigrateDblogConfigsTest.php

@@ -0,0 +1,46 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\dblog\Kernel\Migrate\d6;
+
+use Drupal\Tests\SchemaCheckTestTrait;
+use Drupal\Tests\migrate_drupal\Kernel\d6\MigrateDrupal6TestBase;
+
+/**
+ * Upgrade variables to dblog.settings.yml.
+ *
+ * @group migrate_drupal_6
+ */
+class MigrateDblogConfigsTest extends MigrateDrupal6TestBase {
+
+  use SchemaCheckTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $modules = ['dblog'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp(): void {
+    parent::setUp();
+    // Enable dblog in the source database so that requirements are met.
+    $this->sourceDatabase->update('system')
+      ->condition('name', 'dblog')
+      ->fields(['status' => '1'])
+      ->execute();
+    $this->executeMigration('d6_dblog_settings');
+  }
+
+  /**
+   * Tests migration of dblog variables to dblog.settings.yml.
+   */
+  public function testDblogSettings(): void {
+    $config = $this->config('dblog.settings');
+    $this->assertSame(10000, $config->get('row_limit'));
+    $this->assertConfigSchema(\Drupal::service('config.typed'), 'dblog.settings', $config->get());
+  }
+
+}

core/modules/dblog/tests/src/Kernel/Migrate/d7/MigrateDblogConfigsTest.php

@@ -0,0 +1,38 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\dblog\Kernel\Migrate\d7;
+
+use Drupal\Tests\migrate_drupal\Kernel\d7\MigrateDrupal7TestBase;
+
+/**
+ * Upgrade variables to dblog.settings.yml.
+ *
+ * @group migrate_drupal_7
+ */
+class MigrateDblogConfigsTest extends MigrateDrupal7TestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $modules = ['dblog'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp(): void {
+    parent::setUp();
+    $this->installConfig(static::$modules);
+    $this->executeMigration('d7_dblog_settings');
+  }
+
+  /**
+   * Tests migration of dblog variables to dblog.settings.yml.
+   */
+  public function testDblogSettings(): void {
+    $config = $this->config('dblog.settings');
+    $this->assertSame(10000, $config->get('row_limit'));
+  }
+
+}

core/modules/dblog/tests/src/Kernel/Views/ViewsIntegrationTest.php

@@ -0,0 +1,232 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drupal\Tests\dblog\Kernel\Views;
+
+use Drupal\Component\Render\FormattableMarkup;
+use Drupal\Component\Utility\Xss;
+use Drupal\Core\Logger\RfcLogLevel;
+use Drupal\Core\Link;
+use Drupal\Core\Url;
+use Drupal\Tests\views\Kernel\ViewsKernelTestBase;
+use Drupal\views\Views;
+use Drupal\views\Tests\ViewTestData;
+
+/**
+ * Tests the views integration of dblog module.
+ *
+ * @group dblog
+ */
+class ViewsIntegrationTest extends ViewsKernelTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public static $testViews = ['test_dblog', 'dblog_integration_test'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $modules = ['dblog', 'dblog_test_views', 'user'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected $columnMap = ['watchdog_message' => 'message'];
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp($import_test_views = TRUE): void {
+    parent::setUp();
+
+    $this->installEntitySchema('user');
+    $this->installSchema('dblog', ['watchdog']);
+
+    ViewTestData::createTestViews(static::class, ['dblog_test_views']);
+  }
+
+  /**
+   * Tests the messages escaping functionality.
+   */
+  public function testMessages(): void {
+
+    // Remove the watchdog entries added by the potential batch process.
+    $this->container->get('database')->truncate('watchdog')->execute();
+
+    $entries = $this->createLogEntries();
+
+    $view = Views::getView('test_dblog');
+    $this->executeView($view);
+    $view->initStyle();
+
+    foreach ($entries as $index => $entry) {
+      if (!isset($entry['variables'])) {
+        continue;
+      }
+      $message_vars = $entry['variables'];
+      unset($message_vars['link']);
+      $this->assertEquals(new FormattableMarkup($entry['message'], $message_vars), $view->style_plugin->getField($index, 'message'));
+      $link_field = $view->style_plugin->getField($index, 'link');
+      // The 3rd entry contains some unsafe markup that needs to get filtered.
+      if ($index == 2) {
+        // Make sure that unsafe link differs from the rendered link, so we know
+        // that some filtering actually happened. We use assertNotSame and cast
+        // values to strings since HTML tags are significant.
+        $this->assertNotSame((string) $entry['variables']['link'], (string) $link_field);
+      }
+      $this->assertSame(Xss::filterAdmin($entry['variables']['link']), (string) $link_field);
+    }
+
+    // Disable replacing variables and check that the tokens aren't replaced.
+    $view->destroy();
+    $view->storage->invalidateCaches();
+    $view->initHandlers();
+    $this->executeView($view);
+    $view->initStyle();
+    $view->field['message']->options['replace_variables'] = FALSE;
+    foreach ($entries as $index => $entry) {
+      $this->assertEquals($entry['message'], $view->style_plugin->getField($index, 'message'));
+    }
+  }
+
+  /**
+   * Tests the relationship with the users_field_data table.
+   */
+  public function testRelationship(): void {
+    $view = Views::getView('dblog_integration_test');
+    $view->setDisplay('page_1');
+    // The uid relationship should now join to the {users_field_data} table.
+    $base_tables = $view->getBaseTables();
+    $this->assertArrayHasKey('users_field_data', $base_tables);
+    $this->assertArrayNotHasKey('users', $base_tables);
+    $this->assertArrayHasKey('watchdog', $base_tables);
+  }
+
+  /**
+   * Tests views can be filtered by severity and log type.
+   */
+  public function testFiltering(): void {
+    // Remove the watchdog entries added by the potential batch process.
+    $this->container->get('database')->truncate('watchdog')->execute();
+    $this->createLogEntries();
+
+    $view = Views::getView('dblog_integration_test');
+
+    $filters = [
+      'severity' => [
+        'id' => 'severity',
+        'table' => 'watchdog',
+        'field' => 'severity',
+        'relationship' => 'none',
+        'group_type' => 'group',
+        'admin_label' => '',
+        'operator' => 'in',
+        'value' => [
+          RfcLogLevel::WARNING,
+        ],
+        'group' => 1,
+        'exposed' => FALSE,
+        'plugin_id' => 'in_operator',
+      ],
+    ];
+
+    $view->setDisplay('page_1');
+    $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
+    $view->save();
+
+    $this->executeView($view);
+
+    $resultset = [['message' => 'Warning message']];
+    $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
+
+    $view = Views::getView('dblog_integration_test');
+
+    $filters = [
+      'type' => [
+        'id' => 'type',
+        'table' => 'watchdog',
+        'field' => 'type',
+        'relationship' => 'none',
+        'group_type' => 'group',
+        'admin_label' => '',
+        'operator' => 'in',
+        'value' => [
+          'my-module' => 'my-module',
+        ],
+        'group' => '1',
+        'exposed' => FALSE,
+        'is_grouped' => FALSE,
+        'plugin_id' => 'dblog_types',
+      ],
+    ];
+
+    $view->setDisplay('page_1');
+    $view->displayHandlers->get('page_1')->overrideOption('filters', $filters);
+    $view->save();
+
+    $this->executeView($view);
+
+    $resultset = [['message' => 'My module message']];
+    $this->assertIdenticalResultset($view, $resultset, $this->columnMap);
+  }
+
+  /**
+   * Create a set of log entries.
+   *
+   * @return array
+   *   An array of data used to create the log entries.
+   */
+  protected function createLogEntries() {
+    $entries = [];
+    // Setup a watchdog entry without tokens.
+    $entries[] = [
+      'message' => $this->randomMachineName(),
+      'variables' => ['link' => Link::fromTextAndUrl('Link', Url::fromRoute('<front>'))->toString()],
+    ];
+    // Setup a watchdog entry with one token.
+    $entries[] = [
+      'message' => '@token1',
+      'variables' => [
+        '@token1' => $this->randomMachineName(),
+        'link' => Link::fromTextAndUrl('Link', Url::fromRoute('<front>'))->toString(),
+      ],
+    ];
+    // Setup a watchdog entry with two tokens.
+    $entries[] = [
+      'message' => '@token1 @token2',
+      // Setup a link with a tag which is filtered by
+      // \Drupal\Component\Utility\Xss::filterAdmin() in order to make sure
+      // that strings which are not marked as safe get filtered.
+      'variables' => [
+        '@token1' => $this->randomMachineName(),
+        '@token2' => $this->randomMachineName(),
+        'link' => '<a href="' . Url::fromRoute('<front>')->toString() . '"><object>Link</object></a>',
+      ],
+    ];
+    // Setup a watchdog entry with severity WARNING.
+    $entries[] = [
+      'message' => 'Warning message',
+      'severity' => RfcLogLevel::WARNING,
+    ];
+    // Setup a watchdog entry with a different module.
+    $entries[] = [
+      'message' => 'My module message',
+      'severity' => RfcLogLevel::INFO,
+      'type' => 'my-module',
+    ];
+
+    $logger_factory = $this->container->get('logger.factory');
+    foreach ($entries as $entry) {
+      $entry += [
+        'type' => 'test-views',
+        'severity' => RfcLogLevel::NOTICE,
+        'variables' => [],
+      ];
+      $logger_factory->get($entry['type'])->log($entry['severity'], $entry['message'], $entry['variables']);
+    }
+    return $entries;
+  }
+
+}