diff --git a/doc/admin-guide/files/records.yaml.en.rst b/doc/admin-guide/files/records.yaml.en.rst
index 060a65193a4..c4c12c87b8f 100644
--- a/doc/admin-guide/files/records.yaml.en.rst
+++ b/doc/admin-guide/files/records.yaml.en.rst
@@ -3329,7 +3329,7 @@ Diagnostic Logging Configuration
 .. ts:cv:: CONFIG proxy.config.diags.show_location INT 1
 
    Annotates diagnostic messages with the source code location. Set to 1 to enable
-   for Debug() messages only. Set to 2 to enable for all messages.
+   for Dbg() messages only. Set to 2 to enable for all messages.
 
 .. ts:cv:: CONFIG proxy.config.diags.debug.enabled INT 0
    :reloadable:
@@ -3338,10 +3338,6 @@ Diagnostic Logging Configuration
 
    When set to 2, interprets the :ts:cv:`proxy.config.diags.debug.client_ip` setting determine whether diagnostic messages are logged.
 
-   When set to 3, enables logging for diagnostic messages whose log level is `diag` or `debug`, except those
-   output by deprecated functions such as `TSDebug()` and `TSDebugSpecific()`.  Using the value 3 will have less
-   of a negative impact on proxy throughput than using the value 1.
-
 .. ts:cv:: CONFIG proxy.config.diags.debug.client_ip STRING NULL
 
    if :ts:cv:`proxy.config.diags.debug.enabled` is set to 2, this value is tested against the source IP of the incoming connection.  If there is a match, all the diagnostic messages for that connection and the related outgoing connection will be logged.
@@ -3364,9 +3360,6 @@ Diagnostic Logging Configuration
    ssl           TLS termination and certificate processing
    ============  =====================================================
 
-   |TS| plugins will typically log debug messages using the :c:func:`TSDbg`
-   API, passing the plugin name as the debug tag.
-
 .. ts:cv:: CONFIG proxy.config.diags.debug.throttling_interval_msec INT 0
    :reloadable:
    :units: milliseconds
diff --git a/doc/developer-guide/api/functions/TSAPI.en.rst b/doc/developer-guide/api/functions/TSAPI.en.rst
index 799ae810856..d6b19c89e39 100644
--- a/doc/developer-guide/api/functions/TSAPI.en.rst
+++ b/doc/developer-guide/api/functions/TSAPI.en.rst
@@ -103,7 +103,7 @@ The Traffic Server API adheres to the following naming conventions:
   :data:`TS_MIME_FIELD_ACCEPT`.
 
 * The names of defined types are mixed-case. For example, :type:`TSHttpSsn`
-  and :func:`TSHttpTxn`. :func:`TSDebug`
+  and :func:`TSHttpTxn`. :func:`TSContCreate`
 
 * Function names are mixed-case. For example, :func:`TSUrlCreate`
   and :func:`TSContDestroy`.
diff --git a/doc/developer-guide/api/functions/TSDebug.en.rst b/doc/developer-guide/api/functions/TSDebug.en.rst
index 6be89c25900..460cc928b0e 100644
--- a/doc/developer-guide/api/functions/TSDebug.en.rst
+++ b/doc/developer-guide/api/functions/TSDebug.en.rst
@@ -18,8 +18,8 @@
 
 .. default-domain:: c
 
-TSDbg
-*****
+Dbg
+***
 
 Traffic Server Debugging APIs.
 
@@ -37,14 +37,11 @@ Synopsis
 .. function:: void TSFatal(const char * format, ...)
 .. function:: void TSAlert(const char * format, ...)
 .. function:: void TSEmergency(const char * format, ...)
-.. type:: TSDbgCtl
-.. function:: void TSDbg(const TSDbgCtl * ctlptr, const char * format, ...)
-.. function:: const TSDbgCtl * TSDbgCtlCreate(const char * tag)
-.. function:: void TSDbgCtlDestroy(const TSDbgCtl * dbg_ctl)
-.. function:: void TSDebug(const char * tag, const char * format, ...)
-.. function:: int TSIsDbgCtlSet(const TSDbgCtl * ctlptr)
-.. function:: int TSIsDebugTagSet(const char * tag)
-.. function:: void TSDebugSpecific(int debug_flag, const char * tag, const char * format, ...)
+.. cpp:type:: DbgCtl
+.. cpp:function:: void Dbg(DbgCtl &ctl, const char * format, ...)
+.. cpp:function:: bool DbgCtl::on()
+.. cpp:function:: void SpecificDbg(bool debug_flag, DbgCtl &ctl, const char * format, ...)
+.. cpp:function:: void DbgPrint(DbgCtl &ctl, const char * format, ...)
 .. function:: void TSHttpTxnDebugSet(TSHttpTxn txnp, int on)
 .. function:: void TSHttpSsnDebugSet(TSHttpSsn ssn, int on)
 .. function:: int TSHttpTxnDebugGet(TSHttpTxn txnp)
@@ -81,22 +78,14 @@ Traffic Server, AuTest, CI, and your log monitoring service/dashboard (e.g. Splu
 trafficserver.out
 =================
 
-:func:`TSDbg` logs the debug message only if the given debug control pointed to by
-:arg:`ctlptr` is enabled.  It writes output to the Traffic Server debug log through stderr.
-
-:func:`TSDbgCtlCreate` creates a debug control, associated with the
-debug :arg:`tag`, and returns a const pointer to it.
-
-:func:`TSDbgCtlDestroy` destroys a debug control, pointed to by :arg:`dbg_ctl`.
-
-:func:`TSIsDbgCtlSet` returns non-zero if the given debug control, pointed to by :arg:`ctlptr`, is
+cpp:type:`DbgCtl` is a C++ class. Its constructor is ``DbgCtl::DbgCtl(const char *tag)``.  ``tag`` is
+the debug tag for the control, as a null-terminated string.  The control is enabled/on when the tag is
 enabled.
 
-:func:`TSDebug` (deprecated) logs the debug message only if the given debug :arg:`tag` is enabled.
-It writes output to the Traffic Server debug log through stderr.
+cpp:func:`Dbg` logs the debug message only if the given debug control referred to by
+:arg:`ctl` is enabled.  It writes output to the Traffic Server debug log through stderr.
 
-:func:`TSIsDebugTagSet` (deprecated) returns non-zero if the given debug :arg:`tag` is
-enabled.
+``ctl.on()`` (where ``ctl`` is an instance of ``DbgCtl``) returns true if ``ctl`` is on.
 
 In debug mode, :macro:`TSAssert` Traffic Server to prints the file
 name, line number and expression, and then aborts. In release mode,
@@ -104,33 +93,44 @@ the expression is not removed but the effects of printing an error
 message and aborting are. :macro:`TSReleaseAssert` prints an error
 message and aborts in both release and debug mode.
 
-:func:`TSDebugSpecific` emits a debug line even if the debug :arg:`tag`
+cpp:func:`SpecificDbg` emits a debug line even if the debug :arg:`tag`
 is turned off, as long as debug flag is enabled. This can be used
 in conjunction with :func:`TSHttpTxnDebugSet`, :func:`TSHttpSsnDebugSet`,
 :func:`TSHttpTxnDebugGet` and :func:`TSHttpSsnDebugGet` to enable
 debugging on specific session and transaction objects.
 
+cpp:func:`DbgPrint` emits a debug line even if the debug :arg:`tag`
+is turned off.
+
 :func:`TSHttpServerStateNameLookup`, :func:`TSHttpHookNameLookup` and
 :func:`TSHttpEventNameLookup` converts the respective internal state to a
-string representation. This can be useful in debugging (:func:`TSDebug`),
+string representation. This can be useful in debugging (cpp:func:`Dbg`),
 logging and other types notifications.
 
+(Note that cpp:type:`DbgCtl`, cpp:func:`Dbg`, cpp:func:`SpecificDbg` and cpp:func:`DbgPrint`
+are not in the ``tsapi::c`` namespace.)
+
+(For an example of how to write a plugin with debug tracing, that can be
+compiled with both |TS| Version 10 and older versions of ATS, see ``redirect_1``.)
+
 Examples
 ========
 
-This example uses :func:`TSDebugSpecific` to log a message when a specific
+This example uses cpp:func:`SpecificDbg` to log a message when a specific
 debugging flag is enabled::
 
     #include <ts/ts.h>
 
+    DbgCtl dbg_ctl{PLUGIN_NAME};
+
     // Produce information about a hook receiving an event
-    TSDebug(PLUGIN_NAME, "Entering hook=%s, event=%s",
-            TSHttpHookNameLookup(hook), TSHttpEventNameLookup(event));
+    Dbg(dbg_ctl, "Entering hook=%s, event=%s",
+        TSHttpHookNameLookup(hook), TSHttpEventNameLookup(event));
 
-    // Emit debug message if "tag" is enabled or the txn debug
+    // Emit debug message if "dbg_ctl" is enabled or the txn debug
     // flag is set.
-    TSDebugSpecifc(TSHttpTxnDebugGet(txn), "tag" ,
-            "Hello World from transaction %p", txn);
+    SpecificDbg(TSHttpTxnDebugGet(txn), dbg_ctl ,
+                "Hello World from transaction %p", txn);
 
 See Also
 ========
diff --git a/doc/developer-guide/api/functions/TSTrafficServerVersionGet.en.rst b/doc/developer-guide/api/functions/TSTrafficServerVersionGet.en.rst
index 1d98ab992fd..2e6d995ada0 100644
--- a/doc/developer-guide/api/functions/TSTrafficServerVersionGet.en.rst
+++ b/doc/developer-guide/api/functions/TSTrafficServerVersionGet.en.rst
@@ -55,6 +55,8 @@ Example
 
     #define PLUGIN_NAME "hello_world"
 
+    DbgCtl dbg_ctl{PLUGIN_NAME};
+
     int
     check_ts_version()
     {
@@ -98,7 +100,7 @@ Example
             return;
         }
 
-        TSDebug(PLUGIN_NAME, "Hello World!");
+        Dbg(dbg_ctl, "Hello World!");
     }
 
 See Also
diff --git a/doc/developer-guide/debugging/debug-tags.en.rst b/doc/developer-guide/debugging/debug-tags.en.rst
index 9fb73b7def2..9dc203f6526 100644
--- a/doc/developer-guide/debugging/debug-tags.en.rst
+++ b/doc/developer-guide/debugging/debug-tags.en.rst
@@ -23,36 +23,19 @@ Debug Tags
 **********
 
 Use the API macro
-``TSDbg(ctlptr, const char *format_str, ...)`` to add
+``Dbg(ctl, const char *format_str, ...)`` to add
 traces in your plugin. In this macro:
 
--  ``ctlptr`` is the Traffic Server parameter that enables Traffic Server
-   to print out ``format_str``.  It is returned by ``TSDbgCtlCreate()``.
+-  ``ctl`` is the Traffic Server parameter that enables Traffic Server
+   to print out ``format_str``.  It is an instance of the class ``DbgCtl``.
 
 -  ``...`` are variables for ``format_str`` in the standard ``printf``
    style.
 
-``TSDbgCtlCreate (const char *tag)`` returns a (const) pointer to
-``TSDbgCtl``.  The ``TSDbgCtl`` control is enabled when debug output is
+The ``DbgCtl`` control is enabled when debug output is
 enabled globally by configuration, and ``tag`` matches a configured
 regular expression.
 
-``TSDbgCtlDestroy (TSDbgCtl const *dbg_ctl)`` destroys a debug control
-created by ``TSDbgCtlCreast()``.
-
-The deprecated API
-``void TSDebug (const char *tag, const char *format_str, ...)`` also
-outputs traces.  In this API:
-
--  ``tag`` is the Traffic Server parameter that enables Traffic Server
-   to print out ``format_str``
-
--  ``...`` are variables for ``format_str`` in the standard ``printf``
-   style.
-
-Use of ``TSDebug()`` causes trace output to have a more negative impact
-on proxy throughput.
-
 Run Traffic Server with the ``-Ttag`` option. For example, if the tag is
 ``my-plugin``, then the debug output goes to ``traffic.out.``\ See
 below:
@@ -73,25 +56,8 @@ Sets the following variables in :file:`records.yaml` (in the Traffic Server
          tags: debug-tag-name
 
 
-(Performance will be better if ``enabled`` is set to 3 rather than 1, but,
-using 3, output from ``TSDebug()`` will not be enabled, only from ``TSDbg()``.)
 In this case, debug output goes to ``traffic.out``.
 
-Example:
-
-.. code-block:: c
-
-       static TSDbgCtl const *my_dbg_ctl; // Non-local variable.
-       ...
-       my_dbg_ctl = TSDbgCtlCreate("my-plugin"); // In TSPluginInit() or TSRemapInit().
-       ...
-       TSDbg(my_dbg_ctl, "Starting my-plugin at %d", the_time);
-       ...
-       TSDbg(my_dbg_ctl, "Later on in my-plugin");
-       ...
-       TSDbgCtlDestroy(my_dbg_ctl);
-
-
 The statement ``"Starting my-plugin at <time>"`` appears whenever you
 run Traffic Server with the ``my-plugin`` tag:
 
@@ -99,18 +65,18 @@ run Traffic Server with the ``my-plugin`` tag:
 
        traffic_server -T"my-plugin"
 
-If your plugin is a C++ plugin, the above example can be written as:
+Example:
 
 .. code-block:: cpp
 
-       #include <tscpp/api/Cleanup.h>
-       ...
-       static TSDbgCtlUniqPtr my_dbg_ctl_guard{TSDbgCtlCreate("my-plugin")}; // Non-local variable.
-       TSDbgCtl const * const my_dbg_ctl{my_dbg_ctl_guard.get()}; // Non-local variable.
+       namespace
+       {
+       DbgCtl my_dbg_ctl{"my-plugin"}; // Non-local variable.
+       }
        ...
-       TSDbg(my_dbg_ctl, "Starting my-plugin at %d", the_time);
+       Dbg(my_dbg_ctl, "Starting my-plugin at %d", the_time);
        ...
-       TSDbg(my_dbg_ctl, "Later on in my-plugin");
+       Dbg(my_dbg_ctl, "Later on in my-plugin");
 
 Other Useful Internal Debug Tags
 ================================
diff --git a/doc/developer-guide/jsonrpc/jsonrpc-handler-development.en.rst b/doc/developer-guide/jsonrpc/jsonrpc-handler-development.en.rst
index 18cb9d68137..cba7aebf107 100644
--- a/doc/developer-guide/jsonrpc/jsonrpc-handler-development.en.rst
+++ b/doc/developer-guide/jsonrpc/jsonrpc-handler-development.en.rst
@@ -237,9 +237,9 @@ RPC method registration and implementation examples
             }
 
             if (TSRPCRegisterMethodHandler("join_strings", my_join_string_handler, rpcRegistrationInfo) == TS_ERROR) {
-                TSDebug(PLUGIN_NAME, "%s failed to register", rpcCallName.c_str());
+                Dbg(dbg_ctl, "%s failed to register", rpcCallName.c_str());
             } else {
-                TSDebug(PLUGIN_NAME, "%s successfully registered", rpcCallName.c_str());
+                Dbg(dbg_ctl, "%s successfully registered", rpcCallName.c_str());
             }
         }
 
@@ -292,9 +292,9 @@ RPC method registration and implementation examples
             }
 
             if (TSRPCRegisterMethodHandler("merge_yaml_file", merge_yaml_file, rpcRegistrationInfo) == TS_ERROR) {
-                TSDebug(PLUGIN_NAME, "%s failed to register", rpcCallName.c_str());
+                Dbg(dbg_ctl, "%s failed to register", rpcCallName.c_str());
             } else {
-                TSDebug(PLUGIN_NAME, "%s successfully registered", rpcCallName.c_str());
+                Dbg(dbg_ctl, "%s successfully registered", rpcCallName.c_str());
             }
         }
 
diff --git a/doc/developer-guide/plugins/example-plugins/denylist/index.en.rst b/doc/developer-guide/plugins/example-plugins/denylist/index.en.rst
index e08ad46ac1e..ff25e0ba1b9 100644
--- a/doc/developer-guide/plugins/example-plugins/denylist/index.en.rst
+++ b/doc/developer-guide/plugins/example-plugins/denylist/index.en.rst
@@ -74,6 +74,11 @@ that might be sent to it:
 
 .. code-block:: c
 
+   namespace
+   {
+   DbgCtl dbg_ctl{"denylist_plugin"};
+   }
+
    static int
    denylist_plugin (TSCont contp, TSEvent event, void *edata)
    {
@@ -86,7 +91,7 @@ that might be sent to it:
             handle_response (txnp);
             return 0;
          default:
-            TSDebug ("denylist_plugin", "This event was unexpected: %d", );
+            Dbg (dbg_ctl, "This event was unexpected: %d", int(event) );
             break;
       }
       return 0;
diff --git a/doc/developer-guide/plugins/hooks-and-transactions/http-alternate-selection.en.rst b/doc/developer-guide/plugins/hooks-and-transactions/http-alternate-selection.en.rst
index aaa4b3bf5c6..4158df6dc32 100644
--- a/doc/developer-guide/plugins/hooks-and-transactions/http-alternate-selection.en.rst
+++ b/doc/developer-guide/plugins/hooks-and-transactions/http-alternate-selection.en.rst
@@ -89,8 +89,8 @@ The sample code below shows how to call the alternate APIs.
       if (accept_transform_field) {
          TSMimeHdrFieldValueStringGet(client_req_buf, client_req_hdr,
             accept_transform_field, 0, &accept_transform_value, &accept_transform_len);
-         TSDebug(DBG_TAG, "Accept-Transform = |%s|",
-            accept_transform_value);
+         Dbg(dbg_ctl, "Accept-Transform = |%s|",
+             accept_transform_value);
       }
 
       /* get the Content-Transform field value from cached server response */
@@ -99,8 +99,8 @@ The sample code below shows how to call the alternate APIs.
       if (content_transform_field) {
          TSMimeHdrFieldValueStringGet(cache_resp_buf, cache_resp_hdr,
             content_transform_field, 0, &content_transform_value, &content_transform_len);
-         TSDebug(DBG_TAG, "Content-Transform = |%s|",
-            content_transform_value);
+         Dbg(dbg_ctl, "Content-Transform = |%s|",
+             content_transform_value);
       }
 
       /* compute quality */
@@ -118,7 +118,7 @@ The sample code below shows how to call the alternate APIs.
          quality = content_plugin ? 0.0 : 0.5;
       }
 
-      TSDebug(DBG_TAG, "Setting quality to %3.1f", quality);
+      Dbg(dbg_ctl, "Setting quality to %3.1f", quality);
 
       /* set quality for this alternate */
       TSHttpAltInfoQualitySet(infop, quality);
diff --git a/doc/developer-guide/plugins/hooks-and-transactions/http-transactions.en.rst b/doc/developer-guide/plugins/hooks-and-transactions/http-transactions.en.rst
index 85c2d210461..98e83984f64 100644
--- a/doc/developer-guide/plugins/hooks-and-transactions/http-transactions.en.rst
+++ b/doc/developer-guide/plugins/hooks-and-transactions/http-transactions.en.rst
@@ -49,7 +49,10 @@ transaction and associate data to the transaction.
 
     #include <ts/ts.h>
 
-    char const DBG_TAG[] = "txn";
+    namespace
+    {
+    DbgCtl dbg_ctl{"txn"};
+    }
 
     /* Structure to be associated to txns */
     struct TxnData {
@@ -86,7 +89,7 @@ transaction and associate data to the transaction.
 
        case TS_EVENT_HTTP_TXN_CLOSE:
           /* Print txn data values */
-          TSDebug(DBG_TAG, "Txn data i=%d f=%f s=%s", txn_data->i, txn_data->f, txn_data->s);
+          Dbg(dbg_ctl, "Txn data i=%d f=%f s=%s", txn_data->i, txn_data->f, txn_data->s);
 
           /* Then destroy the txn cont and its data */
           delete txn_data;
diff --git a/doc/developer-guide/plugins/plugin-interfaces.en.rst b/doc/developer-guide/plugins/plugin-interfaces.en.rst
index 2c0ffaacd2a..8a61cd89458 100644
--- a/doc/developer-guide/plugins/plugin-interfaces.en.rst
+++ b/doc/developer-guide/plugins/plugin-interfaces.en.rst
@@ -122,12 +122,11 @@ The thread functions are listed below:
 Debugging Functions
 ===================
 
--  :c:func:`TSDbg`
-   (replaces deprecated :c:func:`TSDebug`) prints out a formatted
-   statement if you are running Traffic Server in debug mode.
+-  :cpp:func:`Dbg`
+   prints out a formatted statement if you are
+   running Traffic Server in debug mode.
 
--  :c:func:`TSIsDbgCtlSet`
-   (replaces deprecated :c:func:`TSIsDebugTagSet`)
+-  :cpp:func:`DbgCtl::on`
    checks to see if a debug control (associated with a debug tag) is
    set. If the debug tag is set, then Traffic Server prints out all
    debug statements associated with the control.
diff --git a/doc/release-notes/whats-new.en.rst b/doc/release-notes/whats-new.en.rst
index 3da755e0ab4..600b99c4344 100644
--- a/doc/release-notes/whats-new.en.rst
+++ b/doc/release-notes/whats-new.en.rst
@@ -52,3 +52,5 @@ Switch to C++17
 
 Plugins are now required to be compiled as C++ code, rather than straight C.
 The API is tested with C++17, so code compatible with this version is preferred.
+``TSDebug`` and related functions are removed.  Debug tracing should now be done
+using cpp:func:`Dbg` and related functions, as in |TS| core code.
diff --git a/example/plugins/c-api/cert_update/cert_update.cc b/example/plugins/c-api/cert_update/cert_update.cc
index 115f4ce7729..338815b0fa0 100644
--- a/example/plugins/c-api/cert_update/cert_update.cc
+++ b/example/plugins/c-api/cert_update/cert_update.cc
@@ -31,6 +31,11 @@
 
 #define PLUGIN_NAME "cert_update"
 
+namespace
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 // Plugin Message Continuation
 int
 CB_cert_update(TSCont, TSEvent, void *edata)
@@ -45,25 +50,25 @@ CB_cert_update(TSCont, TSEvent, void *edata)
     tag.remove_prefix(PLUGIN_PREFIX.size());
     if (tag == "server") {
       server_cert_path = static_cast<const char *>(msg->data);
-      TSDebug(PLUGIN_NAME, "Received Msg to update server cert with %s", server_cert_path);
+      Dbg(dbg_ctl, "Received Msg to update server cert with %s", server_cert_path);
     } else if (tag == "client") {
       client_cert_path = static_cast<const char *>(msg->data);
-      TSDebug(PLUGIN_NAME, "Received Msg to update client cert with %s", client_cert_path);
+      Dbg(dbg_ctl, "Received Msg to update client cert with %s", client_cert_path);
     }
   }
 
   if (server_cert_path) {
     if (TS_SUCCESS == TSSslServerCertUpdate(server_cert_path, nullptr)) {
-      TSDebug(PLUGIN_NAME, "Successfully updated server cert with %s", server_cert_path);
+      Dbg(dbg_ctl, "Successfully updated server cert with %s", server_cert_path);
     } else {
-      TSDebug(PLUGIN_NAME, "Failed to update server cert with %s", server_cert_path);
+      Dbg(dbg_ctl, "Failed to update server cert with %s", server_cert_path);
     }
   }
   if (client_cert_path) {
     if (TS_SUCCESS == TSSslClientCertUpdate(client_cert_path, nullptr)) {
-      TSDebug(PLUGIN_NAME, "Successfully updated client cert with %s", client_cert_path);
+      Dbg(dbg_ctl, "Successfully updated client cert with %s", client_cert_path);
     } else {
-      TSDebug(PLUGIN_NAME, "Failed to update client cert with %s", client_cert_path);
+      Dbg(dbg_ctl, "Failed to update client cert with %s", client_cert_path);
     }
   }
   return TS_SUCCESS;
@@ -81,6 +86,6 @@ TSPluginInit(int argc, const char *argv[])
   if (TSPluginRegister(&info) != TS_SUCCESS) {
     TSError("[%s] Plugin registration failed", PLUGIN_NAME);
   }
-  TSDebug(PLUGIN_NAME, "Initialized.");
+  Dbg(dbg_ctl, "Initialized.");
   TSLifecycleHookAdd(TS_LIFECYCLE_MSG_HOOK, TSContCreate(CB_cert_update, nullptr));
 }
diff --git a/example/plugins/c-api/client_context_dump/client_context_dump.cc b/example/plugins/c-api/client_context_dump/client_context_dump.cc
index b0648b32a5c..329eb55b4d0 100644
--- a/example/plugins/c-api/client_context_dump/client_context_dump.cc
+++ b/example/plugins/c-api/client_context_dump/client_context_dump.cc
@@ -36,6 +36,11 @@
 #define PLUGIN_NAME "client_context_dump"
 TSTextLogObject context_dump_log;
 
+namespace
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 char *
 asn1_string_extract(ASN1_STRING *s)
 {
@@ -131,8 +136,8 @@ dump_context(const char *ca_path, const char *ck_path)
         length = BIO_get_mem_data(time_bio, &data);
         time_s = std::string(data, length);
         BIO_free(time_bio);
-        TSDebug(PLUGIN_NAME, "LookupName: %s:%s, Subject: %s. SAN: %s. Serial: %s. NotAfter: %s.", ca_path, ck_path,
-                subject_s.c_str(), san_s.c_str(), serial_s.c_str(), time_s.c_str());
+        Dbg(dbg_ctl, "LookupName: %s:%s, Subject: %s. SAN: %s. Serial: %s. NotAfter: %s.", ca_path, ck_path, subject_s.c_str(),
+            san_s.c_str(), serial_s.c_str(), time_s.c_str());
         TSTextLogObjectWrite(context_dump_log, "LookupName: %s:%s, Subject: %s. SAN: %s. Serial: %s. NotAfter: %s.", ca_path,
                              ck_path, subject_s.c_str(), san_s.c_str(), serial_s.c_str(), time_s.c_str());
       }
@@ -185,6 +190,6 @@ TSPluginInit(int argc, const char *argv[])
     TSError("[%s] Failed to create log file", PLUGIN_NAME);
     return;
   }
-  TSDebug(PLUGIN_NAME, "Initialized.");
+  Dbg(dbg_ctl, "Initialized.");
   TSLifecycleHookAdd(TS_LIFECYCLE_MSG_HOOK, TSContCreate(CB_context_dump, nullptr));
 }
diff --git a/example/plugins/c-api/denylist_1/denylist_1.cc b/example/plugins/c-api/denylist_1/denylist_1.cc
index ce1883a506a..7e20f314395 100644
--- a/example/plugins/c-api/denylist_1/denylist_1.cc
+++ b/example/plugins/c-api/denylist_1/denylist_1.cc
@@ -32,6 +32,7 @@
 #define MAX_NSITES 500
 #define RETRY_TIME 10
 
+static DbgCtl dbg_ctl{PLUGIN_NAME};
 static char *sites[MAX_NSITES];
 static int nsites;
 static TSMutex sites_mutex;
@@ -99,7 +100,7 @@ handle_dns(TSHttpTxn txnp, TSCont contp)
   /* We need to lock the sites_mutex as that is the mutex that is
      protecting the global list of all denylisted sites. */
   if (TSMutexLockTry(sites_mutex) != TS_SUCCESS) {
-    TSDebug(PLUGIN_NAME, "Unable to get lock. Will retry after some time");
+    Dbg(dbg_ctl, "Unable to get lock. Will retry after some time");
     TSHandleMLocRelease(bufp, hdr_loc, url_loc);
     TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
     TSContScheduleOnPool(contp, RETRY_TIME, TS_THREAD_POOL_NET);
@@ -111,7 +112,7 @@ handle_dns(TSHttpTxn txnp, TSCont contp)
       if (ts_log) {
         TSTextLogObjectWrite(ts_log, "denylisting site: %s", sites[i]);
       } else {
-        TSDebug(PLUGIN_NAME, "denylisting site: %s", sites[i]);
+        Dbg(dbg_ctl, "denylisting site: %s", sites[i]);
       }
       TSHttpTxnHookAdd(txnp, TS_HTTP_SEND_RESPONSE_HDR_HOOK, contp);
       TSHandleMLocRelease(bufp, hdr_loc, url_loc);
@@ -274,7 +275,7 @@ denylist_plugin(TSCont contp, TSEvent event, void *edata)
         handle_response(cd->txnp, contp);
         return 0;
       default:
-        TSDebug(PLUGIN_NAME, "This event was unexpected: %d", event);
+        Dbg(dbg_ctl, "This event was unexpected: %d", event);
         break;
       }
     } else {
@@ -324,7 +325,7 @@ TSPluginInit(int argc ATS_UNUSED, const char *argv[] ATS_UNUSED)
   /* create an TSTextLogObject to log denied requests to */
   error = TSTextLogObjectCreate("denylist", TS_LOG_MODE_ADD_TIMESTAMP, &ts_log);
   if (!ts_log || error == TS_ERROR) {
-    TSDebug(PLUGIN_NAME, "error while creating log");
+    Dbg(dbg_ctl, "error while creating log");
   }
 
   sites_mutex = TSMutexCreate();
diff --git a/example/plugins/c-api/disable_http2/disable_http2.cc b/example/plugins/c-api/disable_http2/disable_http2.cc
index 036c991a1b1..e29bb56d3d7 100644
--- a/example/plugins/c-api/disable_http2/disable_http2.cc
+++ b/example/plugins/c-api/disable_http2/disable_http2.cc
@@ -34,6 +34,11 @@
 
 #define PLUGIN_NAME "disable_http2"
 
+namespace
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 // Map of domains to tweak.
 using DomainSet = std::unordered_set<std::string>;
 DomainSet Domains;
@@ -47,7 +52,7 @@ CB_SNI(TSCont contp, TSEvent, void *cb_data)
   char const *sni          = SSL_get_servername(ssl, TLSEXT_NAMETYPE_host_name);
   if (sni) {
     if (Domains.find(sni) != Domains.end()) {
-      TSDebug(PLUGIN_NAME, "Disable H2 for SNI=%s", sni);
+      Dbg(dbg_ctl, "Disable H2 for SNI=%s", sni);
       TSVConnProtocolDisable(vc, TS_ALPN_PROTOCOL_HTTP_2_0);
     }
   }
@@ -74,11 +79,11 @@ TSPluginInit(int argc, char const *argv[])
     TSError("[%s] Usage %s.so servername1 servername2 ... ", PLUGIN_NAME, PLUGIN_NAME);
     return;
   } else {
-    TSDebug(PLUGIN_NAME, "registration succeeded");
+    Dbg(dbg_ctl, "registration succeeded");
   }
 
   for (int i = 1; i < argc; i++) {
-    TSDebug(PLUGIN_NAME, "%s added to the No-H2 list", argv[i]);
+    Dbg(dbg_ctl, "%s added to the No-H2 list", argv[i]);
     Domains.emplace(std::string(argv[i], strlen(argv[i])));
   }
   // These callbacks do not modify any state so no lock is needed.
diff --git a/example/plugins/c-api/file_1/file_1.cc b/example/plugins/c-api/file_1/file_1.cc
index d1a4023e6cf..dc9357f39a6 100644
--- a/example/plugins/c-api/file_1/file_1.cc
+++ b/example/plugins/c-api/file_1/file_1.cc
@@ -38,6 +38,11 @@
 
 #define PLUGIN_NAME "file_1"
 
+namespace
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 void
 TSPluginInit(int argc, const char *argv[])
 {
@@ -60,7 +65,7 @@ TSPluginInit(int argc, const char *argv[])
     }
 
     while (TSfgets(filep, buf, 4096)) {
-      TSDebug(PLUGIN_NAME, "%s", buf);
+      Dbg(dbg_ctl, "%s", buf);
     }
 
     TSfclose(filep);
diff --git a/example/plugins/c-api/hello/hello.cc b/example/plugins/c-api/hello/hello.cc
index 9f4c6cbbe11..f61f72fce88 100644
--- a/example/plugins/c-api/hello/hello.cc
+++ b/example/plugins/c-api/hello/hello.cc
@@ -27,6 +27,11 @@
 
 #define PLUGIN_NAME "hello"
 
+namespace
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 void
 TSPluginInit(int argc, const char *argv[])
 {
@@ -40,5 +45,5 @@ TSPluginInit(int argc, const char *argv[])
     TSError("[%s] Plugin registration failed", PLUGIN_NAME);
   }
 
-  TSDebug(PLUGIN_NAME, "Hello World!");
+  Dbg(dbg_ctl, "Hello World!");
 }
diff --git a/example/plugins/c-api/intercept/intercept.cc b/example/plugins/c-api/intercept/intercept.cc
index 59bca01deb5..c1bc1f93e92 100644
--- a/example/plugins/c-api/intercept/intercept.cc
+++ b/example/plugins/c-api/intercept/intercept.cc
@@ -45,10 +45,10 @@
 #define PLUGIN_NAME "intercept"
 #define PORT        60000
 
-#define VDEBUG(fmt, ...) TSDebug(PLUGIN_NAME, fmt, ##__VA_ARGS__)
+#define VDEBUG(fmt, ...) Dbg(dbg_ctl, fmt, ##__VA_ARGS__)
 
 #if DEBUG
-#define VERROR(fmt, ...) TSDebug(PLUGIN_NAME, fmt, ##__VA_ARGS__)
+#define VERROR(fmt, ...) Dbg(dbg_ctl, fmt, ##__VA_ARGS__)
 #else
 #define VERROR(fmt, ...) TSError("[%s] %s: " fmt, PLUGIN_NAME, __FUNCTION__, ##__VA_ARGS__)
 #endif
@@ -57,6 +57,8 @@
   VDEBUG("vio=%p vio.cont=%p, vio.cont.data=%p, vio.vc=%p " fmt, (vio), TSVIOContGet(vio), TSContDataGet(TSVIOContGet(vio)), \
          TSVIOVConnGet(vio), ##__VA_ARGS__)
 
+static DbgCtl dbg_ctl{PLUGIN_NAME};
+
 static TSCont TxnHook;
 static TSCont InterceptHook;
 
diff --git a/example/plugins/c-api/lifecycle_plugin/lifecycle_plugin.cc b/example/plugins/c-api/lifecycle_plugin/lifecycle_plugin.cc
index 237e76b6524..734eee68cc4 100644
--- a/example/plugins/c-api/lifecycle_plugin/lifecycle_plugin.cc
+++ b/example/plugins/c-api/lifecycle_plugin/lifecycle_plugin.cc
@@ -32,30 +32,35 @@
 
 #define PLUGIN_NAME "lifecycle"
 
+namespace
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 int
 CallbackHandler(TSCont, TSEvent id, void *data)
 {
   switch (id) {
   case TS_EVENT_LIFECYCLE_PORTS_INITIALIZED:
-    TSDebug(PLUGIN_NAME, "Proxy ports initialized");
+    Dbg(dbg_ctl, "Proxy ports initialized");
     break;
   case TS_EVENT_LIFECYCLE_PORTS_READY:
-    TSDebug(PLUGIN_NAME, "Proxy ports active");
+    Dbg(dbg_ctl, "Proxy ports active");
     break;
   case TS_EVENT_LIFECYCLE_CACHE_READY:
-    TSDebug(PLUGIN_NAME, "Cache ready");
+    Dbg(dbg_ctl, "Cache ready");
     break;
   case TS_EVENT_LIFECYCLE_MSG: {
     TSPluginMsg *msg = (TSPluginMsg *)data;
-    TSDebug(PLUGIN_NAME, "Message to '%s' - %zu bytes of data", msg->tag, msg->data_size);
+    Dbg(dbg_ctl, "Message to '%s' - %zu bytes of data", msg->tag, msg->data_size);
     if (msg->data_size == 0) {
-      TSDebug(PLUGIN_NAME, "Message data is not available");
+      Dbg(dbg_ctl, "Message data is not available");
     }
 
     break;
   }
   default:
-    TSDebug(PLUGIN_NAME, "Unexpected event %d", id);
+    Dbg(dbg_ctl, "Unexpected event %d", id);
     break;
   }
   return TS_EVENT_NONE;
@@ -84,7 +89,7 @@ TSPluginInit(int argc, const char *argv[])
   TSLifecycleHookAdd(TS_LIFECYCLE_CACHE_READY_HOOK, cb);
   TSLifecycleHookAdd(TS_LIFECYCLE_MSG_HOOK, cb);
 
-  TSDebug(PLUGIN_NAME, "online");
+  Dbg(dbg_ctl, "online");
 
   return;
 
diff --git a/example/plugins/c-api/null_transform/null_transform.cc b/example/plugins/c-api/null_transform/null_transform.cc
index de69c63b6be..9039f4da8e8 100644
--- a/example/plugins/c-api/null_transform/null_transform.cc
+++ b/example/plugins/c-api/null_transform/null_transform.cc
@@ -29,6 +29,11 @@
 
 #define PLUGIN_NAME "null_transform"
 
+namespace
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 typedef struct {
   TSVIO output_vio;
   TSIOBuffer output_buffer;
@@ -68,7 +73,7 @@ handle_transform(TSCont contp)
   MyData *data;
   int64_t towrite;
 
-  TSDebug(PLUGIN_NAME, "Entering handle_transform()");
+  Dbg(dbg_ctl, "Entering handle_transform()");
   /* Get the output (downstream) vconnection where we'll write data to. */
 
   output_conn = TSTransformOutputVConnGet(contp);
@@ -91,7 +96,7 @@ handle_transform(TSCont contp)
     data                = my_data_alloc();
     data->output_buffer = TSIOBufferCreate();
     data->output_reader = TSIOBufferReaderAlloc(data->output_buffer);
-    TSDebug(PLUGIN_NAME, "\tWriting %" PRId64 " bytes on VConn", TSVIONBytesGet(input_vio));
+    Dbg(dbg_ctl, "\tWriting %" PRId64 " bytes on VConn", TSVIONBytesGet(input_vio));
     data->output_vio = TSVConnWrite(output_conn, contp, data->output_reader, INT64_MAX);
     TSContDataSet(contp, data);
   }
@@ -117,14 +122,14 @@ handle_transform(TSCont contp)
    * to write to the output connection.
    */
   towrite = TSVIONTodoGet(input_vio);
-  TSDebug(PLUGIN_NAME, "\ttoWrite is %" PRId64 "", towrite);
+  Dbg(dbg_ctl, "\ttoWrite is %" PRId64 "", towrite);
 
   if (towrite > 0) {
     /* The amount of data left to read needs to be truncated by
      * the amount of data actually in the read buffer.
      */
     int64_t avail = TSIOBufferReaderAvail(TSVIOReaderGet(input_vio));
-    TSDebug(PLUGIN_NAME, "\tavail is %" PRId64 "", avail);
+    Dbg(dbg_ctl, "\tavail is %" PRId64 "", avail);
     if (towrite > avail) {
       towrite = avail;
     }
@@ -185,10 +190,10 @@ null_transform(TSCont contp, TSEvent event, void *edata)
   /* Check to see if the transformation has been closed by a call to
    * TSVConnClose.
    */
-  TSDebug(PLUGIN_NAME, "Entering null_transform()");
+  Dbg(dbg_ctl, "Entering null_transform()");
 
   if (TSVConnClosedGet(contp)) {
-    TSDebug(PLUGIN_NAME, "\tVConn is closed");
+    Dbg(dbg_ctl, "\tVConn is closed");
     my_data_destroy(static_cast<MyData *>(TSContDataGet(contp)));
     TSContDestroy(contp);
     return 0;
@@ -197,7 +202,7 @@ null_transform(TSCont contp, TSEvent event, void *edata)
     case TS_EVENT_ERROR: {
       TSVIO input_vio;
 
-      TSDebug(PLUGIN_NAME, "\tEvent is TS_EVENT_ERROR");
+      Dbg(dbg_ctl, "\tEvent is TS_EVENT_ERROR");
       /* Get the write VIO for the write operation that was
        * performed on ourself. This VIO contains the continuation of
        * our parent transformation. This is the input VIO.
@@ -210,7 +215,7 @@ null_transform(TSCont contp, TSEvent event, void *edata)
       TSContCall(TSVIOContGet(input_vio), TS_EVENT_ERROR, input_vio);
     } break;
     case TS_EVENT_VCONN_WRITE_COMPLETE:
-      TSDebug(PLUGIN_NAME, "\tEvent is TS_EVENT_VCONN_WRITE_COMPLETE");
+      Dbg(dbg_ctl, "\tEvent is TS_EVENT_VCONN_WRITE_COMPLETE");
       /* When our output connection says that it has finished
        * reading all the data we've written to it then we should
        * shutdown the write portion of its connection to
@@ -224,11 +229,11 @@ null_transform(TSCont contp, TSEvent event, void *edata)
      * we'll attempt to transform more data.
      */
     case TS_EVENT_VCONN_WRITE_READY:
-      TSDebug(PLUGIN_NAME, "\tEvent is TS_EVENT_VCONN_WRITE_READY");
+      Dbg(dbg_ctl, "\tEvent is TS_EVENT_VCONN_WRITE_READY");
       handle_transform(contp);
       break;
     default:
-      TSDebug(PLUGIN_NAME, "\t(event is %d)", event);
+      Dbg(dbg_ctl, "\t(event is %d)", event);
       handle_transform(contp);
       break;
     }
@@ -249,7 +254,7 @@ transformable(TSHttpTxn txnp)
   TSHttpStatus resp_status;
   int retv = 0;
 
-  TSDebug(PLUGIN_NAME, "Entering transformable()");
+  Dbg(dbg_ctl, "Entering transformable()");
 
   if (TS_SUCCESS == TSHttpTxnServerRespGet(txnp, &bufp, &hdr_loc)) {
     resp_status = TSHttpHdrStatusGet(bufp, hdr_loc);
@@ -257,7 +262,7 @@ transformable(TSHttpTxn txnp)
     TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
   }
 
-  TSDebug(PLUGIN_NAME, "Exiting transformable with return %d", retv);
+  Dbg(dbg_ctl, "Exiting transformable with return %d", retv);
   return retv;
 }
 
@@ -266,7 +271,7 @@ transform_add(TSHttpTxn txnp)
 {
   TSVConn connp;
 
-  TSDebug(PLUGIN_NAME, "Entering transform_add()");
+  Dbg(dbg_ctl, "Entering transform_add()");
   connp = TSTransformCreate(null_transform, txnp);
   TSHttpTxnHookAdd(txnp, TS_HTTP_RESPONSE_TRANSFORM_HOOK, connp);
 }
@@ -276,10 +281,10 @@ transform_plugin(TSCont contp, TSEvent event, void *edata)
 {
   TSHttpTxn txnp = (TSHttpTxn)edata;
 
-  TSDebug(PLUGIN_NAME, "Entering transform_plugin()");
+  Dbg(dbg_ctl, "Entering transform_plugin()");
   switch (event) {
   case TS_EVENT_HTTP_READ_RESPONSE_HDR:
-    TSDebug(PLUGIN_NAME, "\tEvent is TS_EVENT_HTTP_READ_RESPONSE_HDR");
+    Dbg(dbg_ctl, "\tEvent is TS_EVENT_HTTP_READ_RESPONSE_HDR");
     if (transformable(txnp)) {
       transform_add(txnp);
     }
diff --git a/example/plugins/c-api/output_header/output_header.cc b/example/plugins/c-api/output_header/output_header.cc
index 26bfd23fda1..a9a35999809 100644
--- a/example/plugins/c-api/output_header/output_header.cc
+++ b/example/plugins/c-api/output_header/output_header.cc
@@ -40,6 +40,11 @@
 
 #define PLUGIN_NAME "output_header"
 
+namespace
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 static void
 handle_dns(TSHttpTxn txnp, TSCont contp ATS_UNUSED)
 {
@@ -58,7 +63,7 @@ handle_dns(TSHttpTxn txnp, TSCont contp ATS_UNUSED)
   int64_t output_len;
 
   if (TSHttpTxnClientReqGet(txnp, &bufp, &hdr_loc) != TS_SUCCESS) {
-    TSDebug(PLUGIN_NAME, "couldn't retrieve client request header");
+    Dbg(dbg_ctl, "couldn't retrieve client request header");
     TSError("[%s] Couldn't retrieve client request header", PLUGIN_NAME);
     goto done;
   }
@@ -68,11 +73,11 @@ handle_dns(TSHttpTxn txnp, TSCont contp ATS_UNUSED)
 
   /* This will print  just MIMEFields and not
      the http request line */
-  TSDebug(PLUGIN_NAME, "Printing the hdrs ... ");
+  Dbg(dbg_ctl, "Printing the hdrs ... ");
   TSMimeHdrPrint(bufp, hdr_loc, output_buffer);
 
   if (TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc) == TS_ERROR) {
-    TSDebug(PLUGIN_NAME, "non-fatal: error releasing MLoc");
+    Dbg(dbg_ctl, "non-fatal: error releasing MLoc");
     TSError("[%s] non-fatal: Couldn't release MLoc", PLUGIN_NAME);
   }
 
@@ -124,7 +129,7 @@ handle_dns(TSHttpTxn txnp, TSCont contp ATS_UNUSED)
 
   /* Although I'd never do this a production plugin, printf
      the header so that we can see it's all there */
-  TSDebug(PLUGIN_NAME, "%s", output_string);
+  Dbg(dbg_ctl, "%s", output_string);
 
   TSfree(output_string);
 
diff --git a/example/plugins/c-api/passthru/passthru.cc b/example/plugins/c-api/passthru/passthru.cc
index 5fd828b7745..73a97c12ca5 100644
--- a/example/plugins/c-api/passthru/passthru.cc
+++ b/example/plugins/c-api/passthru/passthru.cc
@@ -37,9 +37,14 @@
 
 #define PLUGIN_NAME "passthru"
 
-#define PassthruSessionDebug(sp, fmt, ...)                 \
-  do {                                                     \
-    TSDebug(PLUGIN_NAME, "sp=%p " fmt, sp, ##__VA_ARGS__); \
+namespace
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
+#define PassthruSessionDebug(sp, fmt, ...)         \
+  do {                                             \
+    Dbg(dbg_ctl, "sp=%p " fmt, sp, ##__VA_ARGS__); \
   } while (0)
 
 static int PassthruSessionEvent(TSCont cont, TSEvent event, void *edata);
@@ -307,7 +312,7 @@ PassthruListen()
     return TS_ERROR;
   }
 
-  TSDebug(PLUGIN_NAME, "listening on port '%s'", ports);
+  Dbg(dbg_ctl, "listening on port '%s'", ports);
   TSfree(ports);
 
   cont = TSContCreate(PassthruAccept, nullptr);
diff --git a/example/plugins/c-api/protocol/Protocol.cc b/example/plugins/c-api/protocol/Protocol.cc
index b47efb9c139..ab3fb9e5b57 100644
--- a/example/plugins/c-api/protocol/Protocol.cc
+++ b/example/plugins/c-api/protocol/Protocol.cc
@@ -28,6 +28,11 @@
 
 #define RETRY_TIME 10
 
+namespace protocol_ns
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+};
+
 /* global variable */
 TSTextLogObject protocol_plugin_log;
 
@@ -59,7 +64,7 @@ accept_handler(TSCont contp, TSEvent event, void *edata)
 
     // check if grabbing the lock is successful
     if (TSMutexLockTry(pmutex) != TS_SUCCESS) {
-      TSDebug(PLUGIN_NAME, "Unable to get lock. Will retry after some time");
+      Dbg(dbg_ctl, "Unable to get lock. Will retry after some time");
       TSContScheduleOnPool(contp, RETRY_TIME, TS_THREAD_POOL_NET);
       break;
     }
@@ -130,13 +135,13 @@ TSPluginInit(int argc, const char *argv[])
   server_port = 4666;
 
   if (argc < 3) {
-    TSDebug(PLUGIN_NAME, "Usage: protocol.so <accept_port> <server_port>. Using default ports accept=%d server=%d", accept_port,
-            server_port);
+    Dbg(dbg_ctl, "Usage: protocol.so <accept_port> <server_port>. Using default ports accept=%d server=%d", accept_port,
+        server_port);
   } else {
     tmp = strtol(argv[1], &end, 10);
     if (*end == '\0') {
       accept_port = tmp;
-      TSDebug(PLUGIN_NAME, "using accept_port %d", accept_port);
+      Dbg(dbg_ctl, "using accept_port %d", accept_port);
     } else {
       TSError("[%s] Wrong argument for accept_port, using default port %d", PLUGIN_NAME, accept_port);
     }
@@ -144,7 +149,7 @@ TSPluginInit(int argc, const char *argv[])
     tmp = strtol(argv[2], &end, 10);
     if (*end == '\0') {
       server_port = tmp;
-      TSDebug(PLUGIN_NAME, "using server_port %d", server_port);
+      Dbg(dbg_ctl, "using server_port %d", server_port);
     } else {
       TSError("[%s] Wrong argument for server_port, using default port %d", PLUGIN_NAME, server_port);
     }
diff --git a/example/plugins/c-api/protocol/Protocol.h b/example/plugins/c-api/protocol/Protocol.h
index fbb01bf4f2b..07578092839 100644
--- a/example/plugins/c-api/protocol/Protocol.h
+++ b/example/plugins/c-api/protocol/Protocol.h
@@ -36,6 +36,12 @@
 
 #define PLUGIN_NAME "protocol"
 
+namespace protocol_ns
+{
+extern DbgCtl dbg_ctl;
+}
+using namespace protocol_ns;
+
 #define MAX_SERVER_NAME_LENGTH 1024
 #define MAX_FILE_NAME_LENGTH   1024
 
diff --git a/example/plugins/c-api/protocol/TxnSM.cc b/example/plugins/c-api/protocol/TxnSM.cc
index b48555c244f..dd923d3e496 100644
--- a/example/plugins/c-api/protocol/TxnSM.cc
+++ b/example/plugins/c-api/protocol/TxnSM.cc
@@ -75,7 +75,7 @@ main_handler(TSCont contp, TSEvent event, void *data)
   TxnSM *txn_sm                  = (TxnSM *)TSContDataGet(contp);
   TxnSMHandler q_current_handler = txn_sm->q_current_handler;
 
-  TSDebug(PLUGIN_NAME, "main_handler (contp %p event %d)", contp, event);
+  Dbg(dbg_ctl, "main_handler (contp %p event %d)", contp, event);
 
   /* handle common cases errors */
   if (event == TS_EVENT_ERROR) {
@@ -88,7 +88,7 @@ main_handler(TSCont contp, TSEvent event, void *data)
     }
   }
 
-  TSDebug(PLUGIN_NAME, "current_handler (%p)", q_current_handler);
+  Dbg(dbg_ctl, "current_handler (%p)", q_current_handler);
 
   return (*q_current_handler)(contp, event, data);
 }
@@ -192,7 +192,7 @@ state_interface_with_client(TSCont contp, TSEvent event, TSVIO vio)
 {
   TxnSM *txn_sm = (TxnSM *)TSContDataGet(contp);
 
-  TSDebug(PLUGIN_NAME, "enter state_interface_with_client");
+  Dbg(dbg_ctl, "enter state_interface_with_client");
 
   txn_sm->q_pending_action = nullptr;
 
@@ -213,7 +213,7 @@ state_read_request_from_client(TSCont contp, TSEvent event, TSVIO vio ATS_UNUSED
 
   TxnSM *txn_sm = (TxnSM *)TSContDataGet(contp);
 
-  TSDebug(PLUGIN_NAME, "enter state_read_request_from_client");
+  Dbg(dbg_ctl, "enter state_read_request_from_client");
 
   switch (event) {
   case TS_EVENT_VCONN_READ_READY:
@@ -238,7 +238,7 @@ state_read_request_from_client(TSCont contp, TSEvent event, TSVIO vio ATS_UNUSED
         }
 
         /* Start to do cache lookup */
-        TSDebug(PLUGIN_NAME, "Key material: file name is %s*****", txn_sm->q_file_name);
+        Dbg(dbg_ctl, "Key material: file name is %s*****", txn_sm->q_file_name);
         txn_sm->q_key = CacheKeyCreate(txn_sm->q_file_name);
 
         set_handler(txn_sm->q_current_handler, (TxnSMHandler)&state_handle_cache_lookup);
@@ -268,11 +268,11 @@ state_handle_cache_lookup(TSCont contp, TSEvent event, TSVConn vc)
   int64_t response_size;
   int ret_val;
 
-  TSDebug(PLUGIN_NAME, "enter state_handle_cache_lookup");
+  Dbg(dbg_ctl, "enter state_handle_cache_lookup");
 
   switch (event) {
   case TS_EVENT_CACHE_OPEN_READ:
-    TSDebug(PLUGIN_NAME, "cache hit!!!");
+    Dbg(dbg_ctl, "cache hit!!!");
     /* Cache hit. */
 
     /* Write log */
@@ -313,7 +313,7 @@ state_handle_cache_lookup(TSCont contp, TSEvent event, TSVConn vc)
 
   case TS_EVENT_CACHE_OPEN_READ_FAILED:
     /* Cache miss or error, open cache write_vc. */
-    TSDebug(PLUGIN_NAME, "cache miss or error!!!");
+    Dbg(dbg_ctl, "cache miss or error!!!");
     /* Write log */
     ret_val = TSTextLogObjectWrite(protocol_plugin_log, "%s %s %d \n", txn_sm->q_file_name, txn_sm->q_server_name, 0);
 
@@ -341,8 +341,8 @@ load_buffer_cache_data(TxnSM *txn_sm)
      server response buffer */
   int rdr_avail = TSIOBufferReaderAvail(txn_sm->q_cache_read_buffer_reader);
 
-  TSDebug(PLUGIN_NAME, "entering buffer_cache_data");
-  TSDebug(PLUGIN_NAME, "loading %d bytes to buffer reader", rdr_avail);
+  Dbg(dbg_ctl, "entering buffer_cache_data");
+  Dbg(dbg_ctl, "loading %d bytes to buffer reader", rdr_avail);
 
   TSAssert(rdr_avail > 0);
 
@@ -363,7 +363,7 @@ state_handle_cache_read_response(TSCont contp, TSEvent event, TSVIO vio ATS_UNUS
 {
   TxnSM *txn_sm = (TxnSM *)TSContDataGet(contp);
 
-  TSDebug(PLUGIN_NAME, "enter state_handle_cache_read_response");
+  Dbg(dbg_ctl, "enter state_handle_cache_read_response");
 
   txn_sm->q_pending_action = nullptr;
 
@@ -413,7 +413,7 @@ state_handle_cache_prepare_for_write(TSCont contp, TSEvent event, TSVConn vc)
 {
   TxnSM *txn_sm = (TxnSM *)TSContDataGet(contp);
 
-  TSDebug(PLUGIN_NAME, "enter state_handle_cache_prepare_for_write");
+  Dbg(dbg_ctl, "enter state_handle_cache_prepare_for_write");
 
   txn_sm->q_pending_action = nullptr;
 
@@ -437,7 +437,7 @@ state_build_and_send_request(TSCont contp, TSEvent event ATS_UNUSED, void *data
 {
   TxnSM *txn_sm = (TxnSM *)TSContDataGet(contp);
 
-  TSDebug(PLUGIN_NAME, "enter state_build_and_send_request");
+  Dbg(dbg_ctl, "enter state_build_and_send_request");
 
   txn_sm->q_pending_action = nullptr;
 
@@ -467,7 +467,7 @@ state_build_and_send_request(TSCont contp, TSEvent event ATS_UNUSED, void *data
   txn_sm->q_pending_action = TSHostLookup(contp, txn_sm->q_server_name, strlen(txn_sm->q_server_name));
 
   TSAssert(txn_sm->q_pending_action);
-  TSDebug(PLUGIN_NAME, "initiating host lookup");
+  Dbg(dbg_ctl, "initiating host lookup");
 
   return TS_SUCCESS;
 }
@@ -478,7 +478,7 @@ state_dns_lookup(TSCont contp, TSEvent event, TSHostLookupResult host_info)
 {
   TxnSM *txn_sm = (TxnSM *)TSContDataGet(contp);
 
-  TSDebug(PLUGIN_NAME, "enter state_dns_lookup");
+  Dbg(dbg_ctl, "enter state_dns_lookup");
 
   /* Can't find the server IP. */
   if (event != TS_EVENT_HOST_LOOKUP || !host_info) {
@@ -511,7 +511,7 @@ state_connect_to_server(TSCont contp, TSEvent event, TSVConn vc)
 {
   TxnSM *txn_sm = (TxnSM *)TSContDataGet(contp);
 
-  TSDebug(PLUGIN_NAME, "enter state_connect_to_server");
+  Dbg(dbg_ctl, "enter state_connect_to_server");
 
   /* TSNetConnect failed. */
   if (event != TS_EVENT_NET_CONNECT) {
@@ -537,7 +537,7 @@ state_send_request_to_server(TSCont contp, TSEvent event, TSVIO vio)
 {
   TxnSM *txn_sm = (TxnSM *)TSContDataGet(contp);
 
-  TSDebug(PLUGIN_NAME, "enter state_send_request_to_server");
+  Dbg(dbg_ctl, "enter state_send_request_to_server");
 
   switch (event) {
   case TS_EVENT_VCONN_WRITE_READY:
@@ -562,7 +562,7 @@ state_interface_with_server(TSCont contp, TSEvent event, TSVIO vio)
 {
   TxnSM *txn_sm = (TxnSM *)TSContDataGet(contp);
 
-  TSDebug(PLUGIN_NAME, "enter state_interface_with_server");
+  Dbg(dbg_ctl, "enter state_interface_with_server");
 
   txn_sm->q_pending_action = nullptr;
 
@@ -580,7 +580,7 @@ state_interface_with_server(TSCont contp, TSEvent event, TSVIO vio)
 
   /* all data of the response come in. */
   case TS_EVENT_VCONN_EOS:
-    TSDebug(PLUGIN_NAME, "get server eos");
+    Dbg(dbg_ctl, "get server eos");
     /* There is no more use of server_vc, close it. */
     if (txn_sm->q_server_vc) {
       TSVConnClose(txn_sm->q_server_vc);
@@ -620,8 +620,8 @@ state_interface_with_server(TSCont contp, TSEvent event, TSVIO vio)
       txn_sm->q_pending_action = TSCacheRead(contp, txn_sm->q_key);
     } else { /* not done with writing into cache */
 
-      TSDebug(PLUGIN_NAME, "cache_response_length is %d, server response length is %d", txn_sm->q_cache_response_length,
-              txn_sm->q_server_response_length);
+      Dbg(dbg_ctl, "cache_response_length is %d, server response length is %d", txn_sm->q_cache_response_length,
+          txn_sm->q_server_response_length);
       TSVIOReenable(txn_sm->q_cache_write_vio);
     }
 
@@ -644,7 +644,7 @@ state_read_response_from_server(TSCont contp, TSEvent event ATS_UNUSED, TSVIO vi
   TxnSM *txn_sm  = (TxnSM *)TSContDataGet(contp);
   int bytes_read = 0;
 
-  TSDebug(PLUGIN_NAME, "enter state_read_response_from_server");
+  Dbg(dbg_ctl, "enter state_read_response_from_server");
 
   bytes_read = TSIOBufferReaderAvail(txn_sm->q_cache_response_buffer_reader);
 
@@ -667,7 +667,7 @@ state_read_response_from_server(TSCont contp, TSEvent event ATS_UNUSED, TSVIO vi
   }
 
   txn_sm->q_server_response_length += bytes_read;
-  TSDebug(PLUGIN_NAME, "bytes read is %d, total response length is %d", bytes_read, txn_sm->q_server_response_length);
+  Dbg(dbg_ctl, "bytes read is %d, total response length is %d", bytes_read, txn_sm->q_server_response_length);
 
   return TS_SUCCESS;
 }
@@ -679,7 +679,7 @@ state_write_to_cache(TSCont contp, TSEvent event, TSVIO vio)
 {
   TxnSM *txn_sm = (TxnSM *)TSContDataGet(contp);
 
-  TSDebug(PLUGIN_NAME, "enter state_write_to_cache");
+  Dbg(dbg_ctl, "enter state_write_to_cache");
 
   switch (event) {
   case TS_EVENT_VCONN_WRITE_READY:
@@ -687,7 +687,7 @@ state_write_to_cache(TSCont contp, TSEvent event, TSVIO vio)
     return TS_SUCCESS;
 
   case TS_EVENT_VCONN_WRITE_COMPLETE:
-    TSDebug(PLUGIN_NAME, "nbytes %" PRId64 ", ndone %" PRId64, TSVIONBytesGet(vio), TSVIONDoneGet(vio));
+    Dbg(dbg_ctl, "nbytes %" PRId64 ", ndone %" PRId64, TSVIONBytesGet(vio), TSVIONDoneGet(vio));
     /* Since the first write is through TSVConnWrite, which already consume
        the data in cache_buffer_reader, don't consume it again. */
     if (txn_sm->q_cache_response_length > 0 && txn_sm->q_block_bytes_read > 0) {
@@ -698,15 +698,15 @@ state_write_to_cache(TSCont contp, TSEvent event, TSVIO vio)
 
     /* If not all data have been read in, we have to reenable the read_vio */
     if (txn_sm->q_server_vc != nullptr) {
-      TSDebug(PLUGIN_NAME, "re-enable server_read_vio");
+      Dbg(dbg_ctl, "re-enable server_read_vio");
       TSVIOReenable(txn_sm->q_server_read_vio);
       return TS_SUCCESS;
     }
 
     if (txn_sm->q_cache_response_length >= txn_sm->q_server_response_length) {
       /* Write is complete, close the cache_vc. */
-      TSDebug(PLUGIN_NAME, "close cache_vc, cache_response_length is %d, server_response_length is %d",
-              txn_sm->q_cache_response_length, txn_sm->q_server_response_length);
+      Dbg(dbg_ctl, "close cache_vc, cache_response_length is %d, server_response_length is %d", txn_sm->q_cache_response_length,
+          txn_sm->q_server_response_length);
       TSVConnClose(txn_sm->q_cache_vc);
       txn_sm->q_cache_vc        = nullptr;
       txn_sm->q_cache_write_vio = nullptr;
@@ -717,7 +717,7 @@ state_write_to_cache(TSCont contp, TSEvent event, TSVIO vio)
       txn_sm->q_pending_action = TSCacheRead(contp, txn_sm->q_key);
     } else { /* not done with writing into cache */
 
-      TSDebug(PLUGIN_NAME, "re-enable cache_write_vio");
+      Dbg(dbg_ctl, "re-enable cache_write_vio");
       TSVIOReenable(txn_sm->q_cache_write_vio);
     }
     return TS_SUCCESS;
@@ -737,18 +737,18 @@ state_send_response_to_client(TSCont contp, TSEvent event, TSVIO vio)
 {
   TxnSM *txn_sm = (TxnSM *)TSContDataGet(contp);
 
-  TSDebug(PLUGIN_NAME, "enter state_send_response_to_client");
+  Dbg(dbg_ctl, "enter state_send_response_to_client");
 
   switch (event) {
   case TS_EVENT_VCONN_WRITE_READY:
-    TSDebug(PLUGIN_NAME, " . wr ready");
-    TSDebug(PLUGIN_NAME, "write_ready: nbytes %" PRId64 ", ndone %" PRId64, TSVIONBytesGet(vio), TSVIONDoneGet(vio));
+    Dbg(dbg_ctl, " . wr ready");
+    Dbg(dbg_ctl, "write_ready: nbytes %" PRId64 ", ndone %" PRId64, TSVIONBytesGet(vio), TSVIONDoneGet(vio));
     TSVIOReenable(txn_sm->q_client_write_vio);
     break;
 
   case TS_EVENT_VCONN_WRITE_COMPLETE:
-    TSDebug(PLUGIN_NAME, " . wr complete");
-    TSDebug(PLUGIN_NAME, "write_complete: nbytes %" PRId64 ", ndone %" PRId64, TSVIONBytesGet(vio), TSVIONDoneGet(vio));
+    Dbg(dbg_ctl, " . wr complete");
+    Dbg(dbg_ctl, "write_complete: nbytes %" PRId64 ", ndone %" PRId64, TSVIONBytesGet(vio), TSVIONDoneGet(vio));
     /* Finished sending all data to client, close client_vc. */
     if (txn_sm->q_client_vc) {
       TSVConnClose(txn_sm->q_client_vc);
@@ -760,11 +760,11 @@ state_send_response_to_client(TSCont contp, TSEvent event, TSVIO vio)
     return state_done(contp, TS_EVENT_NONE, nullptr);
 
   default:
-    TSDebug(PLUGIN_NAME, " . default handler");
+    Dbg(dbg_ctl, " . default handler");
     return prepare_to_die(contp);
   }
 
-  TSDebug(PLUGIN_NAME, "leaving send_response_to_client");
+  Dbg(dbg_ctl, "leaving send_response_to_client");
 
   return TS_SUCCESS;
 }
@@ -776,7 +776,7 @@ prepare_to_die(TSCont contp)
 {
   TxnSM *txn_sm = (TxnSM *)TSContDataGet(contp);
 
-  TSDebug(PLUGIN_NAME, "enter prepare_to_die");
+  Dbg(dbg_ctl, "enter prepare_to_die");
   if (txn_sm->q_client_vc) {
     TSVConnAbort(txn_sm->q_client_vc, 1);
     txn_sm->q_client_vc = nullptr;
@@ -806,13 +806,13 @@ state_done(TSCont contp, TSEvent event ATS_UNUSED, TSVIO vio ATS_UNUSED)
 {
   TxnSM *txn_sm = (TxnSM *)TSContDataGet(contp);
 
-  TSDebug(PLUGIN_NAME, "enter state_done");
+  Dbg(dbg_ctl, "enter state_done");
 
   if (txn_sm->q_pending_action && !TSActionDone(txn_sm->q_pending_action)) {
-    TSDebug(PLUGIN_NAME, "cancelling pending action %p", txn_sm->q_pending_action);
+    Dbg(dbg_ctl, "cancelling pending action %p", txn_sm->q_pending_action);
     TSActionCancel(txn_sm->q_pending_action);
   } else if (txn_sm->q_pending_action) {
-    TSDebug(PLUGIN_NAME, "action is done %p", txn_sm->q_pending_action);
+    Dbg(dbg_ctl, "action is done %p", txn_sm->q_pending_action);
   }
 
   txn_sm->q_pending_action = nullptr;
@@ -898,12 +898,12 @@ send_response_to_client(TSCont contp)
   TxnSM *txn_sm;
   int response_len;
 
-  TSDebug(PLUGIN_NAME, "enter send_response_to_client");
+  Dbg(dbg_ctl, "enter send_response_to_client");
 
   txn_sm       = (TxnSM *)TSContDataGet(contp);
   response_len = TSIOBufferReaderAvail(txn_sm->q_client_response_buffer_reader);
 
-  TSDebug(PLUGIN_NAME, " . resp_len is %d", response_len);
+  Dbg(dbg_ctl, " . resp_len is %d", response_len);
 
   set_handler(txn_sm->q_current_handler, (TxnSMHandler)&state_interface_with_client);
   txn_sm->q_client_write_vio = TSVConnWrite(txn_sm->q_client_vc, contp, txn_sm->q_client_response_buffer_reader, response_len);
diff --git a/example/plugins/c-api/protocol_stack/protocol_stack.cc b/example/plugins/c-api/protocol_stack/protocol_stack.cc
index 7a4cc1d451d..9b17670162e 100644
--- a/example/plugins/c-api/protocol_stack/protocol_stack.cc
+++ b/example/plugins/c-api/protocol_stack/protocol_stack.cc
@@ -28,19 +28,24 @@
 
 #define PLUGIN_NAME "protocol_stack"
 
+namespace
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 static int
 proto_stack_cb(TSCont contp ATS_UNUSED, TSEvent event, void *edata)
 {
   TSHttpTxn txnp = static_cast<TSHttpTxn>(edata);
   const char *results[10];
   int count = 0;
-  TSDebug(PLUGIN_NAME, "Protocols:");
+  Dbg(dbg_ctl, "Protocols:");
   TSHttpTxnClientProtocolStackGet(txnp, 10, results, &count);
   for (int i = 0; i < count; i++) {
-    TSDebug(PLUGIN_NAME, "\t%d: %s", i, results[i]);
+    Dbg(dbg_ctl, "\t%d: %s", i, results[i]);
   }
   const char *ret_tag = TSHttpTxnClientProtocolStackContains(txnp, "h2");
-  TSDebug(PLUGIN_NAME, "Stack %s HTTP/2", ret_tag != nullptr ? "contains" : "does not contain");
+  Dbg(dbg_ctl, "Stack %s HTTP/2", ret_tag != nullptr ? "contains" : "does not contain");
   TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
   return 0;
 }
diff --git a/example/plugins/c-api/query_remap/query_remap.cc b/example/plugins/c-api/query_remap/query_remap.cc
index a5e2249b869..3d43a4f75df 100644
--- a/example/plugins/c-api/query_remap/query_remap.cc
+++ b/example/plugins/c-api/query_remap/query_remap.cc
@@ -31,6 +31,11 @@
 
 #define PLUGIN_NAME "query_remap"
 
+namespace
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 /* function prototypes */
 uint32_t hash_fnv32(char *buf, size_t len);
 
@@ -45,7 +50,7 @@ TSReturnCode
 TSRemapInit(TSRemapInterface *api_info ATS_UNUSED, char *errbuf ATS_UNUSED, int errbuf_size ATS_UNUSED)
 {
   /* Called at TS startup. Nothing needed for this plugin */
-  TSDebug(PLUGIN_NAME, "remap plugin initialized");
+  Dbg(dbg_ctl, "remap plugin initialized");
   return TS_SUCCESS;
 }
 
@@ -54,7 +59,7 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char *errbuf ATS_UNUSED, i
 {
   /* Called for each remap rule using this plugin. The parameters are parsed here */
   int i;
-  TSDebug(PLUGIN_NAME, "new instance fromURL: %s toURL: %s", argv[0], argv[1]);
+  Dbg(dbg_ctl, "new instance fromURL: %s toURL: %s", argv[0], argv[1]);
 
   if (argc < 4) {
     TSError("[%s] Missing parameters", PLUGIN_NAME);
@@ -75,15 +80,15 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char *errbuf ATS_UNUSED, i
   qri->num_hosts  = argc - 3;
   qri->hosts      = (char **)TSmalloc(qri->num_hosts * sizeof(char *));
 
-  TSDebug(PLUGIN_NAME, " - Hash using query parameter [%s] with %d hosts", qri->param_name, qri->num_hosts);
+  Dbg(dbg_ctl, " - Hash using query parameter [%s] with %d hosts", qri->param_name, qri->num_hosts);
 
   for (i = 0; i < qri->num_hosts; ++i) {
     qri->hosts[i] = TSstrdup(argv[i + 3]);
-    TSDebug(PLUGIN_NAME, " - Host %d: %s", i, qri->hosts[i]);
+    Dbg(dbg_ctl, " - Host %d: %s", i, qri->hosts[i]);
   }
 
   *ih = (void *)qri;
-  TSDebug(PLUGIN_NAME, "created instance %p", *ih);
+  Dbg(dbg_ctl, "created instance %p", *ih);
   return TS_SUCCESS;
 }
 
@@ -91,7 +96,7 @@ void
 TSRemapDeleteInstance(void *ih)
 {
   /* Release instance memory allocated in TSRemapNewInstance */
-  TSDebug(PLUGIN_NAME, "deleting instance %p", ih);
+  Dbg(dbg_ctl, "deleting instance %p", ih);
 
   if (ih) {
     query_remap_info *qri = (query_remap_info *)ih;
@@ -137,7 +142,7 @@ TSRemapDoRemap(void *ih, TSHttpTxn rh ATS_UNUSED, TSRemapRequestInfo *rri)
         /* the param key matched the configured param_name
            hash the param value to pick a host */
         hostidx = hash_fnv32(val, strlen(val)) % (uint32_t)qri->num_hosts;
-        TSDebug(PLUGIN_NAME, "modifying host based on %s", key);
+        Dbg(dbg_ctl, "modifying host based on %s", key);
         break;
       }
       key = strtok_r(nullptr, "&", &s);
@@ -147,20 +152,20 @@ TSRemapDoRemap(void *ih, TSHttpTxn rh ATS_UNUSED, TSRemapRequestInfo *rri)
 
     if (hostidx >= 0) {
       int req_host_len;
-      /* TODO: Perhaps use TSIsDebugTagSet() before calling TSUrlHostGet()... */
+      /* TODO: Perhaps use dbg_ctl.on() before calling TSUrlHostGet()... */
       const char *req_host = TSUrlHostGet(rri->requestBufp, rri->requestUrl, &req_host_len);
 
       if (TSUrlHostSet(rri->requestBufp, rri->requestUrl, qri->hosts[hostidx], strlen(qri->hosts[hostidx])) != TS_SUCCESS) {
-        TSDebug(PLUGIN_NAME, "Failed to modify the Host in request URL");
+        Dbg(dbg_ctl, "Failed to modify the Host in request URL");
         return TSREMAP_NO_REMAP;
       }
-      TSDebug(PLUGIN_NAME, "host changed from [%.*s] to [%s]", req_host_len, req_host, qri->hosts[hostidx]);
+      Dbg(dbg_ctl, "host changed from [%.*s] to [%s]", req_host_len, req_host, qri->hosts[hostidx]);
       return TSREMAP_DID_REMAP; /* host has been modified */
     }
   }
 
   /* the request was not modified, TS will use the toURL from the remap rule */
-  TSDebug(PLUGIN_NAME, "request not modified");
+  Dbg(dbg_ctl, "request not modified");
   return TSREMAP_NO_REMAP;
 }
 
diff --git a/example/plugins/c-api/redirect_1/redirect_1.cc b/example/plugins/c-api/redirect_1/redirect_1.cc
index 419de7c0a3e..c7b435ad9df 100644
--- a/example/plugins/c-api/redirect_1/redirect_1.cc
+++ b/example/plugins/c-api/redirect_1/redirect_1.cc
@@ -44,6 +44,32 @@
 #define PLUGIN_NAME "redirect_1"
 #define STAT_PREFIX "plugin." PLUGIN_NAME "."
 
+// This plugin illustrates how to write a plugin that can be compiled to run with either ATS10 or an older ATS version.
+
+#if TS_VERSION_MAJOR >= 10
+
+namespace
+{
+DbgCtl dbg_ctl_redirect{"redirect"};
+DbgCtl dbg_ctl_general{PLUGIN_NAME};
+DbgCtl dbg_ctl_demo{PLUGIN_NAME ".demo"};
+DbgCtl dbg_ctl_init{PLUGIN_NAME ".init"};
+} // namespace
+
+#define DBG_REDIRECT_ON  (dbg_ctl_redirect.on())
+#define DBG_GENERAL(...) Dbg(dbg_ctl_general, __VA_ARGS__)
+#define DBG_DEMO_ON      (dbg_ctl_demo.on())
+#define DBG_INIT(...)    Dbg(dbg_ctl_init, __VA_ARGS__)
+
+#else
+
+#define DBG_REDIRECT_ON  (TSIsDebugTagSet("redirect"))
+#define DBG_GENERAL(...) Dbg(dbg_ctl, __VA_ARGS__)
+#define DBG_DEMO_ON      (TSIsDebugTagSet(PLUGIN_NAME ".demo"))
+#define DBG_INIT(...)    TSDebug(PLUGIN_NAME ".init", __VA_ARGS__)
+
+#endif
+
 static in_addr_t ip_deny;
 
 // The created stat indices will be held in these variables.
@@ -78,7 +104,7 @@ handle_client_lookup(TSHttpTxn txnp, TSCont contp)
 
   const char *host;
 
-  if (TSIsDebugTagSet("redirect")) {
+  if (DBG_REDIRECT_ON) {
     struct sockaddr const *addr = TSHttpTxnClientAddrGet(txnp);
 
     if (addr) {
@@ -93,7 +119,7 @@ handle_client_lookup(TSHttpTxn txnp, TSCont contp)
         char clientstring[INET6_ADDRSTRLEN];
 
         if (nullptr != inet_ntop(addr->sa_family, addr, clientstring, addr_size)) {
-          TSDebug(PLUGIN_NAME, "clientip is %s and block_ip is %s", clientstring, block_ip);
+          DBG_GENERAL("clientip is %s and block_ip is %s", clientstring, block_ip);
         }
       }
     }
@@ -318,11 +344,11 @@ TSPluginInit(int argc, const char *argv[])
 
   ip_deny = inet_addr(block_ip);
 
-  TSDebug(PLUGIN_NAME, "initializing stats");
+  DBG_GENERAL("initializing stats");
   init_stats();
   TSHttpHookAdd(TS_HTTP_READ_REQUEST_HDR_HOOK, TSContCreate(redirect_plugin, nullptr));
 
-  TSDebug(PLUGIN_NAME ".init", "block_ip is %s, url_redirect is %s, and uri_redirect is %s", block_ip, url_redirect, uri_redirect);
+  DBG_INIT("block_ip is %s, url_redirect is %s, and uri_redirect is %s", block_ip, url_redirect, uri_redirect);
 
   /*
    *  Demonstrate another tracing function.  This can be used to
@@ -330,9 +356,9 @@ TSPluginInit(int argc, const char *argv[])
    *  be done in debug mode.
    */
 
-  if (TSIsDebugTagSet(PLUGIN_NAME ".demo")) {
-    TSDebug(PLUGIN_NAME ".init", "The redirect_demo tag is set");
+  if (DBG_DEMO_ON) {
+    DBG_INIT("The redirect_demo tag is set");
   } else {
-    TSDebug(PLUGIN_NAME ".init", "The redirect_demo tag is not set");
+    DBG_INIT("The redirect_demo tag is not set");
   }
 }
diff --git a/example/plugins/c-api/remap/remap.cc b/example/plugins/c-api/remap/remap.cc
index 937655459ca..d9d02cdf227 100644
--- a/example/plugins/c-api/remap/remap.cc
+++ b/example/plugins/c-api/remap/remap.cc
@@ -44,6 +44,11 @@
 
 #define PLUGIN_NAME "remap"
 
+namespace
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 class remap_entry
 {
 public:
@@ -136,7 +141,7 @@ store_my_error_message(TSReturnCode retcode, char *err_msg_buf, int buf_size, co
 TSReturnCode
 TSRemapInit(TSRemapInterface *api_info, char *errbuf, int errbuf_size)
 {
-  TSDebug(PLUGIN_NAME, "enter");
+  Dbg(dbg_ctl, "enter");
 
   if (!plugin_init_counter) {
     if (unlikely(!api_info)) {
@@ -171,7 +176,7 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char *errbuf, int errbuf_s
   remap_entry *ri;
   int i;
 
-  TSDebug(PLUGIN_NAME, "enter"); // Debug output automatically includes the file, line #, and function.
+  Dbg(dbg_ctl, "enter"); // Debug output automatically includes the file, line #, and function.
 
   if (argc < 2) {
     return store_my_error_message(TS_ERROR, errbuf, errbuf_size, "Incorrect number of arguments - %d", argc);
@@ -181,7 +186,7 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char *errbuf, int errbuf_s
   }
   // print all arguments for this particular remapping
   for (i = 0; i < argc; i++) {
-    TSDebug(PLUGIN_NAME, "[%s] - argv[%d] = \"%s\"\n", __func__, i, argv[i]);
+    Dbg(dbg_ctl, "[%s] - argv[%d] = \"%s\"\n", __func__, i, argv[i]);
   }
 
   ri = new remap_entry(argc, argv);
@@ -202,7 +207,7 @@ TSRemapDeleteInstance(void *ih)
 {
   remap_entry *ri = static_cast<remap_entry *>(ih);
 
-  TSDebug(PLUGIN_NAME, "enter");
+  Dbg(dbg_ctl, "enter");
 
   remap_entry::remove_from_list(ri);
 
@@ -223,53 +228,53 @@ TSRemapDoRemap(void *ih, TSHttpTxn rh, TSRemapRequestInfo *rri)
   uint64_t _processing_counter = processing_counter++;
 
   remap_entry *ri = static_cast<remap_entry *>(ih);
-  TSDebug(PLUGIN_NAME, "enter");
+  Dbg(dbg_ctl, "enter");
 
   if (!ri || !rri) {
     return TSREMAP_NO_REMAP; /* TS must remap this request */
   }
 
-  TSDebug(PLUGIN_NAME, "From: \"%s\"  To: \"%s\"\n", ri->argv[0], ri->argv[1]);
+  Dbg(dbg_ctl, "From: \"%s\"  To: \"%s\"\n", ri->argv[0], ri->argv[1]);
 
   temp = TSUrlHostGet(rri->requestBufp, rri->requestUrl, &len);
-  TSDebug(PLUGIN_NAME, "Request Host(%d): \"%.*s\"\n", len, len, temp);
+  Dbg(dbg_ctl, "Request Host(%d): \"%.*s\"\n", len, len, temp);
 
   temp = TSUrlHostGet(rri->requestBufp, rri->mapToUrl, &len);
-  TSDebug(PLUGIN_NAME, "Remap To Host: \"%.*s\"\n", len, temp);
+  Dbg(dbg_ctl, "Remap To Host: \"%.*s\"\n", len, temp);
 
   temp = TSUrlHostGet(rri->requestBufp, rri->mapFromUrl, &len);
-  TSDebug(PLUGIN_NAME, "Remap From Host: \"%.*s\"\n", len, temp);
+  Dbg(dbg_ctl, "Remap From Host: \"%.*s\"\n", len, temp);
 
-  TSDebug(PLUGIN_NAME, "Request Port: %d\n", TSUrlPortGet(rri->requestBufp, rri->requestUrl));
-  TSDebug(PLUGIN_NAME, "Remap From Port: %d\n", TSUrlPortGet(rri->requestBufp, rri->mapFromUrl));
-  TSDebug(PLUGIN_NAME, "Remap To Port: %d\n", TSUrlPortGet(rri->requestBufp, rri->mapToUrl));
+  Dbg(dbg_ctl, "Request Port: %d\n", TSUrlPortGet(rri->requestBufp, rri->requestUrl));
+  Dbg(dbg_ctl, "Remap From Port: %d\n", TSUrlPortGet(rri->requestBufp, rri->mapFromUrl));
+  Dbg(dbg_ctl, "Remap To Port: %d\n", TSUrlPortGet(rri->requestBufp, rri->mapToUrl));
 
   temp = TSUrlPathGet(rri->requestBufp, rri->requestUrl, &len);
-  TSDebug(PLUGIN_NAME, "Request Path: \"%.*s\"\n", len, temp);
+  Dbg(dbg_ctl, "Request Path: \"%.*s\"\n", len, temp);
 
   temp = TSUrlPathGet(rri->requestBufp, rri->mapFromUrl, &len);
-  TSDebug(PLUGIN_NAME, "Remap From Path: \"%.*s\"\n", len, temp);
+  Dbg(dbg_ctl, "Remap From Path: \"%.*s\"\n", len, temp);
 
   temp = TSUrlPathGet(rri->requestBufp, rri->mapToUrl, &len);
-  TSDebug(PLUGIN_NAME, "Remap To Path: \"%.*s\"\n", len, temp);
+  Dbg(dbg_ctl, "Remap To Path: \"%.*s\"\n", len, temp);
 
   // InkAPI usage case
   const char *value;
 
   if ((cfield = TSMimeHdrFieldFind(rri->requestBufp, rri->requestHdrp, TS_MIME_FIELD_DATE, -1)) != TS_NULL_MLOC) {
-    TSDebug(PLUGIN_NAME, "We have \"Date\" header in request\n");
+    Dbg(dbg_ctl, "We have \"Date\" header in request\n");
     value = TSMimeHdrFieldValueStringGet(rri->requestBufp, rri->requestHdrp, cfield, -1, nullptr);
-    TSDebug(PLUGIN_NAME, "Header value: %s\n", value);
+    Dbg(dbg_ctl, "Header value: %s\n", value);
   }
   if ((cfield = TSMimeHdrFieldFind(rri->requestBufp, rri->requestHdrp, "MyHeader", sizeof("MyHeader") - 1)) != TS_NULL_MLOC) {
-    TSDebug(PLUGIN_NAME, "We have \"MyHeader\" header in request\n");
+    Dbg(dbg_ctl, "We have \"MyHeader\" header in request\n");
     value = TSMimeHdrFieldValueStringGet(rri->requestBufp, rri->requestHdrp, cfield, -1, nullptr);
-    TSDebug(PLUGIN_NAME, "Header value: %s\n", value);
+    Dbg(dbg_ctl, "Header value: %s\n", value);
   }
 
   // How to store plugin private arguments inside Traffic Server request processing block.
   if (TSUserArgIndexReserve(TS_USER_ARGS_TXN, "remap_example", "Example remap plugin", &arg_index) == TS_SUCCESS) {
-    TSDebug(PLUGIN_NAME, "Save processing counter %" PRIu64 " inside request processing block\n", _processing_counter);
+    Dbg(dbg_ctl, "Save processing counter %" PRIu64 " inside request processing block\n", _processing_counter);
     TSUserArgSet(rh, arg_index, (void *)_processing_counter); // save counter
   }
   // How to cancel request processing and return error message to the client
@@ -325,6 +330,6 @@ TSRemapOSResponse(void *ih ATS_UNUSED, TSHttpTxn rh, int os_response_type)
   void *data     = TSUserArgGet(rh, arg_index); // read counter (we store it in TSRemapDoRemap function call)
   int request_id = data ? static_cast<int *>(data)[0] : -1;
 
-  TSDebug(PLUGIN_NAME, "Read processing counter %d from request processing block\n", request_id);
-  TSDebug(PLUGIN_NAME, "OS response status: %d\n", os_response_type);
+  Dbg(dbg_ctl, "Read processing counter %d from request processing block\n", request_id);
+  Dbg(dbg_ctl, "OS response status: %d\n", os_response_type);
 }
diff --git a/example/plugins/c-api/remap_header_add/remap_header_add.cc b/example/plugins/c-api/remap_header_add/remap_header_add.cc
index 9855af84642..8f0c8768adb 100644
--- a/example/plugins/c-api/remap_header_add/remap_header_add.cc
+++ b/example/plugins/c-api/remap_header_add/remap_header_add.cc
@@ -45,6 +45,11 @@ struct remap_line {
 
 #define PLUGIN_NAME "headeradd_remap"
 
+namespace
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 void
 ParseArgIntoNv(const char *arg, char **n, char **v)
 {
@@ -53,7 +58,7 @@ ParseArgIntoNv(const char *arg, char **n, char **v)
   if (colon_pos == nullptr) {
     *n = nullptr;
     *v = nullptr;
-    TSDebug(PLUGIN_NAME, "No name value pair since it was malformed");
+    Dbg(dbg_ctl, "No name value pair since it was malformed");
     return;
   }
 
@@ -74,7 +79,7 @@ ParseArgIntoNv(const char *arg, char **n, char **v)
   memcpy(*v, colon_pos + 1, val_len);
   (*v)[val_len] = '\0';
 
-  TSDebug(PLUGIN_NAME, "\t name_len=%zu, val_len=%zu, %s=%s", name_len, val_len, *n, *v);
+  Dbg(dbg_ctl, "\t name_len=%zu, val_len=%zu, %s=%s", name_len, val_len, *n, *v);
 }
 
 TSReturnCode
@@ -88,7 +93,7 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char *, int)
 {
   remap_line *rl = nullptr;
 
-  TSDebug(PLUGIN_NAME, "TSRemapNewInstance()");
+  Dbg(dbg_ctl, "TSRemapNewInstance()");
 
   if (!argv || !ih) {
     TSError("[%s] Unable to load plugin because missing argv or ih", PLUGIN_NAME);
@@ -106,7 +111,7 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char *, int)
     rl->val  = static_cast<char **>(TSmalloc(sizeof(char *) * rl->nvc));
   }
 
-  TSDebug(PLUGIN_NAME, "NewInstance:");
+  Dbg(dbg_ctl, "NewInstance:");
   for (int i = 2; i < argc; i++) {
     ParseArgIntoNv(argv[i], &rl->name[i - 2], &rl->val[i - 2]);
   }
@@ -119,7 +124,7 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char *, int)
 void
 TSRemapDeleteInstance(void *ih)
 {
-  TSDebug(PLUGIN_NAME, "deleting instance %p", ih);
+  Dbg(dbg_ctl, "deleting instance %p", ih);
 
   if (ih) {
     remap_line *rl = static_cast<remap_line *>(ih);
@@ -144,7 +149,7 @@ TSRemapDoRemap(void *ih, TSHttpTxn txn, TSRemapRequestInfo *rri)
     return TSREMAP_NO_REMAP;
   }
 
-  TSDebug(PLUGIN_NAME, "TSRemapDoRemap:");
+  Dbg(dbg_ctl, "TSRemapDoRemap:");
 
   TSMBuffer req_bufp;
   TSMLoc req_loc;
@@ -154,7 +159,7 @@ TSRemapDoRemap(void *ih, TSHttpTxn txn, TSRemapRequestInfo *rri)
   }
 
   for (int i = 0; i < rl->nvc; ++i) {
-    TSDebug(PLUGIN_NAME, R"(Attaching header "%s" with value "%s".)", rl->name[i], rl->val[i]);
+    Dbg(dbg_ctl, R"(Attaching header "%s" with value "%s".)", rl->name[i], rl->val[i]);
 
     TSMLoc field_loc;
     if (TSMimeHdrFieldCreate(req_bufp, req_loc, &field_loc) == TS_SUCCESS) {
diff --git a/example/plugins/c-api/request_buffer/request_buffer.cc b/example/plugins/c-api/request_buffer/request_buffer.cc
index 1402e7e7a60..cf6cc3b5608 100644
--- a/example/plugins/c-api/request_buffer/request_buffer.cc
+++ b/example/plugins/c-api/request_buffer/request_buffer.cc
@@ -33,6 +33,11 @@
 
 #define TS_NULL_MUTEX nullptr
 
+namespace
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 static char *
 request_body_get(TSHttpTxn txnp, int *len)
 {
@@ -65,12 +70,12 @@ request_body_get(TSHttpTxn txnp, int *len)
 static int
 request_buffer_plugin(TSCont contp, TSEvent event, void *edata)
 {
-  TSDebug(PLUGIN_NAME, "request_buffer_plugin starting, event[%d]", event);
+  Dbg(dbg_ctl, "request_buffer_plugin starting, event[%d]", event);
   TSHttpTxn txnp = (TSHttpTxn)(edata);
   if (event == TS_EVENT_HTTP_REQUEST_BUFFER_READ_COMPLETE) {
     int len    = 0;
     char *body = request_body_get(txnp, &len);
-    TSDebug(PLUGIN_NAME, "request_buffer_plugin gets the request body with length[%d]", len);
+    Dbg(dbg_ctl, "request_buffer_plugin gets the request body with length[%d]", len);
     TSfree(body);
     TSContDestroy(contp);
   } else {
@@ -102,7 +107,7 @@ is_post_request(TSHttpTxn txnp)
 static int
 global_plugin(TSCont contp ATS_UNUSED, TSEvent event, void *edata)
 {
-  TSDebug(PLUGIN_NAME, "transform_plugin starting");
+  Dbg(dbg_ctl, "transform_plugin starting");
   TSHttpTxn txnp = (TSHttpTxn)edata;
 
   switch (event) {
@@ -130,7 +135,7 @@ TSPluginInit(int argc ATS_UNUSED, const char *argv[] ATS_UNUSED)
   info.support_email = "dev@trafficserver.apache.org";
 
   if (TSPluginRegister(&info) != TS_SUCCESS) {
-    TSDebug(PLUGIN_NAME, "[%s] Plugin registration failed, plugin disabled", PLUGIN_NAME);
+    Dbg(dbg_ctl, "[%s] Plugin registration failed, plugin disabled", PLUGIN_NAME);
 
     return;
   }
@@ -140,5 +145,5 @@ TSPluginInit(int argc ATS_UNUSED, const char *argv[] ATS_UNUSED)
 
   TSMutex mutex = TS_NULL_MUTEX;
   TSHttpHookAdd(TS_HTTP_READ_REQUEST_HDR_HOOK, TSContCreate(global_plugin, mutex));
-  TSDebug(PLUGIN_NAME, "[%s] Plugin registration succeeded", PLUGIN_NAME);
+  Dbg(dbg_ctl, "[%s] Plugin registration succeeded", PLUGIN_NAME);
 }
diff --git a/example/plugins/c-api/response_header_1/response_header_1.cc b/example/plugins/c-api/response_header_1/response_header_1.cc
index 535bfc39cd5..04ef5656417 100644
--- a/example/plugins/c-api/response_header_1/response_header_1.cc
+++ b/example/plugins/c-api/response_header_1/response_header_1.cc
@@ -46,6 +46,11 @@
 
 #define PLUGIN_NAME "response_header_1"
 
+namespace
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 static int init_buffer_status;
 
 static char *mimehdr1_name;
@@ -87,9 +92,9 @@ modify_header(TSHttpTxn txnp)
   resp_status = TSHttpHdrStatusGet(resp_bufp, resp_loc);
 
   if (TS_HTTP_STATUS_OK == resp_status) {
-    TSDebug(PLUGIN_NAME, "Processing 200 OK");
+    Dbg(dbg_ctl, "Processing 200 OK");
     TSMimeHdrFieldCreate(resp_bufp, resp_loc, &new_field_loc); /* Probably should check for errors */
-    TSDebug(PLUGIN_NAME, "Created new resp field with loc %p", new_field_loc);
+    Dbg(dbg_ctl, "Created new resp field with loc %p", new_field_loc);
 
     /* copy name/values created at init
      * ( "x-num-served-from-cache" ) : ( "0"  )
@@ -101,7 +106,7 @@ modify_header(TSHttpTxn txnp)
 
     /* Cache-Control: Public */
     TSMimeHdrFieldCreate(resp_bufp, resp_loc, &new_field_loc); /* Probably should check for errors */
-    TSDebug(PLUGIN_NAME, "Created new resp field with loc %p", new_field_loc);
+    Dbg(dbg_ctl, "Created new resp field with loc %p", new_field_loc);
     TSMimeHdrFieldAppend(resp_bufp, resp_loc, new_field_loc);
     TSMimeHdrFieldNameSet(resp_bufp, resp_loc, new_field_loc, TS_MIME_FIELD_CACHE_CONTROL, TS_MIME_LEN_CACHE_CONTROL);
     TSMimeHdrFieldValueStringInsert(resp_bufp, resp_loc, new_field_loc, -1, TS_HTTP_VALUE_PUBLIC, TS_HTTP_LEN_PUBLIC);
@@ -110,7 +115,7 @@ modify_header(TSHttpTxn txnp)
      * mimehdr2_name  = TSstrdup( "x-date-200-recvd" ) : CurrentDateTime
      */
     TSMimeHdrFieldCreate(resp_bufp, resp_loc, &new_field_loc); /* Probably should check for errors */
-    TSDebug(PLUGIN_NAME, "Created new resp field with loc %p", new_field_loc);
+    Dbg(dbg_ctl, "Created new resp field with loc %p", new_field_loc);
     TSMimeHdrFieldAppend(resp_bufp, resp_loc, new_field_loc);
     TSMimeHdrFieldNameSet(resp_bufp, resp_loc, new_field_loc, mimehdr2_name, strlen(mimehdr2_name));
 
@@ -121,7 +126,7 @@ modify_header(TSHttpTxn txnp)
     TSHandleMLocRelease(resp_bufp, TS_NULL_MLOC, resp_loc);
 
   } else if (TS_HTTP_STATUS_NOT_MODIFIED == resp_status) {
-    TSDebug(PLUGIN_NAME, "Processing 304 Not Modified");
+    Dbg(dbg_ctl, "Processing 304 Not Modified");
 
     /* N.B.: Protect writes to data (hash on URL + mutex: (ies)) */
 
@@ -151,12 +156,12 @@ modify_header(TSHttpTxn txnp)
       TSHandleMLocRelease(cached_bufp, cached_loc, cached_field_loc);
       return; /* Caller reenables */
     }
-    TSDebug(PLUGIN_NAME, "Header field value is %s, with length %d", chkptr, chklength);
+    Dbg(dbg_ctl, "Header field value is %s, with length %d", chkptr, chklength);
 
     /* Get the cached MIME value for this name in this HTTP header */
     /*
        TSMimeHdrFieldValueUintGet(cached_bufp, cached_loc, cached_field_loc, 0, &num_refreshes);
-       TSDebug(PLUGIN_NAME,
+       Dbg(dbg_ctl,
        "Cached header shows %d refreshes so far", num_refreshes );
 
        num_refreshes++ ;
@@ -188,7 +193,7 @@ modify_header(TSHttpTxn txnp)
     TSHandleMLocRelease(resp_bufp, TS_NULL_MLOC, resp_loc);
 
   } else {
-    TSDebug(PLUGIN_NAME, "other response code %d", resp_status);
+    Dbg(dbg_ctl, "other response code %d", resp_status);
   }
 
   /*
@@ -205,7 +210,7 @@ modify_response_header_plugin(TSCont contp ATS_UNUSED, TSEvent event, void *edat
 
   switch (event) {
   case TS_EVENT_HTTP_READ_RESPONSE_HDR:
-    TSDebug(PLUGIN_NAME, "Called back with TS_EVENT_HTTP_READ_RESPONSE_HDR");
+    Dbg(dbg_ctl, "Called back with TS_EVENT_HTTP_READ_RESPONSE_HDR");
     modify_header(txnp);
     TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
     /*  fall through  */
@@ -256,13 +261,13 @@ TSPluginInit(int argc, const char *argv[])
    */
   mimehdr2_name = TSstrdup("x-date-200-recvd");
 
-  TSDebug(PLUGIN_NAME, "Inserting header %s with value %s into init buffer", mimehdr1_name, mimehdr1_value);
+  Dbg(dbg_ctl, "Inserting header %s with value %s into init buffer", mimehdr1_name, mimehdr1_value);
 
   TSMimeHdrFieldCreate(hdr_bufp, hdr_loc, &field_loc); /* Probably should check for errors */
   TSMimeHdrFieldAppend(hdr_bufp, hdr_loc, field_loc);
   TSMimeHdrFieldNameSet(hdr_bufp, hdr_loc, field_loc, mimehdr1_name, strlen(mimehdr1_name));
   TSMimeHdrFieldValueStringInsert(hdr_bufp, hdr_loc, field_loc, -1, mimehdr1_value, strlen(mimehdr1_value));
-  TSDebug(PLUGIN_NAME, "init buffer hdr, field and value locs are %p, %p and %p", hdr_loc, field_loc, value_loc);
+  Dbg(dbg_ctl, "init buffer hdr, field and value locs are %p, %p and %p", hdr_loc, field_loc, value_loc);
   init_buffer_status = 1;
 
   TSHttpHookAdd(TS_HTTP_READ_RESPONSE_HDR_HOOK, TSContCreate(modify_response_header_plugin, nullptr));
diff --git a/example/plugins/c-api/secure_link/secure_link.cc b/example/plugins/c-api/secure_link/secure_link.cc
index b3fe90b04c1..31351bb761e 100644
--- a/example/plugins/c-api/secure_link/secure_link.cc
+++ b/example/plugins/c-api/secure_link/secure_link.cc
@@ -36,6 +36,11 @@
 
 #define PLUGIN_NAME "secure_link"
 
+namespace
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 typedef struct {
   char *secret;
   uint8_t strict;
@@ -58,7 +63,7 @@ TSRemapDoRemap(void *ih, TSHttpTxn rh, TSRemapRequestInfo *rri)
   in = (struct sockaddr_in *)TSHttpTxnClientAddrGet(rh);
   ip = inet_ntoa(in->sin_addr);
   s  = TSUrlStringGet(rri->requestBufp, rri->requestUrl, &len);
-  TSDebug(PLUGIN_NAME, "request [%.*s] from [%s]", len, s, ip);
+  Dbg(dbg_ctl, "request [%.*s] from [%s]", len, s, ip);
   TSfree(s);
 
   qh = TSUrlHttpQueryGet(rri->requestBufp, rri->requestUrl, &len);
@@ -133,22 +138,22 @@ TSRemapDoRemap(void *ih, TSHttpTxn rh, TSRemapRequestInfo *rri)
   status = TSREMAP_DID_REMAP;
   if (e < t || (nullptr == token || 0 != strcmp(hash, token))) {
     if (e < t) {
-      TSDebug(PLUGIN_NAME, "link expired: [%lu] vs [%lu]", t, e);
+      Dbg(dbg_ctl, "link expired: [%lu] vs [%lu]", t, e);
     } else {
-      TSDebug(PLUGIN_NAME, "tokens mismatch: [%s] vs [%s]", hash, token);
+      Dbg(dbg_ctl, "tokens mismatch: [%s] vs [%s]", hash, token);
     }
     if (sli->strict) {
-      TSDebug(PLUGIN_NAME, "request is DENY");
+      Dbg(dbg_ctl, "request is DENY");
       TSHttpTxnStatusSet(rh, TS_HTTP_STATUS_FORBIDDEN);
       status = TSREMAP_NO_REMAP;
     } else {
-      TSDebug(PLUGIN_NAME, "request is PASS");
+      Dbg(dbg_ctl, "request is PASS");
     }
   }
   if (status == TSREMAP_DID_REMAP) {
     if (TSUrlHttpQuerySet(rri->requestBufp, rri->requestUrl, "", -1) == TS_SUCCESS) {
       s = TSUrlStringGet(rri->requestBufp, rri->requestUrl, &len);
-      TSDebug(PLUGIN_NAME, "new request string is [%.*s]", len, s);
+      Dbg(dbg_ctl, "new request string is [%.*s]", len, s);
       TSfree(s);
     } else {
       status = TSREMAP_NO_REMAP;
@@ -186,7 +191,7 @@ TSRemapNewInstance(int argc, char **argv, void **ih, char *errbuf, int errbuf_si
       } else if (strcmp(argv[i], "policy") == 0) {
         sli->strict = !strcasecmp(ptr, "strict");
       } else {
-        TSDebug(PLUGIN_NAME, "Unknown parameter [%s]", argv[i]);
+        Dbg(dbg_ctl, "Unknown parameter [%s]", argv[i]);
       }
     } else {
       TSError("[%s] Invalid parameter [%s]", PLUGIN_NAME, argv[i]);
diff --git a/example/plugins/c-api/server_transform/server_transform.cc b/example/plugins/c-api/server_transform/server_transform.cc
index 43a58230a59..96a8ffd84a2 100644
--- a/example/plugins/c-api/server_transform/server_transform.cc
+++ b/example/plugins/c-api/server_transform/server_transform.cc
@@ -51,6 +51,11 @@
 
 #define PLUGIN_NAME "server-transform"
 
+namespace
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 #define STATE_BUFFER      1
 #define STATE_CONNECT     2
 #define STATE_WRITE       3
@@ -183,7 +188,7 @@ transform_connect(TSCont contp, TransformData *data)
   ip_addr.sin_family      = AF_INET;
   ip_addr.sin_addr.s_addr = server_ip; /* Should be in network byte order */
   ip_addr.sin_port        = server_port;
-  TSDebug(PLUGIN_NAME, "net connect.");
+  Dbg(dbg_ctl, "net connect.");
   action = TSNetConnect(contp, (struct sockaddr const *)&ip_addr);
 
   if (!TSActionDone(action)) {
@@ -353,13 +358,13 @@ transform_connect_event(TSCont contp, TransformData *data, TSEvent event, void *
 {
   switch (event) {
   case TS_EVENT_NET_CONNECT:
-    TSDebug(PLUGIN_NAME, "connected");
+    Dbg(dbg_ctl, "connected");
 
     data->pending_action = nullptr;
     data->server_vc      = (TSVConn)edata;
     return transform_write(contp, data);
   case TS_EVENT_NET_CONNECT_FAILED:
-    TSDebug(PLUGIN_NAME, "connect failed");
+    Dbg(dbg_ctl, "connect failed");
     data->pending_action = nullptr;
     return transform_bypass(contp, data);
   default:
@@ -496,7 +501,7 @@ transform_handler(TSCont contp, TSEvent event, void *edata)
   /* Check to see if the transformation has been closed by a call to
      TSVConnClose. */
   if (TSVConnClosedGet(contp)) {
-    TSDebug(PLUGIN_NAME, "transformation closed");
+    Dbg(dbg_ctl, "transformation closed");
     transform_destroy(contp);
     return 0;
   } else {
@@ -508,7 +513,7 @@ transform_handler(TSCont contp, TSEvent event, void *edata)
       TSError("[%s] Didn't get Continuation's Data, ignoring event", PLUGIN_NAME);
       return 0;
     }
-    TSDebug(PLUGIN_NAME, "transform handler event [%d], data->state = [%d]", event, data->state);
+    Dbg(dbg_ctl, "transform handler event [%d], data->state = [%d]", event, data->state);
 
     do {
       switch (data->state) {
diff --git a/example/plugins/c-api/session_hooks/session_hooks.cc b/example/plugins/c-api/session_hooks/session_hooks.cc
index 96aa997d943..e314451980e 100644
--- a/example/plugins/c-api/session_hooks/session_hooks.cc
+++ b/example/plugins/c-api/session_hooks/session_hooks.cc
@@ -27,6 +27,11 @@
 
 #define PLUGIN_NAME "session_hooks"
 
+namespace
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 static int transaction_count_stat;
 static int session_count_stat;
 
@@ -37,7 +42,7 @@ txn_handler(TSHttpTxn txnp, TSCont contp)
 
   TSStatIntIncrement(transaction_count_stat, 1);
   num_txns = TSStatIntGet(transaction_count_stat);
-  TSDebug(PLUGIN_NAME, "The number of transactions is %" PRId64, num_txns);
+  Dbg(dbg_ctl, "The number of transactions is %" PRId64, num_txns);
 }
 
 static void
@@ -47,7 +52,7 @@ handle_session(TSHttpSsn ssnp, TSCont contp)
 
   TSStatIntIncrement(session_count_stat, 1);
   num_ssn = TSStatIntGet(session_count_stat);
-  TSDebug(PLUGIN_NAME, "The number of sessions is %" PRId64, num_ssn);
+  Dbg(dbg_ctl, "The number of sessions is %" PRId64, num_ssn);
   TSHttpSsnHookAdd(ssnp, TS_HTTP_TXN_START_HOOK, contp);
 }
 
@@ -72,7 +77,7 @@ ssn_handler(TSCont contp, TSEvent event, void *edata)
     return 0;
 
   default:
-    TSDebug(PLUGIN_NAME, "In the default case: event = %d", event);
+    Dbg(dbg_ctl, "In the default case: event = %d", event);
     break;
   }
   return 0;
diff --git a/example/plugins/c-api/ssl_preaccept/ssl_preaccept.cc b/example/plugins/c-api/ssl_preaccept/ssl_preaccept.cc
index db395df197d..6c33fb81e3a 100644
--- a/example/plugins/c-api/ssl_preaccept/ssl_preaccept.cc
+++ b/example/plugins/c-api/ssl_preaccept/ssl_preaccept.cc
@@ -43,6 +43,8 @@ using IpRange      = std::pair<IpAddr, IpAddr>;
 using IpRangeQueue = std::deque<IpRange>;
 IpRangeQueue ClientBlindTunnelIp;
 
+DbgCtl dbg_ctl{PLUGIN_NAME};
+
 void
 Parse_Addr_String(std::string_view const &text, IpRange &range)
 {
@@ -87,9 +89,9 @@ CB_Pre_Accept(TSCont, TSEvent event, void *edata)
     TSVConnTunnel(ssl_vc);
   }
 
-  TSDebug(PLUGIN_NAME, "Pre accept callback %p - event is %s, target address %s, client address %s%s", ssl_vc,
-          event == TS_EVENT_VCONN_START ? "good" : "bad", ip.toString(buff, sizeof(buff)), ip_client.toString(buff2, sizeof(buff2)),
-          proxy_tunnel ? "" : " blind tunneled");
+  Dbg(dbg_ctl, "Pre accept callback %p - event is %s, target address %s, client address %s%s", ssl_vc,
+      event == TS_EVENT_VCONN_START ? "good" : "bad", ip.toString(buff, sizeof(buff)), ip_client.toString(buff2, sizeof(buff2)),
+      proxy_tunnel ? "" : " blind tunneled");
 
   // All done, reactivate things
   TSVConnReenable(ssl_vc);
@@ -133,7 +135,7 @@ TSPluginInit(int argc, const char *argv[])
   if (!success) {
     TSError(PCP "not initialized");
   }
-  TSDebug(PLUGIN_NAME, "Plugin %s", success ? "online" : "offline");
+  Dbg(dbg_ctl, "Plugin %s", success ? "online" : "offline");
 
   return;
 }
diff --git a/example/plugins/c-api/ssl_sni/ssl_sni.cc b/example/plugins/c-api/ssl_sni/ssl_sni.cc
index be9c5dde982..0e9d82a896e 100644
--- a/example/plugins/c-api/ssl_sni/ssl_sni.cc
+++ b/example/plugins/c-api/ssl_sni/ssl_sni.cc
@@ -36,6 +36,8 @@
 
 namespace
 {
+DbgCtl dbg_ctl{PLUGIN_NAME};
+
 /**
    Somewhat nonsensically exercise some scenarios of proxying
    and blind tunneling from the SNI callback plugin
@@ -58,7 +60,7 @@ CB_servername(TSCont /* contp */, TSEvent /* event */, void *edata)
     if (servername_len >= facebook_name_len) {
       const char *server_ptr = servername + (servername_len - facebook_name_len);
       if (strcmp(server_ptr, "facebook.com") == 0) {
-        TSDebug(PLUGIN_NAME, "Blind tunnel from SNI callback");
+        Dbg(dbg_ctl, "Blind tunnel from SNI callback");
         TSVConnTunnel(ssl_vc);
         // Don't reenable to ensure that we break out of the
         // SSL handshake processing
@@ -67,14 +69,14 @@ CB_servername(TSCont /* contp */, TSEvent /* event */, void *edata)
     }
     // If the name is yahoo, look for a context for safelyfiled and use that here
     if (strcmp("www.yahoo.com", servername) == 0) {
-      TSDebug(PLUGIN_NAME, "SNI name is yahoo ssl obj is %p", sslobj);
+      Dbg(dbg_ctl, "SNI name is yahoo ssl obj is %p", sslobj);
       if (sslobj) {
         TSSslContext ctxobj = TSSslContextFindByName("safelyfiled.com");
         if (ctxobj != nullptr) {
-          TSDebug(PLUGIN_NAME, "Found cert for safelyfiled");
+          Dbg(dbg_ctl, "Found cert for safelyfiled");
           SSL_CTX *ctx = reinterpret_cast<SSL_CTX *>(ctxobj);
           SSL_set_SSL_CTX(ssl, ctx);
-          TSDebug(PLUGIN_NAME, "SNI plugin cb: replace SSL CTX");
+          Dbg(dbg_ctl, "SNI plugin cb: replace SSL CTX");
         }
       }
     }
@@ -113,7 +115,7 @@ TSPluginInit(int argc, const char *argv[])
   if (!success) {
     TSError(PCP "not initialized");
   }
-  TSDebug(PLUGIN_NAME, "Plugin %s", success ? "online" : "offline");
+  Dbg(dbg_ctl, "Plugin %s", success ? "online" : "offline");
 
   return;
 }
diff --git a/example/plugins/c-api/ssl_sni_allowlist/ssl_sni_allowlist.cc b/example/plugins/c-api/ssl_sni_allowlist/ssl_sni_allowlist.cc
index 79002ef0b26..7248cee6150 100644
--- a/example/plugins/c-api/ssl_sni_allowlist/ssl_sni_allowlist.cc
+++ b/example/plugins/c-api/ssl_sni_allowlist/ssl_sni_allowlist.cc
@@ -36,6 +36,8 @@
 
 namespace
 {
+DbgCtl dbg_ctl{PLUGIN_NAME};
+
 int
 CB_servername_allowlist(TSCont /* contp */, TSEvent /* event */, void *edata)
 {
@@ -58,7 +60,7 @@ CB_servername_allowlist(TSCont /* contp */, TSEvent /* event */, void *edata)
     }
   }
   if (do_blind_tunnel) {
-    TSDebug(PLUGIN_NAME, "SNI callback: do blind tunnel for %s", servername);
+    Dbg(dbg_ctl, "SNI callback: do blind tunnel for %s", servername);
     TSVConnTunnel(ssl_vc);
     return TS_SUCCESS; // Don't re-enable so we interrupt processing
   }
@@ -94,7 +96,7 @@ TSPluginInit(int argc, const char *argv[])
   if (!success) {
     TSError(PCP "not initialized");
   }
-  TSDebug(PLUGIN_NAME, "Plugin %s", success ? "online" : "offline");
+  Dbg(dbg_ctl, "Plugin %s", success ? "online" : "offline");
 
   return;
 }
diff --git a/example/plugins/c-api/statistic/statistic.cc b/example/plugins/c-api/statistic/statistic.cc
index f76f736a922..91ba1f62c3b 100644
--- a/example/plugins/c-api/statistic/statistic.cc
+++ b/example/plugins/c-api/statistic/statistic.cc
@@ -35,6 +35,11 @@
 
 #define PLUGIN_NAME "statistics"
 
+namespace
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 void
 TSPluginInit(int /* argc */, const char * /* argv */[])
 {
@@ -67,6 +72,6 @@ TSPluginInit(int /* argc */, const char * /* argv */[])
   // Increment the statistic as time passes.
   TSStatIntIncrement(id, 1);
 
-  TSDebug(PLUGIN_NAME, "%s is set to %" PRId64, name, TSStatIntGet(id));
+  Dbg(dbg_ctl, "%s is set to %" PRId64, name, TSStatIntGet(id));
   TSReleaseAssert(TSPluginRegister(&info) == TS_SUCCESS);
 }
diff --git a/example/plugins/c-api/thread_pool/psi.cc b/example/plugins/c-api/thread_pool/psi.cc
index 499a935182b..2b9c0f3d097 100644
--- a/example/plugins/c-api/thread_pool/psi.cc
+++ b/example/plugins/c-api/thread_pool/psi.cc
@@ -105,6 +105,11 @@ static char psi_directory[PSI_PATH_MAX_SIZE];
 
 static int trylock_handler(TSCont contp, TSEvent event, void *edata);
 
+namespace
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 /*-------------------------------------------------------------------------
   cont_data_alloc
   Allocate and initialize a ContData structure associated to a transaction
@@ -152,7 +157,7 @@ cont_data_alloc()
 static void
 cont_data_destroy(ContData *data)
 {
-  TSDebug(PLUGIN_NAME, "Destroying continuation data");
+  Dbg(dbg_ctl, "Destroying continuation data");
   if (data) {
     TSAssert(data->magic == MAGIC_ALIVE);
     if (data->output_reader) {
@@ -233,13 +238,13 @@ strsearch_ioreader(TSIOBufferReader reader, const char *pattern, int *nparse)
 
   *nparse -= index; /* Adjust nparse so it doesn't include matching chars */
   if (index == slen) {
-    TSDebug(PLUGIN_NAME, "strfind: match for %s at position %d", pattern, *nparse);
+    Dbg(dbg_ctl, "strfind: match for %s at position %d", pattern, *nparse);
     return STR_SUCCESS;
   } else if (index > 0) {
-    TSDebug(PLUGIN_NAME, "strfind: partial match for %s at position %d", pattern, *nparse);
+    Dbg(dbg_ctl, "strfind: partial match for %s at position %d", pattern, *nparse);
     return STR_PARTIAL;
   } else {
-    TSDebug(PLUGIN_NAME, "strfind no match for %s", pattern);
+    Dbg(dbg_ctl, "strfind no match for %s", pattern);
     return STR_FAIL;
   }
 }
@@ -308,7 +313,7 @@ strextract_ioreader(TSIOBufferReader reader, int offset, const char *end_pattern
 
   /* Error, could not read end of filename */
   if (buf_idx >= PSI_FILENAME_MAX_SIZE) {
-    TSDebug(PLUGIN_NAME, "strextract: filename too long");
+    Dbg(dbg_ctl, "strextract: filename too long");
     *buflen = 0;
     return STR_FAIL;
   }
@@ -318,12 +323,12 @@ strextract_ioreader(TSIOBufferReader reader, int offset, const char *end_pattern
     /* Nul terminate the filename, remove the end_pattern copied into the buffer */
     *buflen         = buf_idx - plen;
     buffer[*buflen] = '\0';
-    TSDebug(PLUGIN_NAME, "strextract: filename = |%s|", buffer);
+    Dbg(dbg_ctl, "strextract: filename = |%s|", buffer);
     return STR_SUCCESS;
   }
   /* End of filename not yet reached we need to read some more data */
   else {
-    TSDebug(PLUGIN_NAME, "strextract: partially extracted filename");
+    Dbg(dbg_ctl, "strextract: partially extracted filename");
     *buflen = buf_idx - p_idx;
     return STR_PARTIAL;
   }
@@ -475,7 +480,7 @@ psi_include(TSCont contp, void *edata ATS_UNUSED)
 
   /* Read the include file and copy content into iobuffer */
   if ((filep = TSfopen(inc_file, "r")) != nullptr) {
-    TSDebug(PLUGIN_NAME, "Reading include file %s", inc_file);
+    Dbg(dbg_ctl, "Reading include file %s", inc_file);
 
     char buf[BUFFER_SIZE];
     while (TSfgets(filep, buf, BUFFER_SIZE) != nullptr) {
@@ -554,7 +559,7 @@ wake_up_streams(TSCont contp)
     TSVIOReenable(data->output_vio);
     TSContCall(TSVIOContGet(input_vio), TS_EVENT_VCONN_WRITE_READY, input_vio);
   } else {
-    TSDebug(PLUGIN_NAME, "Total bytes produced by transform = %d", data->transform_bytes);
+    Dbg(dbg_ctl, "Total bytes produced by transform = %d", data->transform_bytes);
     TSVIONBytesSet(data->output_vio, data->transform_bytes);
     TSVIOReenable(data->output_vio);
     TSContCall(TSVIOContGet(input_vio), TS_EVENT_VCONN_WRITE_COMPLETE, input_vio);
@@ -604,7 +609,7 @@ handle_transform(TSCont contp)
 
   /* If the input VIO's buffer is null, the transformation is over */
   if (!TSVIOBufferGet(input_vio)) {
-    TSDebug(PLUGIN_NAME, "input_vio null, terminating transformation");
+    Dbg(dbg_ctl, "input_vio null, terminating transformation");
     TSVIONBytesSet(data->output_vio, data->transform_bytes);
     TSVIOReenable(data->output_vio);
     return 1;
@@ -654,7 +659,7 @@ handle_transform(TSCont contp)
         Job *new_job;
         /* Add a request to include a file into the jobs queue.. */
         /* We'll be called back once it's done with an EVENT_IMMEDIATE */
-        TSDebug(PLUGIN_NAME, "Psi filename extracted, adding an include job to thread queue");
+        Dbg(dbg_ctl, "Psi filename extracted, adding an include job to thread queue");
         data->state = STATE_READ_PSI;
 
         /* Create a new job request and add it to the queue */
@@ -701,7 +706,7 @@ dump_psi(TSCont contp)
     if (psi_output_len > 0) {
       data->transform_bytes += psi_output_len;
 
-      TSDebug(PLUGIN_NAME, "Inserting %d bytes from include file", psi_output_len);
+      Dbg(dbg_ctl, "Inserting %d bytes from include file", psi_output_len);
       /* TODO: Should we check the return value of TSIOBufferCopy() ? */
       TSIOBufferCopy(TSVIOBufferGet(data->output_vio), data->psi_reader, psi_output_len, 0);
       /* Consume all the output data */
@@ -931,7 +936,7 @@ read_response_handler(TSCont contp ATS_UNUSED, TSEvent event, void *edata)
   switch (event) {
   case TS_EVENT_HTTP_READ_RESPONSE_HDR:
     if (transformable(txnp)) {
-      TSDebug(PLUGIN_NAME, "Add a transformation");
+      Dbg(dbg_ctl, "Add a transformation");
       transform_add(txnp);
     }
     TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
@@ -992,5 +997,5 @@ TSPluginInit(int argc ATS_UNUSED, const char *argv[] ATS_UNUSED)
   }
 
   TSHttpHookAdd(TS_HTTP_READ_RESPONSE_HDR_HOOK, TSContCreate(read_response_handler, TSMutexCreate()));
-  TSDebug(PLUGIN_NAME, "Plugin started");
+  Dbg(dbg_ctl, "Plugin started");
 }
diff --git a/example/plugins/c-api/txn_data_sink/txn_data_sink.cc b/example/plugins/c-api/txn_data_sink/txn_data_sink.cc
index af4817ccf32..ce77c4e1d55 100644
--- a/example/plugins/c-api/txn_data_sink/txn_data_sink.cc
+++ b/example/plugins/c-api/txn_data_sink/txn_data_sink.cc
@@ -37,6 +37,8 @@ namespace
 {
 constexpr char const *PLUGIN_NAME = "txn_data_sink";
 
+DbgCtl dbg_ctl{PLUGIN_NAME};
+
 /** The flag for activating response body data sink for a transaction. */
 std::string_view FLAG_DUMP_RESPONSE_BODY = "X-Dump-Response";
 
@@ -103,15 +105,15 @@ body_reader_helper(TSCont contp, TSEvent event, bool sync_response_body)
 
   switch (event) {
   case TS_EVENT_ERROR:
-    TSDebug(PLUGIN_NAME, "Error event");
+    Dbg(dbg_ctl, "Error event");
     TSContCall(TSVIOContGet(input_vio), TS_EVENT_ERROR, input_vio);
     break;
   case TS_EVENT_VCONN_READ_COMPLETE:
-    TSDebug(PLUGIN_NAME, "READ_COMPLETE");
+    Dbg(dbg_ctl, "READ_COMPLETE");
     break;
   case TS_EVENT_VCONN_READ_READY:
   case TS_EVENT_IMMEDIATE:
-    TSDebug(PLUGIN_NAME, "Data event - %s", event == TS_EVENT_IMMEDIATE ? "IMMEDIATE" : "READ_READY");
+    Dbg(dbg_ctl, "Data event - %s", event == TS_EVENT_IMMEDIATE ? "IMMEDIATE" : "READ_READY");
     // Look for data and if we find any, consume it.
     if (TSVIOBufferGet(input_vio)) {
       TSIOBufferReader reader = TSVIOReaderGet(input_vio);
@@ -123,21 +125,21 @@ body_reader_helper(TSCont contp, TSEvent event, bool sync_response_body)
 
         TSIOBufferReaderConsume(reader, n);
         TSVIONDoneSet(input_vio, TSVIONDoneGet(input_vio) + n);
-        TSDebug(PLUGIN_NAME, "Consumed %zd bytes", n);
+        Dbg(dbg_ctl, "Consumed %zd bytes", n);
       }
       if (TSVIONTodoGet(input_vio) > 0) {
         // Signal that we can accept more data.
         TSContCall(TSVIOContGet(input_vio), TS_EVENT_VCONN_WRITE_READY, input_vio);
       } else {
-        TSDebug(PLUGIN_NAME, "Consumed the following body: \"%.*s\"", static_cast<int>(body_bytes.size()), body_bytes.data());
+        Dbg(dbg_ctl, "Consumed the following body: \"%.*s\"", static_cast<int>(body_bytes.size()), body_bytes.data());
         TSContCall(TSVIOContGet(input_vio), TS_EVENT_VCONN_WRITE_COMPLETE, input_vio);
       }
     } else { // The buffer is gone so we're done.
-      TSDebug(PLUGIN_NAME, "upstream buffer disappeared - %zd bytes", body_bytes.size());
+      Dbg(dbg_ctl, "upstream buffer disappeared - %zd bytes", body_bytes.size());
     }
     break;
   default:
-    TSDebug(PLUGIN_NAME, "unhandled event %d", event);
+    Dbg(dbg_ctl, "unhandled event %d", event);
     break;
   }
 
@@ -213,7 +215,7 @@ main_hook(TSCont contp, TSEvent event, void *edata)
 {
   TSHttpTxn txnp = static_cast<TSHttpTxn>(edata);
 
-  TSDebug(PLUGIN_NAME, "Checking transaction for any flags to enable transaction data sink.");
+  Dbg(dbg_ctl, "Checking transaction for any flags to enable transaction data sink.");
   switch (event) {
   case TS_EVENT_HTTP_READ_REQUEST_HDR:
     /// We use @c TSTransformCreate because ATS sees this the same as a
@@ -223,11 +225,11 @@ main_hook(TSCont contp, TSEvent event, void *edata)
     /// is with a transform.
     if (response_sink_requested(txnp)) {
       TSHttpTxnHookAdd(txnp, TS_HTTP_RESPONSE_CLIENT_HOOK, TSTransformCreate(response_body_reader, txnp));
-      TSDebug(PLUGIN_NAME, "Adding response data sink to transaction");
+      Dbg(dbg_ctl, "Adding response data sink to transaction");
     }
     if (request_sink_requested(txnp)) {
       TSHttpTxnHookAdd(txnp, TS_HTTP_REQUEST_CLIENT_HOOK, TSTransformCreate(request_body_reader, txnp));
-      TSDebug(PLUGIN_NAME, "Adding request data sink to transaction");
+      Dbg(dbg_ctl, "Adding request data sink to transaction");
     }
     break;
   default:
diff --git a/example/plugins/c-api/vconn_args/vconn_args.cc b/example/plugins/c-api/vconn_args/vconn_args.cc
index 18620ac8a8c..5d336ed5699 100644
--- a/example/plugins/c-api/vconn_args/vconn_args.cc
+++ b/example/plugins/c-api/vconn_args/vconn_args.cc
@@ -27,7 +27,8 @@
 #include "ts/ts.h"
 
 const char *PLUGIN_NAME = "vconn_arg_test";
-static int last_arg     = 0;
+static DbgCtl dbg_ctl{PLUGIN_NAME};
+static int last_arg = 0;
 
 static int
 vconn_arg_handler(TSCont contp, TSEvent event, void *edata)
@@ -41,7 +42,7 @@ vconn_arg_handler(TSCont contp, TSEvent event, void *edata)
       char *buf = static_cast<char *>(TSmalloc(64));
       snprintf(buf, 64, "Test Arg Idx %d", idx);
       TSUserArgSet(ssl_vc, idx, (void *)buf);
-      TSDebug(PLUGIN_NAME, "Successfully reserve and set arg #%d", idx);
+      Dbg(dbg_ctl, "Successfully reserve and set arg #%d", idx);
     }
     last_arg = idx;
     break;
@@ -53,9 +54,9 @@ vconn_arg_handler(TSCont contp, TSEvent event, void *edata)
       const char *name = nullptr;
       const char *desc = nullptr;
       if (TSUserArgIndexLookup(TS_USER_ARGS_VCONN, idx, &name, &desc) == TS_SUCCESS) {
-        TSDebug(PLUGIN_NAME, "Successful lookup for arg #%d: [%s] [%s]", idx, name, desc);
+        Dbg(dbg_ctl, "Successful lookup for arg #%d: [%s] [%s]", idx, name, desc);
       } else {
-        TSDebug(PLUGIN_NAME, "Failed lookup for arg #%d", idx);
+        Dbg(dbg_ctl, "Failed lookup for arg #%d", idx);
       }
       idx++;
     }
@@ -67,16 +68,16 @@ vconn_arg_handler(TSCont contp, TSEvent event, void *edata)
     while (idx <= last_arg) {
       char *buf = static_cast<char *>(TSUserArgGet(ssl_vc, idx));
       if (buf) {
-        TSDebug(PLUGIN_NAME, "Successfully retrieve vconn arg #%d: %s", idx, buf);
+        Dbg(dbg_ctl, "Successfully retrieve vconn arg #%d: %s", idx, buf);
         TSfree(buf);
       } else {
-        TSDebug(PLUGIN_NAME, "Failed to retrieve vconn arg #%d", idx);
+        Dbg(dbg_ctl, "Failed to retrieve vconn arg #%d", idx);
       }
       idx++;
     }
   } break;
   default: {
-    TSDebug(PLUGIN_NAME, "Unexpected event %d", event);
+    Dbg(dbg_ctl, "Unexpected event %d", event);
     break;
   }
   }
@@ -87,7 +88,7 @@ vconn_arg_handler(TSCont contp, TSEvent event, void *edata)
 void
 TSPluginInit(int argc, const char *argv[])
 {
-  TSDebug(PLUGIN_NAME, "Initializing plugin.");
+  Dbg(dbg_ctl, "Initializing plugin.");
   TSPluginRegistrationInfo info;
   info.plugin_name   = PLUGIN_NAME;
   info.vendor_name   = "Oath";
diff --git a/example/plugins/c-api/verify_cert/verify_cert.cc b/example/plugins/c-api/verify_cert/verify_cert.cc
index f59495f1517..1932a703432 100644
--- a/example/plugins/c-api/verify_cert/verify_cert.cc
+++ b/example/plugins/c-api/verify_cert/verify_cert.cc
@@ -34,6 +34,8 @@
 
 namespace
 {
+DbgCtl dbg_ctl{PLUGIN_NAME};
+
 static void
 debug_certificate(const char *msg, X509_NAME *name)
 {
@@ -52,7 +54,7 @@ debug_certificate(const char *msg, X509_NAME *name)
     long len;
     char *ptr;
     len = BIO_get_mem_data(bio, &ptr);
-    TSDebug(PLUGIN_NAME, "%s %.*s", msg, static_cast<int>(len), ptr);
+    Dbg(dbg_ctl, "%s %.*s", msg, static_cast<int>(len), ptr);
   }
 
   BIO_free(bio);
@@ -69,7 +71,7 @@ CB_clientcert(TSCont /* contp */, TSEvent /* event */, void *edata)
 #else
   X509 *cert = SSL_get_peer_certificate(ssl);
 #endif
-  TSDebug(PLUGIN_NAME, "plugin verify_cert verifying client certificate");
+  Dbg(dbg_ctl, "plugin verify_cert verifying client certificate");
   if (cert) {
     debug_certificate("client certificate subject CN is %s", X509_get_subject_name(cert));
     debug_certificate("client certificate issuer CN is %s", X509_get_issuer_name(cert));
@@ -106,7 +108,7 @@ TSPluginInit(int argc, const char *argv[])
   if (!success) {
     TSError(PCP "not initialized");
   }
-  TSDebug(PLUGIN_NAME, "Plugin %s", success ? "online" : "offline");
+  Dbg(dbg_ctl, "Plugin %s", success ? "online" : "offline");
 
   return;
 }
diff --git a/example/plugins/c-api/version/version.cc b/example/plugins/c-api/version/version.cc
index bc1c86a5090..53d88a3bb13 100644
--- a/example/plugins/c-api/version/version.cc
+++ b/example/plugins/c-api/version/version.cc
@@ -26,6 +26,11 @@
 
 #define PLUGIN_NAME "version"
 
+namespace
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 void
 TSPluginInit(int argc, const char *argv[])
 {
@@ -59,5 +64,5 @@ TSPluginInit(int argc, const char *argv[])
     TSError("[%s] Plugin registration failed.", PLUGIN_NAME);
   }
 
-  TSDebug(PLUGIN_NAME, "Running in Apache Traffic Server: v%d.%d.%d", major_ts_version, minor_ts_version, patch_ts_version);
+  Dbg(dbg_ctl, "Running in Apache Traffic Server: v%d.%d.%d", major_ts_version, minor_ts_version, patch_ts_version);
 }
diff --git a/include/ts/DbgCtl.h b/include/ts/DbgCtl.h
index 1aac8644614..a2130a9d281 100644
--- a/include/ts/DbgCtl.h
+++ b/include/ts/DbgCtl.h
@@ -40,11 +40,11 @@ class DbgCtl
 
   // As instance with no tag will always be off.
   //
-  DbgCtl() : _ptr{&_No_tag_dummy} {}
+  DbgCtl() : _ptr{&_No_tag_dummy()} {}
 
   ~DbgCtl()
   {
-    if (_ptr != &_No_tag_dummy) {
+    if (_ptr != &_No_tag_dummy()) {
       _rm_reference();
     }
   }
@@ -119,7 +119,12 @@ class DbgCtl
 
   _TagData const *_ptr;
 
-  static const _TagData _No_tag_dummy;
+  static const _TagData &
+  _No_tag_dummy()
+  {
+    static DbgCtl::_TagData const ntd{nullptr, false};
+    return ntd;
+  }
 
   static const _TagData *_new_reference(char const *tag);
 
@@ -144,3 +149,14 @@ class DbgCtl
       DbgPrint((CTL), __VA_ARGS__); \
     }                               \
   } while (false)
+
+// Same as Dbg above, but this allows a positive override of the DbgCtl, if FLAG is true.
+//
+#define SpecificDbg(FLAG, CTL, ...)   \
+  do {                                \
+    if (DbgCtl::global_on()) {        \
+      if ((FLAG) || ((CTL).on())) {   \
+        DbgPrint((CTL), __VA_ARGS__); \
+      }                               \
+    }                                 \
+  } while (false)
diff --git a/include/ts/ts.h b/include/ts/ts.h
index 6d94342a2d6..ae18efe2220 100644
--- a/include/ts/ts.h
+++ b/include/ts/ts.h
@@ -2184,31 +2184,6 @@ namespace c
   */
   TSReturnCode TSRecYAMLConfigParse(TSYaml node, TSYAMLRecNodeHandler handler, void *data);
 
-  /* --------------------------------------------------------------------------
-     tracing api */
-
-  int TSIsDebugTagSet(const char *t);
-  void TSDebug(const char *tag, const char *format_str, ...) TS_PRINTFLIKE(2, 3);
-  /**
-      Output a debug line even if the debug tag is turned off, as long as
-      debugging is enabled. Could be used as follows:
-      @code
-      TSDebugSpecific(TSHttpTxnDebugGet(txn), "plugin_tag" , "Hello World from transaction %p", txn);
-      @endcode
-      will be printed if the plugin_tag is enabled or the transaction specific
-      debugging is turned on for txn.
-
-      @param debug_flag boolean flag.
-      @param tag Debug tag for the line.
-      @param format Format string.
-      @param ... Format arguments.
-   */
-  void TSDebugSpecific(int debug_flag, const char *tag, const char *format_str, ...) TS_PRINTFLIKE(3, 4);
-  extern int diags_on_for_plugins; /* Do not use directly. */
-#define TSDEBUG             \
-  if (diags_on_for_plugins) \
-  TSDebug
-
   /* --------------------------------------------------------------------------
      logging api */
 
diff --git a/include/tscore/Diags.h b/include/tscore/Diags.h
index 52a13ba308b..c3037a7c896 100644
--- a/include/tscore/Diags.h
+++ b/include/tscore/Diags.h
@@ -196,17 +196,6 @@ diags()
     }                                     \
   } while (false)
 
-// Same as Dbg above, but this allows a positive override of the DbgCtl, if flag is true.
-//
-#define SpecificDbg(FLAG, CTL, ...) \
-  do {                              \
-    if (unlikely(diags()->on())) {  \
-      if ((FLAG) || CTL.tag_on()) { \
-        DbgPrint(CTL, __VA_ARGS__); \
-      }                             \
-    }                               \
-  } while (false)
-
 // For better performance, use this instead of diags()->on(tag) when the tag parameter is a C-string literal.
 //
 #define is_debug_tag_set(TAG)                 \
@@ -236,7 +225,6 @@ diags()
 
 #define Diag(...)
 #define Debug(...)
-#define SpecificDbg(...)
 
 #define is_debug_tag_set(_t)      0
 #define is_action_tag_set(_t)     0
diff --git a/include/tscore/DiagsTypes.h b/include/tscore/DiagsTypes.h
index 60b0fe25ab4..e7db4b68216 100644
--- a/include/tscore/DiagsTypes.h
+++ b/include/tscore/DiagsTypes.h
@@ -47,7 +47,6 @@
 #define DIAGS_MAGIC 0x12345678
 #define BYTES_IN_MB 1000000
 
-// extern int diags_on_for_plugins;
 enum DiagsTagType {
   DiagsTagType_Debug  = 0, // do not renumber --- used as array index
   DiagsTagType_Action = 1
@@ -150,12 +149,6 @@ class Diags
     return (config.enabled(mode) & 1) || (config.enabled(mode) == 2 && this->get_override());
   }
 
-  bool
-  on_for_TSDebug() const
-  {
-    return (config.enabled(DiagsTagType_Debug) == 1) || (config.enabled(DiagsTagType_Debug) == 2 && this->get_override());
-  }
-
   // is_debug_tag_set() is the faster alternative to this for debug mode, when the tag is a literal C-string
   // (or otherwise is a constexpr returning char const *).
   //
@@ -165,12 +158,6 @@ class Diags
     return unlikely(this->on(mode)) && tag_activated(tag, mode);
   }
 
-  bool
-  on_for_TSDebug(const char *tag) const
-  {
-    return unlikely(this->on_for_TSDebug()) && tag_activated(tag, DiagsTagType_Debug);
-  }
-
   /////////////////////////////////////
   // low-level tag inquiry functions //
   /////////////////////////////////////
diff --git a/include/tscpp/api/Logger.h b/include/tscpp/api/Logger.h
index 159345741a4..643bd31b4cd 100644
--- a/include/tscpp/api/Logger.h
+++ b/include/tscpp/api/Logger.h
@@ -30,6 +30,7 @@
 
 #include <string>
 #include "tscpp/api/noncopyable.h"
+#include "ts/ts.h"
 
 #if !defined(ATSCPPAPI_PRINTFLIKE)
 #if defined(__GNUC__) || defined(__clang__)
@@ -82,15 +83,6 @@ namespace tsapi
 {
 namespace c
 {
-  /**
-   * We forward declare this because if we didn't we end up writing our
-   * own version to do the vsnprintf just to call TSDebug and have it do
-   * an unnecessary vsnprintf.
-   *
-   * @private
-   */
-  void TSDebug(const char *tag, const char *fmt, ...) ATSCPPAPI_PRINTFLIKE(2, 3);
-
   /**
    * We forward declare this because if we didn't we end up writing our
    * own version to do the vsnprintf just to call TSError and have it do
@@ -109,16 +101,6 @@ namespace c
 #define STRINGIFY(x)  STRINGIFY0(x)
 #define LINE_NO       STRINGIFY(__LINE__)
 
-/**
- * A helper macro to get access to the Diag messages available in traffic server. These can be enabled
- * via traffic_server -T "tag.*" or since this macro includes the file can you further refine to an
- * individual file or even a particular line! This can also be enabled via records.yaml.
- */
-#define TS_DEBUG(tag, fmt, ...)                                                        \
-  do {                                                                                 \
-    TSDebug(tag "." __FILE__ ":" LINE_NO, "[%s()] " fmt, __FUNCTION__, ##__VA_ARGS__); \
-  } while (false)
-
 /**
  * A helper macro to get access to the error.log messages available in traffic server. This
  * will also output a DEBUG message visible via traffic_server -T "tag.*", or by enabling the
@@ -126,7 +108,8 @@ namespace c
  */
 #define TS_ERROR(tag, fmt, ...)                                                               \
   do {                                                                                        \
-    TS_DEBUG(tag, "[ERROR] " fmt, ##__VA_ARGS__);                                             \
+    DbgCtl dc{tag};                                                                           \
+    Dbg(dc, "[ERROR] " fmt, ##__VA_ARGS__);                                                   \
     TSError("[%s] [%s:%d, %s()] " fmt, tag, __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__); \
   } while (false)
 
diff --git a/plugins/authproxy/utils.cc b/plugins/authproxy/utils.cc
index e9a9a7568a6..bfe7562af56 100644
--- a/plugins/authproxy/utils.cc
+++ b/plugins/authproxy/utils.cc
@@ -28,6 +28,8 @@
 #include <arpa/inet.h>
 #include <string_view>
 
+DbgCtl Auth_dbg_ctl{"authproxy"};
+
 void
 HttpDebugHeader(TSMBuffer mbuf, TSMLoc mhdr)
 {
diff --git a/plugins/authproxy/utils.h b/plugins/authproxy/utils.h
index 1249a3eb911..82a2209086d 100644
--- a/plugins/authproxy/utils.h
+++ b/plugins/authproxy/utils.h
@@ -24,7 +24,9 @@
 #include <netinet/in.h>
 #include <memory>
 
-#define AuthLogDebug(fmt, ...) TSDebug("authproxy", "%s: " fmt, __func__, ##__VA_ARGS__)
+extern DbgCtl Auth_dbg_ctl;
+
+#define AuthLogDebug(fmt, ...) Dbg(Auth_dbg_ctl, "%s: " fmt, __func__, ##__VA_ARGS__)
 #define AuthLogError(fmt, ...) TSError(fmt, ##__VA_ARGS__)
 
 template <typename T>
diff --git a/plugins/background_fetch/background_fetch.cc b/plugins/background_fetch/background_fetch.cc
index 1b85ac2d877..f07115dc28c 100644
--- a/plugins/background_fetch/background_fetch.cc
+++ b/plugins/background_fetch/background_fetch.cc
@@ -79,7 +79,7 @@ class BgFetchState
   createLog(const std::string &log_name)
   {
     if (!_log) {
-      TSDebug(PLUGIN_NAME, "Creating log name %s", log_name.c_str());
+      Dbg(Bg_dbg_ctl, "Creating log name %s", log_name.c_str());
       TSAssert(TS_SUCCESS == TSTextLogObjectCreate(log_name.c_str(), TS_LOG_MODE_ADD_TIMESTAMP, &_log));
     } else {
       TSError("[%s] A log file was already create, ignoring creation of %s", PLUGIN_NAME, log_name.c_str());
@@ -106,7 +106,7 @@ class BgFetchState
     }
     TSMutexUnlock(_lock);
 
-    TSDebug(PLUGIN_NAME, "BgFetchState.acquire(): ret = %d, url = %s", ret, url.c_str());
+    Dbg(Bg_dbg_ctl, "BgFetchState.acquire(): ret = %d, url = %s", ret, url.c_str());
 
     return ret;
   }
@@ -263,7 +263,7 @@ BgFetchData::initialize(TSMBuffer request, TSMLoc req_hdr, TSHttpTxn txnp)
           if (TS_SUCCESS == TSHttpTxnCacheLookupUrlGet(txnp, request, c_url)) {
             url = TSUrlStringGet(request, c_url, &len);
             TSHandleMLocRelease(request, TS_NULL_MLOC, c_url);
-            TSDebug(PLUGIN_NAME, "Cache URL is %.*s", len, url);
+            Dbg(Bg_dbg_ctl, "Cache URL is %.*s", len, url);
           }
         }
 
@@ -276,13 +276,13 @@ BgFetchData::initialize(TSMBuffer request, TSMLoc req_hdr, TSHttpTxn txnp)
             const char *hostp = TSUrlHostGet(mbuf, url_loc, &len);
 
             if (set_header(mbuf, hdr_loc, TS_MIME_FIELD_HOST, TS_MIME_LEN_HOST, hostp, len)) {
-              TSDebug(PLUGIN_NAME, "Set header Host: %.*s", len, hostp);
+              Dbg(Bg_dbg_ctl, "Set header Host: %.*s", len, hostp);
             }
 
             // Next, remove the Range headers and IMS (conditional) headers from the request
             for (auto const &header : FILTER_HEADERS) {
               if (remove_header(mbuf, hdr_loc, header.data(), header.size()) > 0) {
-                TSDebug(PLUGIN_NAME, "Removed the %s header from request", header.data());
+                Dbg(Bg_dbg_ctl, "Removed the %s header from request", header.data());
               }
             }
 
@@ -327,7 +327,7 @@ BgFetchData::log(TSEvent event) const
 {
   TSTextLogObject log = BgFetchState::getInstance().getLog();
 
-  if (log || TSIsDebugTagSet(PLUGIN_NAME)) {
+  if (log || Bg_dbg_ctl.on()) {
     const char *status;
 
     switch (event) {
@@ -349,7 +349,7 @@ BgFetchData::log(TSEvent event) const
     }
 
     // ToDo: Also deal with per-remap tagging
-    TSDebug(PLUGIN_NAME, "%s %" PRId64 " %s %s", "-", _bytes, status, _url.c_str());
+    Dbg(Bg_dbg_ctl, "%s %" PRId64 " %s %s", "-", _bytes, status, _url.c_str());
     if (log) {
       TSTextLogObjectWrite(log, "%s %" PRId64 " %s %s", "-", _bytes, status, _url.c_str());
     }
@@ -370,24 +370,24 @@ cont_bg_fetch(TSCont contp, TSEvent event, void * /* edata ATS_UNUSED */)
   case TS_EVENT_IMMEDIATE:
   case TS_EVENT_TIMEOUT:
     // Debug info for this particular bg fetch (put all debug in here please)
-    if (TSIsDebugTagSet(PLUGIN_NAME)) {
+    if (Bg_dbg_ctl.on()) {
       char buf[INET6_ADDRSTRLEN];
       const sockaddr *sockaddress = reinterpret_cast<const sockaddr *>(&data->client_ip);
 
       switch (sockaddress->sa_family) {
       case AF_INET:
         inet_ntop(AF_INET, &(((struct sockaddr_in *)sockaddress)->sin_addr), buf, INET_ADDRSTRLEN);
-        TSDebug(PLUGIN_NAME, "Client IPv4 = %s", buf);
+        Dbg(Bg_dbg_ctl, "Client IPv4 = %s", buf);
         break;
       case AF_INET6:
         inet_ntop(AF_INET6, &(((struct sockaddr_in6 *)sockaddress)->sin6_addr), buf, INET6_ADDRSTRLEN);
-        TSDebug(PLUGIN_NAME, "Client IPv6 = %s", buf);
+        Dbg(Bg_dbg_ctl, "Client IPv6 = %s", buf);
         break;
       default:
         TSError("[%s] Unknown address family %d", PLUGIN_NAME, sockaddress->sa_family);
         break;
       }
-      TSDebug(PLUGIN_NAME, "Starting background fetch, replaying:");
+      Dbg(Bg_dbg_ctl, "Starting background fetch, replaying:");
       dump_headers(data->mbuf, data->hdr_loc);
     }
 
@@ -409,7 +409,7 @@ cont_bg_fetch(TSCont contp, TSEvent event, void * /* edata ATS_UNUSED */)
   case TS_EVENT_VCONN_WRITE_COMPLETE:
     // TSVConnShutdown(data->vc, 0, 1);
     // TSVIOReenable(data->w_vio);
-    TSDebug(PLUGIN_NAME, "Write Complete");
+    Dbg(Bg_dbg_ctl, "Write Complete");
     break;
 
   case TS_EVENT_VCONN_READ_READY:
@@ -425,13 +425,13 @@ cont_bg_fetch(TSCont contp, TSEvent event, void * /* edata ATS_UNUSED */)
   case TS_EVENT_VCONN_INACTIVITY_TIMEOUT:
   case TS_EVENT_ERROR:
     if (event == TS_EVENT_VCONN_INACTIVITY_TIMEOUT) {
-      TSDebug(PLUGIN_NAME, "Encountered Inactivity Timeout");
+      Dbg(Bg_dbg_ctl, "Encountered Inactivity Timeout");
       TSVConnAbort(data->vc, TS_VC_CLOSE_ABORT);
     } else {
       TSVConnClose(data->vc);
     }
 
-    TSDebug(PLUGIN_NAME, "Closing down background transaction, event= %s(%d)", TSHttpEventNameLookup(event), event);
+    Dbg(Bg_dbg_ctl, "Closing down background transaction, event= %s(%d)", TSHttpEventNameLookup(event), event);
     avail = TSIOBufferReaderAvail(data->resp_io_buf_reader);
     data->addBytes(avail);
     TSIOBufferReaderConsume(data->resp_io_buf_reader, avail);
@@ -444,7 +444,7 @@ cont_bg_fetch(TSCont contp, TSEvent event, void * /* edata ATS_UNUSED */)
     break;
 
   default:
-    TSDebug(PLUGIN_NAME, "Unhandled event: %s (%d)", TSHttpEventNameLookup(event), event);
+    Dbg(Bg_dbg_ctl, "Unhandled event: %s (%d)", TSHttpEventNameLookup(event), event);
     break;
   }
 
@@ -471,7 +471,7 @@ cont_check_cacheable(TSCont contp, TSEvent /* event ATS_UNUSED */, void *edata)
       bool cacheable = TSHttpTxnIsCacheable(txnp, nullptr, response);
       TSHttpHdrStatusSet(response, resp_hdr, TS_HTTP_STATUS_PARTIAL_CONTENT);
 
-      TSDebug(PLUGIN_NAME, "Testing: request / response is cacheable?");
+      Dbg(Bg_dbg_ctl, "Testing: request / response is cacheable?");
       if (cacheable) {
         BgFetchData *data = new BgFetchData();
 
@@ -530,7 +530,7 @@ cont_handle_response(TSCont contp, TSEvent event, void *edata)
 
           // Only deal with 206 and possibly 304 responses from Origin
           TSHttpStatus status = TSHttpHdrStatusGet(response, resp_hdr);
-          TSDebug(PLUGIN_NAME, "Testing: response status code: %d?", status);
+          Dbg(Bg_dbg_ctl, "Testing: response status code: %d?", status);
           if (TS_HTTP_STATUS_PARTIAL_CONTENT == status || (config->allow304() && TS_HTTP_STATUS_NOT_MODIFIED == status)) {
             // Everything looks good so far, add a TXN hook for SEND_RESPONSE_HDR
             TSCont localcontp = TSContCreate(cont_check_cacheable, nullptr);
@@ -544,7 +544,7 @@ cont_handle_response(TSCont contp, TSEvent event, void *edata)
       break;
     default:
       TSError("[%s] Unknown event for this plugin", PLUGIN_NAME);
-      TSDebug(PLUGIN_NAME, "unknown event for this plugin");
+      Dbg(Bg_dbg_ctl, "unknown event for this plugin");
       break;
     }
   }
@@ -579,11 +579,11 @@ TSPluginInit(int argc, const char *argv[])
     if (!gConfig->logFile().empty()) {
       BgFetchState::getInstance().createLog(gConfig->logFile());
     }
-    TSDebug(PLUGIN_NAME, "Initialized");
+    Dbg(Bg_dbg_ctl, "Initialized");
     TSHttpHookAdd(TS_HTTP_READ_RESPONSE_HDR_HOOK, cont);
   } else {
     // ToDo: Hmmm, no way to fail a global plugin here?
-    TSDebug(PLUGIN_NAME, "Failed to initialize as global plugin");
+    Dbg(Bg_dbg_ctl, "Failed to initialize as global plugin");
   }
 }
 
@@ -596,7 +596,7 @@ TSReturnCode
 TSRemapInit(TSRemapInterface *api_info, char *errbuf, int errbuf_size)
 {
   CHECK_REMAP_API_COMPATIBILITY(api_info, errbuf, errbuf_size);
-  TSDebug(PLUGIN_NAME, "background fetch remap is successfully initialized");
+  Dbg(Bg_dbg_ctl, "background fetch remap is successfully initialized");
   return TS_SUCCESS;
 }
 
@@ -618,7 +618,7 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char * /* errbuf */, int /
 
   // This is for backwards compatibility, ugly! ToDo: Remove for ATS v9.0.0 IMO.
   if (argc > 1 && *argv[1] != '-') {
-    TSDebug(PLUGIN_NAME, "config file %s", argv[1]);
+    Dbg(Bg_dbg_ctl, "config file %s", argv[1]);
     if (!config->readConfig(argv[1])) {
       success = false;
     }
@@ -675,7 +675,7 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo * /* rri */)
       BgFetchConfig *config = static_cast<BgFetchConfig *>(ih);
 
       TSHttpTxnHookAdd(txnp, TS_HTTP_READ_RESPONSE_HDR_HOOK, config->getCont());
-      TSDebug(PLUGIN_NAME, "TSRemapDoRemap() added hook, request was Range / If-Range");
+      Dbg(Bg_dbg_ctl, "TSRemapDoRemap() added hook, request was Range / If-Range");
       TSHandleMLocRelease(bufp, req_hdrs, field_loc);
     }
     TSHandleMLocRelease(bufp, TS_NULL_MLOC, req_hdrs);
diff --git a/plugins/background_fetch/configs.cc b/plugins/background_fetch/configs.cc
index d6eace2f8a5..a7b86dc23fe 100644
--- a/plugins/background_fetch/configs.cc
+++ b/plugins/background_fetch/configs.cc
@@ -50,18 +50,18 @@ BgFetchConfig::parseOptions(int argc, const char *argv[])
 
     switch (opt) {
     case 'l':
-      TSDebug(PLUGIN_NAME, "option: log file specified: %s", optarg);
+      Dbg(Bg_dbg_ctl, "option: log file specified: %s", optarg);
       _log_file = optarg;
       break;
     case 'c':
-      TSDebug(PLUGIN_NAME, "option: config file '%s'", optarg);
+      Dbg(Bg_dbg_ctl, "option: config file '%s'", optarg);
       if (!readConfig(optarg)) {
         // Error messages are written in the parser
         return false;
       }
       break;
     case 'a':
-      TSDebug(PLUGIN_NAME, "option: --allow-304 set");
+      Dbg(Bg_dbg_ctl, "option: --allow-304 set");
       _allow_304 = true;
       break;
     default:
@@ -86,19 +86,19 @@ BgFetchConfig::readConfig(const char *config_file)
     return false;
   }
 
-  TSDebug(PLUGIN_NAME, "trying to open config file in this path: %s", config_file);
+  Dbg(Bg_dbg_ctl, "trying to open config file in this path: %s", config_file);
 
   if (*config_file == '/') {
     snprintf(file_path, sizeof(file_path), "%s", config_file);
   } else {
     snprintf(file_path, sizeof(file_path), "%s/%s", TSConfigDirGet(), config_file);
   }
-  TSDebug(PLUGIN_NAME, "chosen config file is at: %s", file_path);
+  Dbg(Bg_dbg_ctl, "chosen config file is at: %s", file_path);
 
   file = TSfopen(file_path, "r");
   if (nullptr == file) {
     TSError("[%s] invalid config file:  %s", PLUGIN_NAME, file_path);
-    TSDebug(PLUGIN_NAME, "invalid config file: %s", file_path);
+    Dbg(Bg_dbg_ctl, "invalid config file: %s", file_path);
     return false;
   }
 
@@ -125,7 +125,7 @@ BgFetchConfig::readConfig(const char *config_file)
     char *cfg     = strtok_r(buffer, "\n\r\n", &savePtr);
 
     if (nullptr != cfg) {
-      TSDebug(PLUGIN_NAME, "setting background_fetch exclusion criterion based on string: %s", cfg);
+      Dbg(Bg_dbg_ctl, "setting background_fetch exclusion criterion based on string: %s", cfg);
       char *cfg_type  = strtok_r(buffer, " ", &savePtr);
       char *cfg_name  = nullptr;
       char *cfg_value = nullptr;
@@ -159,7 +159,7 @@ BgFetchConfig::readConfig(const char *config_file)
             }
             cur = r;
 
-            TSDebug(PLUGIN_NAME, "adding background_fetch exclusion rule %d for %s: %s", exclude, cfg_name, cfg_value);
+            Dbg(Bg_dbg_ctl, "adding background_fetch exclusion rule %d for %s: %s", exclude, cfg_name, cfg_value);
           } else {
             TSError("[%s] invalid value %s, skipping config line", PLUGIN_NAME, cfg_name);
           }
@@ -170,7 +170,7 @@ BgFetchConfig::readConfig(const char *config_file)
   }
 
   TSfclose(file);
-  TSDebug(PLUGIN_NAME, "Done parsing config");
+  Dbg(Bg_dbg_ctl, "Done parsing config");
 
   return true;
 }
@@ -182,7 +182,7 @@ BgFetchConfig::readConfig(const char *config_file)
 bool
 BgFetchConfig::bgFetchAllowed(TSHttpTxn txnp) const
 {
-  TSDebug(PLUGIN_NAME, "Testing: request is internal?");
+  Dbg(Bg_dbg_ctl, "Testing: request is internal?");
   if (TSHttpTxnIsInternal(txnp)) {
     return false;
   }
@@ -192,7 +192,7 @@ BgFetchConfig::bgFetchAllowed(TSHttpTxn txnp) const
   // We could do this recursively, but following the linked list is probably more efficient.
   for (const BgFetchRule *r = _rules; nullptr != r; r = r->_next) {
     if (r->check_field_configured(txnp)) {
-      TSDebug(PLUGIN_NAME, "found field match %s, exclude %d", r->_field, static_cast<int>(r->_exclude));
+      Dbg(Bg_dbg_ctl, "found field match %s, exclude %d", r->_field, static_cast<int>(r->_exclude));
       allow_bg_fetch = !r->_exclude;
       break;
     }
diff --git a/plugins/background_fetch/configs.h b/plugins/background_fetch/configs.h
index 0517ffad314..1bf2ab73963 100644
--- a/plugins/background_fetch/configs.h
+++ b/plugins/background_fetch/configs.h
@@ -33,6 +33,8 @@
 // Constants
 const char PLUGIN_NAME[] = "background_fetch";
 
+extern DbgCtl Bg_dbg_ctl;
+
 ///////////////////////////////////////////////////////////////////////////
 // This holds one complete background fetch rule
 //
diff --git a/plugins/background_fetch/headers.cc b/plugins/background_fetch/headers.cc
index a134187239b..09c7601c836 100644
--- a/plugins/background_fetch/headers.cc
+++ b/plugins/background_fetch/headers.cc
@@ -93,7 +93,7 @@ set_header(TSMBuffer bufp, TSMLoc hdr_loc, const char *header, int len, const ch
 }
 
 ///////////////////////////////////////////////////////////////////////////
-// Dump a header on stderr, useful together with TSDebug().
+// Dump a header on stderr, useful together with Dbg().
 void
 dump_headers(TSMBuffer bufp, TSMLoc hdr_loc)
 {
@@ -113,7 +113,7 @@ dump_headers(TSMBuffer bufp, TSMLoc hdr_loc)
   do {
     const char *block_start = TSIOBufferBlockReadStart(block, reader, &block_avail);
     if (block_avail > 0) {
-      TSDebug(PLUGIN_NAME, "Headers are:\n%.*s", static_cast<int>(block_avail), block_start);
+      Dbg(Bg_dbg_ctl, "Headers are:\n%.*s", static_cast<int>(block_avail), block_start);
     }
     TSIOBufferReaderConsume(reader, block_avail);
     block = TSIOBufferReaderStart(reader);
diff --git a/plugins/background_fetch/rules.cc b/plugins/background_fetch/rules.cc
index ddbd2bc0e64..b8f339d6d2a 100644
--- a/plugins/background_fetch/rules.cc
+++ b/plugins/background_fetch/rules.cc
@@ -47,10 +47,10 @@ check_client_ip_configured(TSHttpTxn txnp, const char *cfg_ip)
     return false;
   }
 
-  TSDebug(PLUGIN_NAME, "cfg_ip %s, client_ip %s", cfg_ip, ip_buf);
+  Dbg(Bg_dbg_ctl, "cfg_ip %s, client_ip %s", cfg_ip, ip_buf);
 
   if ((strlen(cfg_ip) == strlen(ip_buf)) && !strcmp(cfg_ip, ip_buf)) {
-    TSDebug(PLUGIN_NAME, "bg fetch for ip %s, configured ip %s", ip_buf, cfg_ip);
+    Dbg(Bg_dbg_ctl, "bg fetch for ip %s, configured ip %s", ip_buf, cfg_ip);
     return true;
   }
 
@@ -81,11 +81,11 @@ BgFetchRule::check_field_configured(TSHttpTxn txnp) const
   // check for client-ip first
   if (!strcmp(_field, "Client-IP")) {
     if (!strcmp(_value, "*")) {
-      TSDebug(PLUGIN_NAME, "Found client_ip wild card");
+      Dbg(Bg_dbg_ctl, "Found client_ip wild card");
       return true;
     }
     if (check_client_ip_configured(txnp, _value)) {
-      TSDebug(PLUGIN_NAME, "Found client_ip match");
+      Dbg(Bg_dbg_ctl, "Found client_ip match");
       return true;
     }
   }
@@ -103,12 +103,12 @@ BgFetchRule::check_field_configured(TSHttpTxn txnp) const
         unsigned int content_len = TSMimeHdrFieldValueUintGet(hdr_bufp, hdr_loc, loc, 0 /* index */);
 
         if (check_content_length(content_len, _value)) {
-          TSDebug(PLUGIN_NAME, "Found content-length match");
+          Dbg(Bg_dbg_ctl, "Found content-length match");
           hdr_found = true;
         }
         TSHandleMLocRelease(hdr_bufp, hdr_loc, loc);
       } else {
-        TSDebug(PLUGIN_NAME, "No content-length field in resp");
+        Dbg(Bg_dbg_ctl, "No content-length field in resp");
       }
       TSHandleMLocRelease(hdr_bufp, TS_NULL_MLOC, hdr_loc);
     } else {
@@ -123,16 +123,16 @@ BgFetchRule::check_field_configured(TSHttpTxn txnp) const
 
     if (TS_NULL_MLOC != loc) {
       if (!strcmp(_value, "*")) {
-        TSDebug(PLUGIN_NAME, "Found %s wild card", _field);
+        Dbg(Bg_dbg_ctl, "Found %s wild card", _field);
         hdr_found = true;
       } else {
         int val_len         = 0;
         const char *val_str = TSMimeHdrFieldValueStringGet(hdr_bufp, hdr_loc, loc, 0, &val_len);
 
         if (!val_str || val_len <= 0) {
-          TSDebug(PLUGIN_NAME, "invalid field");
+          Dbg(Bg_dbg_ctl, "invalid field");
         } else {
-          TSDebug(PLUGIN_NAME, "comparing with %s", _value);
+          Dbg(Bg_dbg_ctl, "comparing with %s", _value);
           if (std::string_view::npos != std::string_view(val_str, val_len).find(_value)) {
             hdr_found = true;
           }
@@ -140,7 +140,7 @@ BgFetchRule::check_field_configured(TSHttpTxn txnp) const
       }
       TSHandleMLocRelease(hdr_bufp, hdr_loc, loc);
     } else {
-      TSDebug(PLUGIN_NAME, "no field %s in request header", _field);
+      Dbg(Bg_dbg_ctl, "no field %s in request header", _field);
     }
     TSHandleMLocRelease(hdr_bufp, TS_NULL_MLOC, hdr_loc);
   } else {
diff --git a/plugins/cache_promote/cache_promote.cc b/plugins/cache_promote/cache_promote.cc
index 0580fb521aa..c1a53d7945f 100644
--- a/plugins/cache_promote/cache_promote.cc
+++ b/plugins/cache_promote/cache_promote.cc
@@ -27,6 +27,7 @@
 
 const char *PLUGIN_NAME = "cache_promote";
 int TXN_ARG_IDX;
+DbgCtl cache_promote_dbg_ctl{PLUGIN_NAME};
 
 // This has to be a global here. I tried doing a classic singleton (with a getInstance()) in the PolicyManager,
 // but then reloading the DSO does not work. What happens is that the old singleton is still there, even though
@@ -59,9 +60,9 @@ cont_handle_policy(TSCont contp, TSEvent event, void *edata)
         case TS_CACHE_LOOKUP_MISS:
         case TS_CACHE_LOOKUP_SKIPPED:
           if (config->getPolicy()->doSample() && config->getPolicy()->doPromote(txnp)) {
-            TSDebug(PLUGIN_NAME, "cache-status is %d, and leaving cache on (promoted)", obj_status);
+            DBG("cache-status is %d, and leaving cache on (promoted)", obj_status);
           } else {
-            TSDebug(PLUGIN_NAME, "cache-status is %d, and turning off the cache (not promoted)", obj_status);
+            DBG("cache-status is %d, and turning off the cache (not promoted)", obj_status);
             if (config->getPolicy()->countBytes()) {
               // Need to schedule this continuation for read-response-header-hook as well.
               TSHttpTxnHookAdd(txnp, TS_HTTP_READ_RESPONSE_HDR_HOOK, contp);
@@ -74,7 +75,7 @@ cont_handle_policy(TSCont contp, TSEvent event, void *edata)
           break;
         default:
           // Do nothing, just let it handle the lookup.
-          TSDebug(PLUGIN_NAME, "cache-status is %d (hit), nothing to do", obj_status);
+          DBG("cache-status is %d (hit), nothing to do", obj_status);
 
           if (config->getPolicy()->_stats_enabled) {
             TSStatIntIncrement(config->getPolicy()->_cache_hits_id, 1);
@@ -86,7 +87,7 @@ cont_handle_policy(TSCont contp, TSEvent event, void *edata)
         TSStatIntIncrement(config->getPolicy()->_total_requests_id, 1);
       }
     } else {
-      TSDebug(PLUGIN_NAME, "request is an internal (plugin) request, implicitly promoted");
+      DBG("request is an internal (plugin) request, implicitly promoted");
     }
     break;
 
@@ -101,7 +102,7 @@ cont_handle_policy(TSCont contp, TSEvent event, void *edata)
 
   // Should not happen
   default:
-    TSDebug(PLUGIN_NAME, "unhandled event %d", static_cast<int>(event));
+    DBG("unhandled event %d", static_cast<int>(event));
     break;
   }
 
@@ -124,14 +125,14 @@ TSRemapInit(TSRemapInterface *api_info, char *errbuf, int errbuf_size)
     return TS_ERROR;
   }
 
-  TSDebug(PLUGIN_NAME, "remap plugin is successfully initialized, TXN_IDX = %d", TXN_ARG_IDX);
+  DBG("remap plugin is successfully initialized, TXN_IDX = %d", TXN_ARG_IDX);
   return TS_SUCCESS; /* success */
 }
 
 void
 TSRemapDone()
 {
-  TSDebug(PLUGIN_NAME, "called TSRemapDone()");
+  DBG("called TSRemapDone()");
   gManager.clear();
 }
 
@@ -172,11 +173,11 @@ TSRemapStatus
 TSRemapDoRemap(void *ih, TSHttpTxn rh, TSRemapRequestInfo * /* ATS_UNUSED rri */)
 {
   if (nullptr == ih) {
-    TSDebug(PLUGIN_NAME, "no promotion rules configured, this is probably a plugin bug");
+    DBG("no promotion rules configured, this is probably a plugin bug");
   } else {
     TSCont contp = static_cast<TSCont>(ih);
 
-    TSDebug(PLUGIN_NAME, "scheduling a TS_HTTP_CACHE_LOOKUP_COMPLETE_HOOK hook");
+    DBG("scheduling a TS_HTTP_CACHE_LOOKUP_COMPLETE_HOOK hook");
     TSHttpTxnHookAdd(rh, TS_HTTP_CACHE_LOOKUP_COMPLETE_HOOK, contp);
   }
 
diff --git a/plugins/cache_promote/chance_policy.h b/plugins/cache_promote/chance_policy.h
index fb74ab88fad..b38b0e01d57 100644
--- a/plugins/cache_promote/chance_policy.h
+++ b/plugins/cache_promote/chance_policy.h
@@ -29,7 +29,7 @@ class ChancePolicy : public PromotionPolicy
   bool
   doPromote(TSHttpTxn /* txnp ATS_UNUSED */) override
   {
-    TSDebug(PLUGIN_NAME, "ChancePolicy::doPromote(%f)", getSample());
+    DBG("ChancePolicy::doPromote(%f)", getSample());
     incrementStat(_promoted_id, 1);
 
     return true;
diff --git a/plugins/cache_promote/configs.cc b/plugins/cache_promote/configs.cc
index 980fcea080f..cfa901f8fa8 100644
--- a/plugins/cache_promote/configs.cc
+++ b/plugins/cache_promote/configs.cc
@@ -66,7 +66,7 @@ PromotionConfig::factory(int argc, char *argv[])
         return false;
       }
       if (_policy) {
-        TSDebug(PLUGIN_NAME, "created remap with cache promotion policy = %s", _policy->policyName());
+        DBG("created remap with cache promotion policy = %s", _policy->policyName());
       }
     } else if (opt == 'e') {
       if (optarg == nullptr) {
@@ -75,7 +75,7 @@ PromotionConfig::factory(int argc, char *argv[])
       } else {
         if (_policy && _policy->stats_add(optarg)) {
           _policy->_stats_enabled = true;
-          TSDebug(PLUGIN_NAME, "stats collection is enabled");
+          DBG("stats collection is enabled");
         }
       }
     } else {
@@ -85,7 +85,7 @@ PromotionConfig::factory(int argc, char *argv[])
           _policy->setSample(optarg);
         } else if (opt == 'i') {
           _policy->setInternalEnabled(true);
-          TSDebug(PLUGIN_NAME, "internal_enabled set to true");
+          DBG("internal_enabled set to true");
         } else {
           if (!_policy->parseOption(opt, optarg)) {
             TSError("[%s] The specified policy (%s) does not support the -%c option; skipping this argument", PLUGIN_NAME,
diff --git a/plugins/cache_promote/lru_policy.cc b/plugins/cache_promote/lru_policy.cc
index dfba26ed971..b74bd3f806f 100644
--- a/plugins/cache_promote/lru_policy.cc
+++ b/plugins/cache_promote/lru_policy.cc
@@ -55,7 +55,7 @@ LRUHash::initFromUrl(TSHttpTxn txnp)
 #else
         EVP_Digest(url, url_len, _hash, nullptr, EVP_sha1(), nullptr);
 #endif
-        TSDebug(PLUGIN_NAME, "LRUHash::initFromUrl(%.*s%s)", url_len > 100 ? 100 : url_len, url, url_len > 100 ? "..." : "");
+        DBG("LRUHash::initFromUrl(%.*s%s)", url_len > 100 ? 100 : url_len, url, url_len > 100 ? "..." : "");
         TSfree(url);
         ret = true;
       }
@@ -69,7 +69,7 @@ LRUHash::initFromUrl(TSHttpTxn txnp)
 
 LRUPolicy::~LRUPolicy()
 {
-  TSDebug(PLUGIN_NAME, "LRUPolicy DTOR");
+  DBG("LRUPolicy DTOR");
   TSMutexLock(_lock);
 
   _map.clear();
@@ -90,7 +90,7 @@ LRUPolicy::parseOption(int opt, char *optarg)
     _buckets = static_cast<unsigned>(strtol(optarg, nullptr, 10));
     if (_buckets < MINIMUM_BUCKET_SIZE) {
       TSError("%s: Enforcing minimum LRU bucket size of %d", PLUGIN_NAME, MINIMUM_BUCKET_SIZE);
-      TSDebug(PLUGIN_NAME, "enforcing minimum bucket size of %d", MINIMUM_BUCKET_SIZE);
+      DBG("enforcing minimum bucket size of %d", MINIMUM_BUCKET_SIZE);
       _buckets = MINIMUM_BUCKET_SIZE;
     }
     break;
@@ -155,7 +155,7 @@ LRUPolicy::doPromote(TSHttpTxn txnp)
           cacheable = true;
         }
       }
-      TSDebug(PLUGIN_NAME, "The request is %s", cacheable ? "cacheable" : "not cacheable");
+      DBG("The request is %s", cacheable ? "cacheable" : "not cacheable");
       TSHandleMLocRelease(request, TS_NULL_MLOC, req_hdr);
     }
 
@@ -165,7 +165,7 @@ LRUPolicy::doPromote(TSHttpTxn txnp)
     ++val_hits; // Increment hits, bytes are incremented elsewhere
     if (cacheable && (val_hits >= _hits || (_bytes > 0 && val_bytes > _bytes))) {
       // Promoted! Cleanup the LRU, and signal success. Save the promoted entry on the freelist.
-      TSDebug(PLUGIN_NAME, "saving the LRUEntry to the freelist");
+      DBG("saving the LRUEntry to the freelist");
       _freelist.splice(_freelist.begin(), _list, map_val);
       ++_freelist_size;
       --_list_size;
@@ -176,26 +176,26 @@ LRUPolicy::doPromote(TSHttpTxn txnp)
       ret = true;
     } else {
       // It's still not promoted, make sure it's moved to the front of the list
-      TSDebug(PLUGIN_NAME, "still not promoted, got %d hits so far and %" PRId64 " bytes", val_hits, val_bytes);
+      DBG("still not promoted, got %d hits so far and %" PRId64 " bytes", val_hits, val_bytes);
       _list.splice(_list.begin(), _list, map_val);
     }
   } else {
     // New LRU entry for the URL, try to repurpose the list entry as much as possible
     incrementStat(_lru_miss_id, 1);
     if (_list_size >= _buckets) {
-      TSDebug(PLUGIN_NAME, "repurposing last LRUHash entry");
+      DBG("repurposing last LRUHash entry");
       _list.splice(_list.begin(), _list, --_list.end());
       _map.erase(&(std::get<0>(*_list.begin()))); // Get the hash from the first list element
       incrementStat(_lru_vacated_id, 1);
     } else if (_freelist_size > 0) {
-      TSDebug(PLUGIN_NAME, "reusing LRUEntry from freelist");
+      DBG("reusing LRUEntry from freelist");
       _list.splice(_list.begin(), _freelist, _freelist.begin());
       --_freelist_size;
       ++_list_size;
       incrementStat(_lru_size_id, 1);
       decrementStat(_freelist_size_id, 1);
     } else {
-      TSDebug(PLUGIN_NAME, "creating new LRUEntry");
+      DBG("creating new LRUEntry");
       _list.push_front(NULL_LRU_ENTRY);
       ++_list_size;
       incrementStat(_lru_size_id, 1);
@@ -243,7 +243,7 @@ LRUPolicy::addBytes(TSHttpTxn txnp)
           (void)val_key, (void)val_hits;
 
           val_bytes += cl;
-          TSDebug(PLUGIN_NAME, "Added %" PRId64 " bytes for LRU entry", cl);
+          DBG("Added %" PRId64 " bytes for LRU entry", cl);
           TSHandleMLocRelease(resp, resp_hdr, field_loc);
         }
         TSHandleMLocRelease(resp, TS_NULL_MLOC, resp_hdr);
diff --git a/plugins/cache_promote/lru_policy.h b/plugins/cache_promote/lru_policy.h
index f2532ff4470..e33345f2675 100644
--- a/plugins/cache_promote/lru_policy.h
+++ b/plugins/cache_promote/lru_policy.h
@@ -43,19 +43,19 @@ class LRUHash
   friend struct LRUHashHasher;
 
 public:
-  LRUHash() { TSDebug(PLUGIN_NAME, "LRUHash() CTOR"); }
-  ~LRUHash() { TSDebug(PLUGIN_NAME, "~LRUHash() DTOR"); }
+  LRUHash() { DBG("LRUHash() CTOR"); }
+  ~LRUHash() { DBG("~LRUHash() DTOR"); }
 
   LRUHash(const LRUHash &h)
   {
-    TSDebug(PLUGIN_NAME, "Copy CTOR an LRUHash object");
+    DBG("Copy CTOR an LRUHash object");
     memcpy(_hash, h._hash, sizeof(_hash));
   }
 
   LRUHash &
   operator=(const LRUHash &h)
   {
-    TSDebug(PLUGIN_NAME, "copying an LRUHash object");
+    DBG("copying an LRUHash object");
     if (this != &h) {
       memcpy(_hash, h._hash, sizeof(_hash));
     }
diff --git a/plugins/cache_promote/policy.cc b/plugins/cache_promote/policy.cc
index cc5bdac215b..c9fbdb93656 100644
--- a/plugins/cache_promote/policy.cc
+++ b/plugins/cache_promote/policy.cc
@@ -26,9 +26,9 @@ PromotionPolicy::doSample() const
     double r = ts::Random::drandom();
 
     if (_sample > r) {
-      TSDebug(PLUGIN_NAME, "checking sampling, is %f > %f? Yes!", _sample, r);
+      DBG("checking sampling, is %f > %f? Yes!", _sample, r);
     } else {
-      TSDebug(PLUGIN_NAME, "checking sampling, is %f > %f? No!", _sample, r);
+      DBG("checking sampling, is %f > %f? No!", _sample, r);
       return false;
     }
   }
@@ -48,9 +48,9 @@ PromotionPolicy::create_stat(std::string_view name, std::string_view remap_ident
   if (TS_ERROR == TSStatFindName(stat_name.data(), &stat_id)) {
     stat_id = TSStatCreate(stat_name.data(), TS_RECORDDATATYPE_INT, TS_STAT_NON_PERSISTENT, TS_STAT_SYNC_SUM);
     if (TS_ERROR == stat_id) {
-      TSDebug(PLUGIN_NAME, "error creating stat_name: %s", stat_name.data());
+      DBG("error creating stat_name: %s", stat_name.data());
     } else {
-      TSDebug(PLUGIN_NAME, "created stat_name: %s, stat_id: %d", stat_name.data(), stat_id);
+      DBG("created stat_name: %s, stat_id: %d", stat_name.data(), stat_id);
     }
   }
 
diff --git a/plugins/cache_promote/policy.h b/plugins/cache_promote/policy.h
index e6c468b5bd3..c9f6d2aa8a1 100644
--- a/plugins/cache_promote/policy.h
+++ b/plugins/cache_promote/policy.h
@@ -28,6 +28,10 @@ extern int TXN_ARG_IDX;
 #define MAX_STAT_LENGTH (1 << 8)
 extern const char *PLUGIN_NAME;
 
+extern DbgCtl cache_promote_dbg_ctl;
+
+#define DBG(...) Dbg(cache_promote_dbg_ctl, __VA_ARGS__)
+
 //////////////////////////////////////////////////////////////////////////////////////////////
 // Abstract base class for all policies.
 //
@@ -38,7 +42,7 @@ class PromotionPolicy
   {
     // This doesn't have to be perfect, since this is just chance sampling.
     // coverity[dont_call]
-    TSDebug(PLUGIN_NAME, "PromotionPolicy() CTOR");
+    DBG("PromotionPolicy() CTOR");
     srand48(static_cast<long>(time(nullptr)));
   }
 
diff --git a/plugins/cache_promote/policy_manager.cc b/plugins/cache_promote/policy_manager.cc
index 2b30adb2c99..2476144ee47 100644
--- a/plugins/cache_promote/policy_manager.cc
+++ b/plugins/cache_promote/policy_manager.cc
@@ -25,17 +25,17 @@ PolicyManager::coalescePolicy(PromotionPolicy *policy)
   if (tag.size() != 0) {
     auto res = _policies.find(tag);
 
-    TSDebug(PLUGIN_NAME, "looking up policy by tag: %s", tag.c_str());
+    DBG("looking up policy by tag: %s", tag.c_str());
 
     if (res != _policies.end()) {
-      TSDebug(PLUGIN_NAME, "repurposing policy for tag: %s", tag.c_str());
+      DBG("repurposing policy for tag: %s", tag.c_str());
 
       ++res->second.second;
       // Repurpose the existing policy, nuking this placeholder.
       delete policy;
       return res->second.first;
     } else {
-      TSDebug(PLUGIN_NAME, "inserting policy for tag: %s", tag.c_str());
+      DBG("inserting policy for tag: %s", tag.c_str());
       _policies[tag] = std::make_pair(policy, 1);
     }
   }
@@ -53,14 +53,14 @@ PolicyManager::releasePolicy(PromotionPolicy *policy)
 
     if (res != _policies.end()) {
       if (0 == --res->second.second) {
-        TSDebug(PLUGIN_NAME, "releasing unused PromotionPolicy");
+        DBG("releasing unused PromotionPolicy");
         delete res->second.first;
         _policies.erase(res);
       }
 
       return;
     } else {
-      TSDebug(PLUGIN_NAME, "Tried to release a policy which was not properly initialized nor acquired via PolicyManager");
+      DBG("Tried to release a policy which was not properly initialized nor acquired via PolicyManager");
     }
   }
 
diff --git a/plugins/cache_promote/policy_manager.h b/plugins/cache_promote/policy_manager.h
index bd4d9574505..cc635c371f6 100644
--- a/plugins/cache_promote/policy_manager.h
+++ b/plugins/cache_promote/policy_manager.h
@@ -25,8 +25,8 @@
 class PolicyManager
 {
 public:
-  PolicyManager() { TSDebug(PLUGIN_NAME, "PolicyManager() CTOR"); }
-  virtual ~PolicyManager() { TSDebug(PLUGIN_NAME, "~PolicyManger() DTOR"); }
+  PolicyManager() { DBG("PolicyManager() CTOR"); }
+  virtual ~PolicyManager() { DBG("~PolicyManger() DTOR"); }
 
   // This is sort of a no-op right now, but it should be called regardless.
   void
diff --git a/plugins/cache_range_requests/cache_range_requests.cc b/plugins/cache_range_requests/cache_range_requests.cc
index 73bdb586b78..a5e2883ab3d 100644
--- a/plugins/cache_range_requests/cache_range_requests.cc
+++ b/plugins/cache_range_requests/cache_range_requests.cc
@@ -38,11 +38,13 @@
 #include <string_view>
 
 #define PLUGIN_NAME         "cache_range_requests"
-#define DEBUG_LOG(fmt, ...) TSDebug(PLUGIN_NAME, "[%s:%d] %s(): " fmt, __FILE__, __LINE__, __func__, ##__VA_ARGS__)
+#define DEBUG_LOG(fmt, ...) Dbg(dbg_ctl, "[%s:%d] %s(): " fmt, __FILE__, __LINE__, __func__, ##__VA_ARGS__)
 #define ERROR_LOG(fmt, ...) TSError("[%s:%d] %s(): " fmt, __FILE__, __LINE__, __func__, ##__VA_ARGS__)
 
 namespace
 {
+DbgCtl dbg_ctl{PLUGIN_NAME};
+
 using parent_select_mode_t = enum parent_select_mode {
   PS_DEFAULT,      // Default ATS parent selection mode
   PS_CACHEKEY_URL, // Set parent selection url to cache_key url
@@ -570,7 +572,7 @@ handle_cache_lookup_complete(TSHttpTxn txnp, txndata *const txn_state)
                 static_cast<intmax_t>(txn_state->ims_time));
       if (ch_time < txn_state->ims_time) {
         TSHttpTxnCacheLookupStatusSet(txnp, TS_CACHE_LOOKUP_HIT_STALE);
-        if (TSIsDebugTagSet(PLUGIN_NAME)) {
+        if (dbg_ctl.on()) {
           int url_len         = 0;
           char *const req_url = TSHttpTxnEffectiveUrlStringGet(txnp, &url_len);
           if (nullptr != req_url) {
diff --git a/plugins/cachekey/common.cc b/plugins/cachekey/common.cc
index 87397c86000..de9fb1c48e5 100644
--- a/plugins/cachekey/common.cc
+++ b/plugins/cachekey/common.cc
@@ -35,4 +35,8 @@ PrintToStdErr(const char *fmt, ...)
   va_end(args);
 }
 
+#else
+
+DbgCtl CacheKey_dbg_ctl{PLUGIN_NAME};
+
 #endif /* CACHEKEY_UNIT_TEST */
diff --git a/plugins/cachekey/common.h b/plugins/cachekey/common.h
index eb98bdc2a30..7ac55c647df 100644
--- a/plugins/cachekey/common.h
+++ b/plugins/cachekey/common.h
@@ -48,14 +48,16 @@ void PrintToStdErr(const char *fmt, ...);
 #else /* CACHEKEY_UNIT_TEST */
 #include "ts/ts.h"
 
-#define CacheKeyDebug(fmt, ...)                                                           \
-  do {                                                                                    \
-    TSDebug(PLUGIN_NAME, "%s:%d:%s() " fmt, __FILE__, __LINE__, __func__, ##__VA_ARGS__); \
+extern DbgCtl CacheKey_dbg_ctl;
+
+#define CacheKeyDebug(fmt, ...)                                                            \
+  do {                                                                                     \
+    Dbg(CacheKey_dbg_ctl, "%s:%d:%s() " fmt, __FILE__, __LINE__, __func__, ##__VA_ARGS__); \
   } while (0)
 
-#define CacheKeyError(fmt, ...)                                                           \
-  do {                                                                                    \
-    TSError("(%s) " fmt, PLUGIN_NAME, ##__VA_ARGS__);                                     \
-    TSDebug(PLUGIN_NAME, "%s:%d:%s() " fmt, __FILE__, __LINE__, __func__, ##__VA_ARGS__); \
+#define CacheKeyError(fmt, ...)                                                            \
+  do {                                                                                     \
+    TSError("(%s) " fmt, PLUGIN_NAME, ##__VA_ARGS__);                                      \
+    Dbg(CacheKey_dbg_ctl, "%s:%d:%s() " fmt, __FILE__, __LINE__, __func__, ##__VA_ARGS__); \
   } while (0)
 #endif /* CACHEKEY_UNIT_TEST */
diff --git a/plugins/certifier/certifier.cc b/plugins/certifier/certifier.cc
index f73bcb6f39d..60e4b0f3994 100644
--- a/plugins/certifier/certifier.cc
+++ b/plugins/certifier/certifier.cc
@@ -45,8 +45,13 @@
 
 #include "ts/ts.h"
 
+namespace
+{
 const char *PLUGIN_NAME = "certifier";
 
+DbgCtl dbg_ctl{PLUGIN_NAME};
+} // namespace
+
 /// Override default delete for unique ptrs to openSSL objects
 namespace std
 {
@@ -103,7 +108,7 @@ class SslLRUList
 
     SslData() = default;
     ~SslData()
-    { /* TSDebug(PLUGIN_NAME, "Deleting ssl data for [%s]", commonName.c_str()); */
+    { /* Dbg(dbg_ctl, "Deleting ssl data for [%s]", commonName.c_str()); */
     }
   };
 
@@ -211,7 +216,7 @@ class SslLRUList
 
         // Remove oldest node if size exceeds limit
         if (++size > limit) {
-          TSDebug(PLUGIN_NAME, "%s: removing '%s'", __func__, tail->commonName.c_str());
+          Dbg(dbg_ctl, "%s: removing '%s'", __func__, tail->commonName.c_str());
           auto iter = cnDataMap.find(tail->commonName);
           if (iter != cnDataMap.end()) {
             local = std::move(iter->second); // copy ownership
@@ -224,8 +229,8 @@ class SslLRUList
         }
       }
     }
-    TSDebug(PLUGIN_NAME, "%s: prepending '%s' to LRU ... list size: %d, map size: %d", __func__, data->commonName.c_str(), size,
-            static_cast<int>(cnDataMap.size()));
+    Dbg(dbg_ctl, "%s: prepending '%s' to LRU ... list size: %d, map size: %d", __func__, data->commonName.c_str(), size,
+        static_cast<int>(cnDataMap.size()));
 
     TSMutexUnlock(list_mutex);
   }
@@ -328,7 +333,7 @@ static std::string store_path;
 static void
 addSANExtToCert(X509 *cert, std::string_view dnsName)
 {
-  TSDebug(PLUGIN_NAME, "Adding SAN extension to the cert");
+  Dbg(dbg_ctl, "Adding SAN extension to the cert");
   GENERAL_NAMES *generalNames = sk_GENERAL_NAME_new_null();
   GENERAL_NAME *generalName   = GENERAL_NAME_new();
   ASN1_IA5STRING *ia5         = ASN1_IA5STRING_new();
@@ -356,7 +361,6 @@ mkcrt(const std::string &commonName, int serial)
   }
 
   // Set serial number
-  // TSDebug("txn_monitor", "serial: %d", serial);
   ASN1_INTEGER_set(X509_get_serialNumber(cert.get()), serial);
 
   // Set issuer from CA cert
@@ -421,7 +425,7 @@ shadow_cert_generator(TSCont contp, TSEvent event, void *edata)
     /// Try open the file if directory exists
     fp = fopen(cert_filename.c_str(), "rt");
   }
-  TSDebug(PLUGIN_NAME, "%s: cert file is expected at %s", __func__, cert_filename.c_str());
+  Dbg(dbg_ctl, "%s: cert file is expected at %s", __func__, cert_filename.c_str());
   /// If cert file exists and is readable
   if (fp != nullptr) {
     cert.reset(PEM_read_X509(fp, nullptr, nullptr, nullptr));
@@ -431,19 +435,19 @@ shadow_cert_generator(TSCont contp, TSEvent event, void *edata)
       /// Problem with cert file / openssl read
       TSError("[%s] %s: failed o load certificate from '%s'", PLUGIN_NAME, __func__, cert_filename.c_str());
     } else {
-      TSDebug(PLUGIN_NAME, "%s: loaded certificate from '%s'", __func__, cert_filename.c_str());
+      Dbg(dbg_ctl, "%s: loaded certificate from '%s'", __func__, cert_filename.c_str());
     }
   }
 
   /// No valid certs available from disk, create one and write to file
   if (cert == nullptr) {
     if (!sign_enabled) {
-      TSDebug(PLUGIN_NAME, "%s: no certs found and dynamic generation disabled; marked as wontdo", __func__);
+      Dbg(dbg_ctl, "%s: no certs found and dynamic generation disabled; marked as wontdo", __func__);
       // There won't be certs available. Mark this servername as wontdo
       // Pass on as if plugin doesn't exist
       ssl_list->setup_data_ctx(commonName, localQ, nullptr, nullptr, true);
       while (!localQ.empty()) {
-        // TSDebug(PLUGIN_NAME, "\tClearing the queue size %lu", localQ.size());
+        // Dbg(dbg_ctl, "\tClearing the queue size %lu", localQ.size());
         TSVConn ssl_vc = reinterpret_cast<TSVConn>(localQ.front());
         localQ.pop();
         TSVConnReenable(ssl_vc);
@@ -451,7 +455,7 @@ shadow_cert_generator(TSCont contp, TSEvent event, void *edata)
       TSContDestroy(contp);
       return TS_SUCCESS;
     }
-    TSDebug(PLUGIN_NAME, "%s: creating shadow certs", __func__);
+    Dbg(dbg_ctl, "%s: creating shadow certs", __func__);
 
     /// Get serial number
     TSMutexLock(serial_mutex);
@@ -468,7 +472,7 @@ shadow_cert_generator(TSCont contp, TSEvent event, void *edata)
     /// Create cert
     cert = mkcrt(commonName, serial);
     if (cert == nullptr) {
-      TSDebug(PLUGIN_NAME, "%s: cert generation failed", __func__);
+      Dbg(dbg_ctl, "%s: cert generation failed", __func__);
       TSContDestroy(contp);
       ssl_list->set_schedule(commonName, false);
       return TS_ERROR;
@@ -476,10 +480,10 @@ shadow_cert_generator(TSCont contp, TSEvent event, void *edata)
 
     /// Write certs to file
     if ((fp = fopen(cert_filename.c_str(), "w+")) == nullptr) {
-      TSDebug(PLUGIN_NAME, "%s: error opening file: %s", __func__, strerror(errno));
+      Dbg(dbg_ctl, "%s: error opening file: %s", __func__, strerror(errno));
     } else {
       if (!PEM_write_X509(fp, cert.get())) {
-        TSDebug(PLUGIN_NAME, "%s: error writing cert to disk", __func__);
+        Dbg(dbg_ctl, "%s: error writing cert to disk", __func__);
       }
       fclose(fp);
     }
@@ -501,12 +505,12 @@ shadow_cert_generator(TSCont contp, TSEvent event, void *edata)
     ssl_list->set_schedule(commonName, false);
     return TS_ERROR;
   }
-  TSDebug(PLUGIN_NAME, "%s: cert and context ready, clearing the queue", __func__);
+  Dbg(dbg_ctl, "%s: cert and context ready, clearing the queue", __func__);
   ssl_list->setup_data_ctx(commonName, localQ, std::move(ctx), std::move(cert), false);
 
   /// Clear the queue by setting context for each and reenable them
   while (!localQ.empty()) {
-    TSDebug(PLUGIN_NAME, "%s: clearing the queue size %lu", __func__, localQ.size());
+    Dbg(dbg_ctl, "%s: clearing the queue size %lu", __func__, localQ.size());
     TSVConn ssl_vc = reinterpret_cast<TSVConn>(localQ.front());
     localQ.pop();
     TSSslConnection sslobj = TSVConnSslConnectionGet(ssl_vc);
@@ -538,21 +542,21 @@ cert_retriever(TSCont contp, TSEvent event, void *edata)
   ref_ctx     = ssl_list->lookup_and_create(servername, edata, wontdo);
 
   if (wontdo) {
-    TSDebug(PLUGIN_NAME, "%s: won't generate cert for %s", __func__, servername);
+    Dbg(dbg_ctl, "%s: won't generate cert for %s", __func__, servername);
     TSVConnReenable(ssl_vc);
     return TS_SUCCESS;
   }
 
   if (ref_ctx) {
     // Use existing context.
-    TSDebug(PLUGIN_NAME, "%s: reusing existing cert and context for %s", __func__, servername);
+    Dbg(dbg_ctl, "%s: reusing existing cert and context for %s", __func__, servername);
     SSL_set_SSL_CTX(ssl, ref_ctx);
     TSVConnReenable(ssl_vc);
     return TS_SUCCESS;
   }
 
   // If no existing context, schedule TASK thread to generate.
-  TSDebug(PLUGIN_NAME, "%s: scheduling thread to generate/retrieve cert for %s", __func__, servername);
+  Dbg(dbg_ctl, "%s: scheduling thread to generate/retrieve cert for %s", __func__, servername);
   TSCont schedule_cont = TSContCreate(shadow_cert_generator, TSMutexCreate());
   TSContDataSet(schedule_cont, const_cast<char *>(servername));
   TSContScheduleOnPool(schedule_cont, 0, TS_THREAD_POOL_TASK);
@@ -563,7 +567,7 @@ cert_retriever(TSCont contp, TSEvent event, void *edata)
 void
 TSPluginInit(int argc, const char *argv[])
 {
-  TSDebug(PLUGIN_NAME, "initializing plugin");
+  Dbg(dbg_ctl, "initializing plugin");
   // Initialization data and callback
   TSPluginRegistrationInfo info;
   TSCont cb_shadow   = nullptr;
@@ -613,7 +617,7 @@ TSPluginInit(int argc, const char *argv[])
     case '?':
       break;
     default:
-      TSDebug(PLUGIN_NAME, "unexpected options");
+      Dbg(dbg_ctl, "unexpected options");
       TSError("[%s] unexpected options error", PLUGIN_NAME);
       return;
     }
@@ -637,7 +641,7 @@ TSPluginInit(int argc, const char *argv[])
     // To comply to openssl, key and cert file are opened as FILE*
     FILE *fp = nullptr;
     if ((fp = fopen(cert, "r")) == nullptr) {
-      TSDebug(PLUGIN_NAME, "fopen() error is %d: %s for %s", errno, strerror(errno), cert);
+      Dbg(dbg_ctl, "fopen() error is %d: %s for %s", errno, strerror(errno), cert);
       TSError("[%s] unable to initialize plugin: failed to open CA certificate '%s'", PLUGIN_NAME, cert);
       return;
     }
@@ -645,7 +649,7 @@ TSPluginInit(int argc, const char *argv[])
     fclose(fp);
 
     if ((fp = fopen(key, "r")) == nullptr) {
-      TSDebug(PLUGIN_NAME, "fopen() error is %d: %s for %s", errno, strerror(errno), key);
+      Dbg(dbg_ctl, "fopen() error is %d: %s for %s", errno, strerror(errno), key);
       TSError("[%s] unable to initialize plugin: failed to open CA key '%s'", PLUGIN_NAME, key);
       return;
     }
@@ -653,7 +657,7 @@ TSPluginInit(int argc, const char *argv[])
     fclose(fp);
 
     if (ca_pkey_scoped == nullptr || ca_cert_scoped == nullptr) {
-      TSDebug(PLUGIN_NAME, "PEM_read failed to read %s %s", ca_pkey_scoped ? "" : "pkey", ca_cert_scoped ? "" : "cert");
+      Dbg(dbg_ctl, "PEM_read failed to read %s %s", ca_pkey_scoped ? "" : "pkey", ca_cert_scoped ? "" : "cert");
       TSError("[%s] unable to initialize plugin: failed to parse ca key or certificate", PLUGIN_NAME);
       return;
     }
@@ -661,7 +665,7 @@ TSPluginInit(int argc, const char *argv[])
     // Read serial file
     serial_file.open(serial, std::fstream::in | std::fstream::out);
     if (!serial_file.is_open()) {
-      TSDebug(PLUGIN_NAME, "failed to open serial file '%s'", serial);
+      Dbg(dbg_ctl, "failed to open serial file '%s'", serial);
       TSError("[%s] unable to initialize plugin: failed to open serial file '%s'", PLUGIN_NAME, serial);
       return;
     }
@@ -676,7 +680,7 @@ TSPluginInit(int argc, const char *argv[])
     }
   }
 
-  TSDebug(PLUGIN_NAME, "dynamic certificate generation %s", sign_enabled ? "enabled" : "disabled");
+  Dbg(dbg_ctl, "dynamic certificate generation %s", sign_enabled ? "enabled" : "disabled");
 
   /// Add global hooks
   TSHttpHookAdd(TS_SSL_CERT_HOOK, cb_shadow);
diff --git a/plugins/compress/compress.cc b/plugins/compress/compress.cc
index a393fbf1973..b0e0c7a474e 100644
--- a/plugins/compress/compress.cc
+++ b/plugins/compress/compress.cc
@@ -54,6 +54,11 @@ using namespace Gzip;
 // and '9' is 'Best compression'. Testing has proved level '6'
 // to be about the best level to use in an HTTP Server.
 
+namespace compress_ns
+{
+DbgCtl dbg_ctl{TAG};
+}
+
 const int ZLIB_COMPRESSION_LEVEL = 6;
 const char *dictionary           = nullptr;
 
diff --git a/plugins/compress/debug_macros.h b/plugins/compress/debug_macros.h
index 040e2d33a58..ce42573ffe5 100644
--- a/plugins/compress/debug_macros.h
+++ b/plugins/compress/debug_macros.h
@@ -27,30 +27,35 @@
 
 #define TAG "compress"
 
-#define debug(fmt, args...)                                                             \
-  do {                                                                                  \
-    TSDebug(TAG, "DEBUG: [%s:%d] [%s] " fmt, __FILE__, __LINE__, __FUNCTION__, ##args); \
+namespace compress_ns
+{
+extern DbgCtl dbg_ctl;
+}
+
+#define debug(fmt, args...)                                                                          \
+  do {                                                                                               \
+    Dbg(compress_ns::dbg_ctl, "DEBUG: [%s:%d] [%s] " fmt, __FILE__, __LINE__, __FUNCTION__, ##args); \
   } while (0)
 
-#define info(fmt, args...)              \
-  do {                                  \
-    TSDebug(TAG, "INFO: " fmt, ##args); \
+#define info(fmt, args...)                           \
+  do {                                               \
+    Dbg(compress_ns::dbg_ctl, "INFO: " fmt, ##args); \
   } while (0)
 
-#define warning(fmt, args...)              \
-  do {                                     \
-    TSDebug(TAG, "WARNING: " fmt, ##args); \
+#define warning(fmt, args...)                           \
+  do {                                                  \
+    Dbg(compress_ns::dbg_ctl, "WARNING: " fmt, ##args); \
   } while (0)
 
-#define error(fmt, args...)                                                             \
-  do {                                                                                  \
-    TSError("[%s:%d] [%s] ERROR: " fmt, __FILE__, __LINE__, __FUNCTION__, ##args);      \
-    TSDebug(TAG, "[%s:%d] [%s] ERROR: " fmt, __FILE__, __LINE__, __FUNCTION__, ##args); \
+#define error(fmt, args...)                                                                          \
+  do {                                                                                               \
+    TSError("[%s:%d] [%s] ERROR: " fmt, __FILE__, __LINE__, __FUNCTION__, ##args);                   \
+    Dbg(compress_ns::dbg_ctl, "[%s:%d] [%s] ERROR: " fmt, __FILE__, __LINE__, __FUNCTION__, ##args); \
   } while (0)
 
-#define fatal(fmt, args...)                                                             \
-  do {                                                                                  \
-    TSError("[%s:%d] [%s] ERROR: " fmt, __FILE__, __LINE__, __FUNCTION__, ##args);      \
-    TSDebug(TAG, "[%s:%d] [%s] ERROR: " fmt, __FILE__, __LINE__, __FUNCTION__, ##args); \
-    exit(-1);                                                                           \
+#define fatal(fmt, args...)                                                                          \
+  do {                                                                                               \
+    TSError("[%s:%d] [%s] ERROR: " fmt, __FILE__, __LINE__, __FUNCTION__, ##args);                   \
+    Dbg(compress_ns::dbg_ctl, "[%s:%d] [%s] ERROR: " fmt, __FILE__, __LINE__, __FUNCTION__, ##args); \
+    exit(-1);                                                                                        \
   } while (0)
diff --git a/plugins/conf_remap/conf_remap.cc b/plugins/conf_remap/conf_remap.cc
index 74a3983fd37..ad13a627d7c 100644
--- a/plugins/conf_remap/conf_remap.cc
+++ b/plugins/conf_remap/conf_remap.cc
@@ -28,7 +28,12 @@
 #include <cstdlib>
 #include <string>
 
-static const char PLUGIN_NAME[] = "conf_remap";
+namespace
+{
+const char PLUGIN_NAME[] = "conf_remap";
+
+DbgCtl dbg_ctl{PLUGIN_NAME};
+} // namespace
 
 // This makes the plugin depend on the version of traffic server installed, but that's
 // OK, since this plugin is distributed only with the "core" (it's a core piece).
@@ -164,7 +169,7 @@ scalar_node_handler(const TSYAMLRecCfgFieldData *cfg, void *data)
   RemapConfigs::Item *item = &ctx.items[*ctx.current];
 
   auto type = try_deduce_type(value);
-  TSDebug(PLUGIN_NAME, "### deduced type %d for %s", type, cfg->record_name);
+  Dbg(dbg_ctl, "### deduced type %d for %s", type, cfg->record_name);
   // If we detected a type but it's different from the one registered with the in ATS, then we ignore it.
   if (type != TS_RECORDDATATYPE_NULL && expected_type != type) {
     TSError("%s", swoc::bwprint(text, "[{}] '{}' variable type mismatch, expected {}, got {}", PLUGIN_NAME, cfg->record_name,
@@ -233,7 +238,7 @@ RemapConfigs::parse_file(const char *filename)
     path += filename;
   }
 
-  TSDebug(PLUGIN_NAME, "loading configuration file %s", path.c_str());
+  Dbg(dbg_ctl, "loading configuration file %s", path.c_str());
 
   YAML::Node root;
   try {
@@ -273,7 +278,7 @@ TSRemapInit(TSRemapInterface *api_info, char *errbuf, int errbuf_size)
     return TS_ERROR;
   }
 
-  TSDebug(PLUGIN_NAME, "remap plugin is successfully initialized");
+  Dbg(dbg_ctl, "remap plugin is successfully initialized");
   return TS_SUCCESS; /* success */
 }
 
@@ -335,15 +340,15 @@ TSRemapDoRemap(void *ih, TSHttpTxn rh, TSRemapRequestInfo * /* rri ATS_UNUSED */
       switch (conf->_items[ix]._type) {
       case TS_RECORDDATATYPE_INT:
         TSHttpTxnConfigIntSet(txnp, conf->_items[ix]._name, conf->_items[ix]._data.rec_int);
-        TSDebug(PLUGIN_NAME, "Setting config id %d to %" PRId64 "", conf->_items[ix]._name, conf->_items[ix]._data.rec_int);
+        Dbg(dbg_ctl, "Setting config id %d to %" PRId64 "", conf->_items[ix]._name, conf->_items[ix]._data.rec_int);
         break;
       case TS_RECORDDATATYPE_STRING:
         TSHttpTxnConfigStringSet(txnp, conf->_items[ix]._name, conf->_items[ix]._data.rec_string, conf->_items[ix]._data_len);
-        TSDebug(PLUGIN_NAME, "Setting config id %d to %s", conf->_items[ix]._name, conf->_items[ix]._data.rec_string);
+        Dbg(dbg_ctl, "Setting config id %d to %s", conf->_items[ix]._name, conf->_items[ix]._data.rec_string);
         break;
       case TS_RECORDDATATYPE_FLOAT:
         TSHttpTxnConfigFloatSet(txnp, conf->_items[ix]._name, conf->_items[ix]._data.rec_int);
-        TSDebug(PLUGIN_NAME, "Setting config id %d to %f", conf->_items[ix]._name, conf->_items[ix]._data.rec_float);
+        Dbg(dbg_ctl, "Setting config id %d to %f", conf->_items[ix]._name, conf->_items[ix]._data.rec_float);
         break;
       default:
         break; // Error ?
diff --git a/plugins/escalate/escalate.cc b/plugins/escalate/escalate.cc
index 903bca54c48..f0888b82c30 100644
--- a/plugins/escalate/escalate.cc
+++ b/plugins/escalate/escalate.cc
@@ -31,7 +31,11 @@
 #include <map>
 
 // Constants and some declarations
+
 const char PLUGIN_NAME[] = "escalate";
+
+static DbgCtl dbg_ctl{PLUGIN_NAME};
+
 static int EscalateResponse(TSCont, TSEvent, void *);
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -53,6 +57,7 @@ struct EscalationState {
   EscalationState()
   {
     cont = TSContCreate(EscalateResponse, nullptr);
+
     TSContDataSet(cont, this);
   }
 
@@ -72,7 +77,7 @@ MakeEscalateUrl(TSMBuffer mbuf, TSMLoc url, const char *host, size_t host_len, i
   // Update the request URL with the new Host to try.
   TSUrlHostSet(mbuf, url, host, host_len);
   url_str = TSUrlStringGet(mbuf, url, &url_len);
-  TSDebug(PLUGIN_NAME, "Setting new URL to %.*s", url_len, url_str);
+  Dbg(dbg_ctl, "Setting new URL to %.*s", url_len, url_str);
 
   return url_str;
 }
@@ -103,7 +108,7 @@ EscalateResponse(TSCont cont, TSEvent event, void *edata)
   if (0 != tries) { // ToDo: Future support for more than one retry-URL
     goto no_action;
   }
-  TSDebug(PLUGIN_NAME, "This is try %d, proceeding", tries);
+  Dbg(dbg_ctl, "This is try %d, proceeding", tries);
 
   // Next, the response status ...
   status = TSHttpHdrStatusGet(mbuf, hdrp);
@@ -115,11 +120,11 @@ EscalateResponse(TSCont cont, TSEvent event, void *edata)
     goto no_action;
   }
 
-  TSDebug(PLUGIN_NAME, "Found an entry for HTTP status %u", static_cast<unsigned>(status));
+  Dbg(dbg_ctl, "Found an entry for HTTP status %u", static_cast<unsigned>(status));
   if (EscalationState::RETRY_URL == entry->second.type) {
     url_str = TSstrdup(entry->second.target.c_str());
     url_len = entry->second.target.size();
-    TSDebug(PLUGIN_NAME, "Setting new URL to %.*s", url_len, url_str);
+    Dbg(dbg_ctl, "Setting new URL to %.*s", url_len, url_str);
   } else if (EscalationState::RETRY_HOST == entry->second.type) {
     if (es->use_pristine) {
       if (TS_SUCCESS == TSHttpTxnPristineUrlGet(txn, &mbuf, &url)) {
@@ -184,10 +189,10 @@ TSRemapNewInstance(int argc, char *argv[], void **instance, char *errbuf, int er
       info.target = sep;
       if (std::string::npos != info.target.find('/')) {
         info.type = EscalationState::RETRY_URL;
-        TSDebug(PLUGIN_NAME, "Creating Redirect rule with URL = %s", sep);
+        Dbg(dbg_ctl, "Creating Redirect rule with URL = %s", sep);
       } else {
         info.type = EscalationState::RETRY_HOST;
-        TSDebug(PLUGIN_NAME, "Creating Redirect rule with Host = %s", sep);
+        Dbg(dbg_ctl, "Creating Redirect rule with Host = %s", sep);
       }
 
       for (token = strtok_r(argv[i], ",", &save); token; token = strtok_r(nullptr, ",", &save)) {
@@ -198,7 +203,7 @@ TSRemapNewInstance(int argc, char *argv[], void **instance, char *errbuf, int er
           goto fail;
         }
 
-        TSDebug(PLUGIN_NAME, "      added status = %d to rule", status);
+        Dbg(dbg_ctl, "      added status = %d to rule", status);
         es->status_map[status] = info;
       }
     }
diff --git a/plugins/esi/combo_handler.cc b/plugins/esi/combo_handler.cc
index 597e5cbe19c..9b0009a6831 100644
--- a/plugins/esi/combo_handler.cc
+++ b/plugins/esi/combo_handler.cc
@@ -48,6 +48,8 @@ using namespace swoc::literals;
 
 #define DEBUG_TAG "combo_handler"
 
+static DbgCtl dbg_ctl{DEBUG_TAG};
+
 // Because STL vs. C library leads to ugly casting, fix it once.
 inline int
 length(std::string const &str)
@@ -70,15 +72,15 @@ static vector<string> HEADER_ALLOWLIST;
 #define DEFAULT_COMBO_HANDLER_PATH "admin/v1/combo"
 static string COMBO_HANDLER_PATH{DEFAULT_COMBO_HANDLER_PATH};
 
-#define LOG_ERROR(fmt, args...)                                                               \
-  do {                                                                                        \
-    TSError("[%s:%d] [%s] ERROR: " fmt, __FILE__, __LINE__, __FUNCTION__, ##args);            \
-    TSDebug(DEBUG_TAG, "[%s:%d] [%s] ERROR: " fmt, __FILE__, __LINE__, __FUNCTION__, ##args); \
+#define LOG_ERROR(fmt, args...)                                                         \
+  do {                                                                                  \
+    TSError("[%s:%d] [%s] ERROR: " fmt, __FILE__, __LINE__, __FUNCTION__, ##args);      \
+    Dbg(dbg_ctl, "[%s:%d] [%s] ERROR: " fmt, __FILE__, __LINE__, __FUNCTION__, ##args); \
   } while (0)
 
-#define LOG_DEBUG(fmt, args...)                                                               \
-  do {                                                                                        \
-    TSDebug(DEBUG_TAG, "[%s:%d] [%s] DEBUG: " fmt, __FILE__, __LINE__, __FUNCTION__, ##args); \
+#define LOG_DEBUG(fmt, args...)                                                         \
+  do {                                                                                  \
+    Dbg(dbg_ctl, "[%s:%d] [%s] DEBUG: " fmt, __FILE__, __LINE__, __FUNCTION__, ##args); \
   } while (0)
 
 using StringList = list<string>;
@@ -372,7 +374,7 @@ TSPluginInit(int argc, const char *argv[])
           TSError("[%s] %s must be a positive number", DEBUG_TAG, longopts[longindex].name);
         } else {
           MaxFileCount = n;
-          TSDebug(DEBUG_TAG, "Max files set to %u", MaxFileCount);
+          Dbg(dbg_ctl, "Max files set to %u", MaxFileCount);
         }
         break;
       }
@@ -445,7 +447,6 @@ TSPluginInit(int argc, const char *argv[])
     LOG_DEBUG("txn_arg_idx: %d", arg_idx);
   }
 
-  Utils::init(&TSDebug, &TSError);
   LOG_DEBUG("Plugin started");
 }
 
@@ -1243,7 +1244,7 @@ TSRemapInit(TSRemapInterface *api_info, char *errbuf, int errbuf_size)
     LOG_DEBUG("txn_arg_idx: %d", arg_idx);
   }
 
-  TSDebug(DEBUG_TAG, "%s plugin's remap part is initialized", DEBUG_TAG);
+  Dbg(dbg_ctl, "%s plugin's remap part is initialized", DEBUG_TAG);
 
   return TS_SUCCESS;
 }
@@ -1253,7 +1254,7 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char *errbuf, int errbuf_s
 {
   *ih = nullptr;
 
-  TSDebug(DEBUG_TAG, "%s Remap Instance for '%s' created", DEBUG_TAG, argv[0]);
+  Dbg(dbg_ctl, "%s Remap Instance for '%s' created", DEBUG_TAG, argv[0]);
   return TS_SUCCESS;
 }
 
diff --git a/plugins/esi/common/ComponentBase.h b/plugins/esi/common/ComponentBase.h
deleted file mode 100644
index 8304561bc6d..00000000000
--- a/plugins/esi/common/ComponentBase.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/** @file
-
-  A brief file description
-
-  @section license License
-
-  Licensed to the Apache Software Foundation (ASF) under one
-  or more contributor license agreements.  See the NOTICE file
-  distributed with this work for additional information
-  regarding copyright ownership.  The ASF licenses this file
-  to you under the Apache License, Version 2.0 (the
-  "License"); you may not use this file except in compliance
-  with the License.  You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
- */
-
-#pragma once
-
-#include <cstdio>
-#include <string>
-
-namespace EsiLib
-{
-#define DEBUG_TAG_MAX_SIZE 64
-
-/** class that has common private characteristics */
-class ComponentBase
-{
-public:
-  using Debug = void (*)(const char *, const char *, ...);
-  using Error = void (*)(const char *, ...);
-
-protected:
-  ComponentBase(const char *debug_tag, Debug debug_func, Error error_func) : _debugLog(debug_func), _errorLog(error_func)
-  {
-    snprintf(_debug_tag, sizeof(_debug_tag), "%s", debug_tag);
-  };
-
-  char _debug_tag[DEBUG_TAG_MAX_SIZE];
-  Debug _debugLog;
-  Error _errorLog;
-
-  virtual ~ComponentBase(){};
-};
-}; // namespace EsiLib
diff --git a/plugins/esi/common/DocNode.cc b/plugins/esi/common/DocNode.cc
index fc22f0dcd85..acbe89ed54d 100644
--- a/plugins/esi/common/DocNode.cc
+++ b/plugins/esi/common/DocNode.cc
@@ -21,6 +21,8 @@
   limitations under the License.
  */
 
+#include <ts/ts.h>
+
 #include "DocNode.h"
 #include "Utils.h"
 
@@ -82,12 +84,12 @@ DocNode::unpack(const char *packed_data, int packed_data_len, int &node_len)
   const char *packed_data_start = packed_data;
 
   if (!packed_data || (packed_data_len < static_cast<int>((sizeof(char) + sizeof(int32_t))))) {
-    Utils::ERROR_LOG("[%s] Invalid arguments (%p, %d)", __FUNCTION__, packed_data, packed_data_len);
+    TSError("[%s] Invalid arguments (%p, %d)", __FUNCTION__, packed_data, packed_data_len);
     return false;
   }
   if (*packed_data != DOCNODE_VERSION) {
-    Utils::ERROR_LOG("[%s] Version %d not in supported set (%d)", __FUNCTION__, static_cast<int>(*packed_data),
-                     static_cast<int>(DOCNODE_VERSION));
+    TSError("[%s] Version %d not in supported set (%d)", __FUNCTION__, static_cast<int>(*packed_data),
+            static_cast<int>(DOCNODE_VERSION));
     return false;
   }
   ++packed_data;
@@ -95,7 +97,7 @@ DocNode::unpack(const char *packed_data, int packed_data_len, int &node_len)
   int32_t node_size;
   unpackItem(packed_data, node_size);
   if (node_size > packed_data_len) {
-    Utils::ERROR_LOG("[%s] Data size (%d) not sufficient to hold node of size %d", __FUNCTION__, packed_data_len, node_size);
+    TSError("[%s] Data size (%d) not sufficient to hold node of size %d", __FUNCTION__, packed_data_len, node_size);
     return false;
   }
   node_len = node_size;
@@ -115,7 +117,7 @@ DocNode::unpack(const char *packed_data, int packed_data_len, int &node_len)
   }
 
   if (!child_nodes.unpack(packed_data, packed_data_len - (packed_data - packed_data_start))) {
-    Utils::ERROR_LOG("[%s] Could not unpack child nodes", __FUNCTION__);
+    TSError("[%s] Could not unpack child nodes", __FUNCTION__);
     return false;
   }
   return true;
@@ -135,7 +137,7 @@ bool
 DocNodeList::unpack(const char *data, int data_len)
 {
   if (!data || (data_len < static_cast<int>(sizeof(int32_t)))) {
-    Utils::ERROR_LOG("[%s] Invalid arguments", __FUNCTION__);
+    TSError("[%s] Invalid arguments", __FUNCTION__);
     return false;
   }
   const char *data_start = data;
@@ -146,7 +148,7 @@ DocNodeList::unpack(const char *data, int data_len)
   DocNode node;
   for (int i = 0; i < n_elements; ++i) {
     if (!node.unpack(data_start + data_offset, data_len - data_offset, node_size)) {
-      Utils::ERROR_LOG("[%s] Could not unpack node", __FUNCTION__);
+      TSError("[%s] Could not unpack node", __FUNCTION__);
       return false;
     }
     data_offset += node_size;
diff --git a/plugins/esi/common/Utils.cc b/plugins/esi/common/Utils.cc
index cfd0f846408..7d51f273bb6 100644
--- a/plugins/esi/common/Utils.cc
+++ b/plugins/esi/common/Utils.cc
@@ -23,22 +23,17 @@
 
 #include "Utils.h"
 
+#include <ts/ts.h>
+
 #include <sstream>
 
 using namespace EsiLib;
 
-ComponentBase::Debug Utils::DEBUG_LOG(nullptr);
-ComponentBase::Error Utils::ERROR_LOG(nullptr);
-
-#define DEBUG_TAG "EsiUtils"
-
 using std::string;
 
-void
-Utils::init(ComponentBase::Debug debug_func, ComponentBase::Error error_func)
+namespace
 {
-  DEBUG_LOG = debug_func;
-  ERROR_LOG = error_func;
+DbgCtl dbg_ctl{"EsiUtils"};
 }
 
 bool
@@ -47,7 +42,7 @@ Utils::getAttribute(const string &data, const string &attr, size_t curr_pos, siz
 {
   size_t attr_start = data.find(attr, curr_pos);
   if (attr_start >= end_pos) {
-    ERROR_LOG("[%s] Tag has no [%.*s] attribute", __FUNCTION__, attr.size(), attr.data());
+    TSError("[%s] Tag has no [%.*s] attribute", __FUNCTION__, int(attr.size()), attr.data());
     return false;
   }
   curr_pos          = attr_start + attr.size();
@@ -63,12 +58,12 @@ Utils::getAttribute(const string &data, const string &attr, size_t curr_pos, siz
     }
   }
   if (!equals_found) {
-    ERROR_LOG("[%s] Attribute [%.*s] has no value", __FUNCTION__, attr.size(), attr.data());
+    TSError("[%s] Attribute [%.*s] has no value", __FUNCTION__, int(attr.size()), attr.data());
     return false;
   }
   ++curr_pos;
   if (curr_pos == end_pos) {
-    ERROR_LOG("[%s] No space for value after [%.*s] attribute", __FUNCTION__, attr.size(), attr.data());
+    TSError("[%s] No space for value after [%.*s] attribute", __FUNCTION__, int(attr.size()), attr.data());
     return false;
   }
   bool in_quoted_part = false;
@@ -88,14 +83,14 @@ Utils::getAttribute(const string &data, const string &attr, size_t curr_pos, siz
   }
   const char *data_start_ptr = data.data();
   if (in_quoted_part) {
-    ERROR_LOG("[%s] Unterminated quote in value for attribute [%.*s] starting at [%.10s]", __FUNCTION__, attr.size(), attr.data(),
-              data_start_ptr + curr_pos);
+    TSError("[%s] Unterminated quote in value for attribute [%.*s] starting at [%.10s]", __FUNCTION__, int(attr.size()),
+            attr.data(), data_start_ptr + curr_pos);
     return false;
   }
   if (terminator && term_pos) {
     *term_pos = data.find(terminator, i);
     if (*term_pos >= end_pos) {
-      ERROR_LOG("[%s] Unterminated attribute [%.*s]", __FUNCTION__, attr.size(), attr.data());
+      TSError("[%s] Unterminated attribute [%.*s]", __FUNCTION__, int(attr.size()), attr.data());
       return false;
     }
   }
@@ -131,7 +126,7 @@ Utils::parseKeyValueConfig(const std::list<string> &lines, KeyValueMap &kvMap, H
       }
       if (key.size() && value.size()) {
         kvMap.insert(KeyValueMap::value_type(key, value));
-        DEBUG_LOG(DEBUG_TAG, "[%s] Read value [%s] for key [%s]", __FUNCTION__, value.c_str(), key.c_str());
+        Dbg(dbg_ctl, "[%s] Read value [%s] for key [%s]", __FUNCTION__, value.c_str(), key.c_str());
       }
     }
     key.clear();
@@ -177,8 +172,8 @@ Utils::parseAttributes(const char *data, int data_len, AttributeList &attr_list,
             attr.value_len -= 2;
           }
           if (attr.name_len && attr.value_len) {
-            DEBUG_LOG(DEBUG_TAG, "[%s] Added attribute with name [%.*s] and value [%.*s]", __FUNCTION__, attr.name_len, attr.name,
-                      attr.value_len, attr.value);
+            Dbg(dbg_ctl, "[%s] Added attribute with name [%.*s] and value [%.*s]", __FUNCTION__, attr.name_len, attr.name,
+                attr.value_len, attr.value);
             attr_list.push_back(attr);
           } // else ignore empty name/value
         }   // else ignore attribute with no value
diff --git a/plugins/esi/common/Utils.h b/plugins/esi/common/Utils.h
index ed5c1cece24..209e3f92797 100644
--- a/plugins/esi/common/Utils.h
+++ b/plugins/esi/common/Utils.h
@@ -24,7 +24,6 @@
 #pragma once
 
 #include "DocNode.h"
-#include "ComponentBase.h"
 
 #include <cstring>
 #include <string>
@@ -36,12 +35,6 @@ namespace EsiLib
 {
 namespace Utils
 {
-  extern ComponentBase::Debug DEBUG_LOG;
-
-  extern ComponentBase::Error ERROR_LOG;
-
-  void init(ComponentBase::Debug debug_func, ComponentBase::Error error_func);
-
   // looks for the given attribute in given data; a terminator can
   // also be specified apart from the end_pos; attr_info will point
   // to data inside data string
diff --git a/plugins/esi/common/gzip.cc b/plugins/esi/common/gzip.cc
index 71da60e1d33..41fe2f80387 100644
--- a/plugins/esi/common/gzip.cc
+++ b/plugins/esi/common/gzip.cc
@@ -25,6 +25,7 @@
 
 #include "gzip.h"
 #include <zlib.h>
+#include <ts/ts.h>
 
 #include "Utils.h"
 
@@ -82,7 +83,7 @@ EsiLib::gzip(const ByteBlockList &blocks, std::string &cdata)
   zstrm.zfree  = Z_NULL;
   zstrm.opaque = Z_NULL;
   if (deflateInit2(&zstrm, COMPRESSION_LEVEL, Z_DEFLATED, -MAX_WBITS, ZLIB_MEM_LEVEL, Z_DEFAULT_STRATEGY) != Z_OK) {
-    Utils::ERROR_LOG("[%s] deflateInit2 failed!", __FUNCTION__);
+    TSError("[%s] deflateInit2 failed!", __FUNCTION__);
     return false;
   }
 
@@ -111,7 +112,7 @@ EsiLib::gzip(const ByteBlockList &blocks, std::string &cdata)
   }
   deflateEnd(&zstrm);
   if (deflate_result != Z_STREAM_END) {
-    Utils::ERROR_LOG("[%s] Failure while deflating; error code %d", __FUNCTION__, deflate_result);
+    TSError("[%s] Failure while deflating; error code %d", __FUNCTION__, deflate_result);
     return false;
   }
   cdata[0] = MAGIC_BYTE_1;
@@ -127,11 +128,11 @@ bool
 EsiLib::gunzip(const char *data, int data_len, BufferList &buf_list)
 {
   if (!data || (data_len <= (GZIP_HEADER_SIZE + GZIP_TRAILER_SIZE))) {
-    Utils::ERROR_LOG("[%s] Invalid arguments: 0x%p, %d", __FUNCTION__, data, data_len);
+    TSError("[%s] Invalid arguments: 0x%p, %d", __FUNCTION__, data, data_len);
     return false;
   }
   if ((data[0] != MAGIC_BYTE_1) || (data[1] != MAGIC_BYTE_2) || (data[2] != Z_DEFLATED)) {
-    Utils::ERROR_LOG("[%s] Header check failed!", __FUNCTION__);
+    TSError("[%s] Header check failed!", __FUNCTION__);
     return false;
   }
   data     += GZIP_HEADER_SIZE;
@@ -144,7 +145,7 @@ EsiLib::gunzip(const char *data, int data_len, BufferList &buf_list)
   zstrm.next_in  = nullptr;
   zstrm.avail_in = 0;
   if (inflateInit2(&zstrm, -MAX_WBITS) != Z_OK) {
-    Utils::ERROR_LOG("[%s] inflateInit2 failed!", __FUNCTION__);
+    TSError("[%s] inflateInit2 failed!", __FUNCTION__);
     return false;
   }
   zstrm.next_in  = reinterpret_cast<Bytef *>(const_cast<char *>(data));
@@ -165,11 +166,11 @@ EsiLib::gunzip(const char *data, int data_len, BufferList &buf_list)
       curr_buf_size = BUF_SIZE - zstrm.avail_out;
     }
     if (curr_buf_size > BUF_SIZE) {
-      Utils::ERROR_LOG("[%s] buf too large", __FUNCTION__);
+      TSError("[%s] buf too large", __FUNCTION__);
       break;
     }
     if (curr_buf_size < 1) {
-      Utils::ERROR_LOG("[%s] buf below zero", __FUNCTION__);
+      TSError("[%s] buf below zero", __FUNCTION__);
       break;
     }
     unzipped_data_size += curr_buf_size;
@@ -187,7 +188,7 @@ EsiLib::gunzip(const char *data, int data_len, BufferList &buf_list)
   } while (zstrm.avail_in > 0);
   inflateEnd(&zstrm);
   if (inflate_result != Z_STREAM_END) {
-    Utils::ERROR_LOG("[%s] Failure while inflating; error code %d", __FUNCTION__, inflate_result);
+    TSError("[%s] Failure while inflating; error code %d", __FUNCTION__, inflate_result);
     return false;
   }
   int32_t orig_size;
@@ -195,8 +196,8 @@ EsiLib::gunzip(const char *data, int data_len, BufferList &buf_list)
   extract(data + data_len, orig_crc);
   extract(data + data_len + 4, orig_size);
   if ((crc != orig_crc) || (unzipped_data_size != orig_size)) {
-    Utils::ERROR_LOG("[%s] CRC/size error. Expecting (CRC, size) (0x%x, 0x%x); computed (0x%x, 0x%x)", __FUNCTION__, orig_crc,
-                     orig_size, crc, unzipped_data_size);
+    TSError("[%s] CRC/size error. Expecting (CRC, size) (0x%x, 0x%x); computed (0x%x, 0x%x)", __FUNCTION__, orig_crc, orig_size,
+            unsigned(crc), unzipped_data_size);
     return false;
   }
   return true;
diff --git a/plugins/esi/esi.cc b/plugins/esi/esi.cc
index f5aa37f8f76..999a25a196d 100644
--- a/plugins/esi/esi.cc
+++ b/plugins/esi/esi.cc
@@ -60,15 +60,8 @@ struct OptionInfo {
 static HandlerManager *gHandlerManager = nullptr;
 static Utils::HeaderValueList gAllowlistCookies;
 
-#define DEBUG_TAG             "plugin_esi"
-#define PROCESSOR_DEBUG_TAG   "plugin_esi_processor"
-#define GZIP_DEBUG_TAG        "plugin_esi_gzip"
-#define GUNZIP_DEBUG_TAG      "plugin_esi_gunzip"
-#define PARSER_DEBUG_TAG      "plugin_esi_parser"
-#define FETCHER_DEBUG_TAG     "plugin_esi_fetcher"
-#define VARS_DEBUG_TAG        "plugin_esi_vars"
-#define HANDLER_MGR_DEBUG_TAG "plugin_esi_handler_mgr"
-#define EXPR_DEBUG_TAG        VARS_DEBUG_TAG
+#define DEBUG_TAG         "plugin_esi"
+#define FETCHER_DEBUG_TAG "plugin_esi_fetcher"
 
 #define MIME_FIELD_XESI     "X-Esi"
 #define MIME_FIELD_XESI_LEN 5
@@ -86,6 +79,8 @@ static const char *DATA_TYPE_NAMES_[] = {"RAW_ESI", "GZIPPED_ESI", "PACKED_ESI"}
 static const char *HEADER_MASK_PREFIX    = "Mask-";
 static const int HEADER_MASK_PREFIX_SIZE = 5;
 
+static DbgCtl dbg_ctl_local{DEBUG_TAG};
+
 struct ContData {
   enum STATE {
     READING_ESI_DOC,
@@ -111,7 +106,6 @@ struct ContData {
   DataType input_type;
   string packed_node_list;
   string gzipped_data;
-  char debug_tag[32];
   bool gzip_output;
   bool initialized;
   bool xform_closed;
@@ -148,7 +142,6 @@ struct ContData {
       os_response_cacheable(true)
   {
     client_addr = TSHttpTxnClientAddrGet(txnp);
-    *debug_tag  = '\0';
   }
 
   void fillPostHeader(TSMBuffer bufp, TSMLoc hdr_loc);
@@ -164,6 +157,8 @@ struct ContData {
   ~ContData();
 };
 
+#define CONT_DATA_DBG(CONT_DATA_PTR, FMT, ...) Dbg(dbg_ctl_local, FMT " contp=%p", ##__VA_ARGS__, (CONT_DATA_PTR))
+
 class TSStatSystem : public StatSystem
 {
 public:
@@ -180,15 +175,6 @@ class TSStatSystem : public StatSystem
   }
 };
 
-static const char *
-createDebugTag(const char *prefix, TSCont contp, string &dest)
-{
-  char buf[1024];
-  snprintf(buf, 1024, "%s_%p", prefix, contp);
-  dest.assign(buf);
-  return dest.c_str();
-}
-
 static bool checkHeaderValue(TSMBuffer bufp, TSMLoc hdr_loc, const char *name, int name_len, const char *exp_value = nullptr,
                              int exp_value_len = 0, bool prefix = false); // forward decl
 
@@ -201,9 +187,9 @@ ContData::checkXformStatus()
     int retval = TSVConnClosedGet(contp);
     if ((retval == TS_ERROR) || retval) {
       if (retval == TS_ERROR) {
-        TSDebug(debug_tag, "[%s] Error while getting close status of transformation at state %d", __FUNCTION__, curr_state);
+        CONT_DATA_DBG(this, "[%s] Error while getting close status of transformation at state %d", __FUNCTION__, curr_state);
       } else {
-        TSDebug(debug_tag, "[%s] Vconn closed", __FUNCTION__);
+        CONT_DATA_DBG(this, "[%s] Vconn closed", __FUNCTION__);
       }
       xform_closed = true;
     }
@@ -218,10 +204,6 @@ ContData::init()
     return false;
   }
 
-  string tmp_tag;
-  createDebugTag(DEBUG_TAG, contp, tmp_tag);
-  memcpy(debug_tag, tmp_tag.c_str(), tmp_tag.length() + 1);
-
   checkXformStatus();
 
   bool retval = false;
@@ -250,24 +232,22 @@ ContData::init()
 
     string fetcher_tag, vars_tag, expr_tag, proc_tag, gzip_tag, gunzip_tag;
     if (!data_fetcher) {
-      data_fetcher = new HttpDataFetcherImpl(contp, client_addr, createDebugTag(FETCHER_DEBUG_TAG, contp, fetcher_tag));
+      data_fetcher = new HttpDataFetcherImpl(contp, client_addr, FETCHER_DEBUG_TAG);
     }
     if (!esi_vars) {
-      esi_vars = new Variables(createDebugTag(VARS_DEBUG_TAG, contp, vars_tag), &TSDebug, &TSError, gAllowlistCookies);
+      esi_vars = new Variables(contp, gAllowlistCookies);
     }
 
-    esi_proc = new EsiProcessor(
-      createDebugTag(PROCESSOR_DEBUG_TAG, contp, proc_tag), createDebugTag(PARSER_DEBUG_TAG, contp, fetcher_tag),
-      createDebugTag(EXPR_DEBUG_TAG, contp, expr_tag), &TSDebug, &TSError, *data_fetcher, *esi_vars, *gHandlerManager);
+    esi_proc = new EsiProcessor(contp, *data_fetcher, *esi_vars, *gHandlerManager);
 
-    esi_gzip   = new EsiGzip(createDebugTag(GZIP_DEBUG_TAG, contp, gzip_tag), &TSDebug, &TSError);
-    esi_gunzip = new EsiGunzip(createDebugTag(GUNZIP_DEBUG_TAG, contp, gunzip_tag), &TSDebug, &TSError);
+    esi_gzip   = new EsiGzip();
+    esi_gunzip = new EsiGunzip();
 
-    TSDebug(debug_tag, "[%s] Set input data type to [%s]", __FUNCTION__, DATA_TYPE_NAMES_[input_type]);
+    CONT_DATA_DBG(this, "[%s] Set input data type to [%s]", __FUNCTION__, DATA_TYPE_NAMES_[input_type]);
 
     retval = true;
   } else {
-    TSDebug(debug_tag, "[%s] Transformation closed during initialization; Returning false", __FUNCTION__);
+    CONT_DATA_DBG(this, "[%s] Transformation closed during initialization; Returning false", __FUNCTION__);
   }
 
 lReturn:
@@ -287,11 +267,11 @@ ContData::getClientState()
 
   if (!esi_vars) {
     string vars_tag;
-    esi_vars = new Variables(createDebugTag(VARS_DEBUG_TAG, contp, vars_tag), &TSDebug, &TSError, gAllowlistCookies);
+    esi_vars = new Variables(contp, gAllowlistCookies);
   }
   if (!data_fetcher) {
     string fetcher_tag;
-    data_fetcher = new HttpDataFetcherImpl(contp, client_addr, createDebugTag(FETCHER_DEBUG_TAG, contp, fetcher_tag));
+    data_fetcher = new HttpDataFetcherImpl(contp, client_addr, FETCHER_DEBUG_TAG);
   }
   if (req_bufp && req_hdr_loc) {
     TSMBuffer bufp;
@@ -306,7 +286,7 @@ ContData::getClientState()
       }
       int length;
       request_url = TSUrlStringGet(bufp, url_loc, &length);
-      TSDebug(DEBUG_TAG, "[%s] Got request URL [%s]", __FUNCTION__, request_url ? request_url : "(null)");
+      Dbg(dbg_ctl_local, "[%s] Got request URL [%s]", __FUNCTION__, request_url ? request_url : "(null)");
       int query_len;
       const char *query = TSUrlHttpQueryGet(bufp, url_loc, &query_len);
       if (query) {
@@ -366,10 +346,10 @@ ContData::getClientState()
 
   if (gzip_output) {
     if (option_info->disable_gzip_output) {
-      TSDebug(DEBUG_TAG, "[%s] disable gzip output", __FUNCTION__);
+      Dbg(dbg_ctl_local, "[%s] disable gzip output", __FUNCTION__);
       gzip_output = false;
     } else {
-      TSDebug(DEBUG_TAG, "[%s] Client accepts gzip encoding; will compress output", __FUNCTION__);
+      Dbg(dbg_ctl_local, "[%s] Client accepts gzip encoding; will compress output", __FUNCTION__);
     }
   }
 
@@ -387,17 +367,17 @@ ContData::fillPostHeader(TSMBuffer bufp, TSMLoc hdr_loc)
   for (int i = 0; i < n_mime_headers; ++i) {
     field_loc = TSMimeHdrFieldGet(bufp, hdr_loc, i);
     if (!field_loc) {
-      TSDebug(DEBUG_TAG, "[%s] Error while obtaining header field #%d", __FUNCTION__, i);
+      Dbg(dbg_ctl_local, "[%s] Error while obtaining header field #%d", __FUNCTION__, i);
       continue;
     }
     name = TSMimeHdrFieldNameGet(bufp, hdr_loc, field_loc, &name_len);
     if (name) {
       if (Utils::areEqual(name, name_len, TS_MIME_FIELD_TRANSFER_ENCODING, TS_MIME_LEN_TRANSFER_ENCODING)) {
-        TSDebug(DEBUG_TAG, "[%s] Not retaining transfer encoding header", __FUNCTION__);
+        Dbg(dbg_ctl_local, "[%s] Not retaining transfer encoding header", __FUNCTION__);
       } else if (Utils::areEqual(name, name_len, MIME_FIELD_XESI, MIME_FIELD_XESI_LEN)) {
-        TSDebug(DEBUG_TAG, "[%s] Not retaining 'X-Esi' header", __FUNCTION__);
+        Dbg(dbg_ctl_local, "[%s] Not retaining 'X-Esi' header", __FUNCTION__);
       } else if (Utils::areEqual(name, name_len, TS_MIME_FIELD_CONTENT_LENGTH, TS_MIME_LEN_CONTENT_LENGTH)) {
-        TSDebug(DEBUG_TAG, "[%s] Not retaining 'Content-length' header", __FUNCTION__);
+        Dbg(dbg_ctl_local, "[%s] Not retaining 'Content-length' header", __FUNCTION__);
       } else {
         header.assign(name, name_len);
         header.append(": ");
@@ -405,14 +385,14 @@ ContData::fillPostHeader(TSMBuffer bufp, TSMLoc hdr_loc)
         for (int j = 0; j < n_field_values; ++j) {
           value = TSMimeHdrFieldValueStringGet(bufp, hdr_loc, field_loc, j, &value_len);
           if (nullptr == value || !value_len) {
-            TSDebug(DEBUG_TAG, "[%s] Error while getting value #%d of header [%.*s]", __FUNCTION__, j, name_len, name);
+            Dbg(dbg_ctl_local, "[%s] Error while getting value #%d of header [%.*s]", __FUNCTION__, j, name_len, name);
           } else {
             if (Utils::areEqual(name, name_len, TS_MIME_FIELD_VARY, TS_MIME_LEN_VARY) &&
                 Utils::areEqual(value, value_len, TS_MIME_FIELD_ACCEPT_ENCODING, TS_MIME_LEN_ACCEPT_ENCODING)) {
-              TSDebug(DEBUG_TAG, "[%s] Not retaining 'vary: accept-encoding' header", __FUNCTION__);
+              Dbg(dbg_ctl_local, "[%s] Not retaining 'vary: accept-encoding' header", __FUNCTION__);
             } else if (Utils::areEqual(name, name_len, TS_MIME_FIELD_CONTENT_ENCODING, TS_MIME_LEN_CONTENT_ENCODING) &&
                        Utils::areEqual(value, value_len, TS_HTTP_VALUE_GZIP, TS_HTTP_LEN_GZIP)) {
-              TSDebug(DEBUG_TAG, "[%s] Not retaining 'content-encoding: gzip' header", __FUNCTION__);
+              Dbg(dbg_ctl_local, "[%s] Not retaining 'content-encoding: gzip' header", __FUNCTION__);
             } else {
               if (header[header.size() - 2] != ':') {
                 header.append(", ");
@@ -420,8 +400,8 @@ ContData::fillPostHeader(TSMBuffer bufp, TSMLoc hdr_loc)
               header.append(value, value_len);
               checkForCacheHeader(name, name_len, value, value_len, os_response_cacheable);
               if (!os_response_cacheable) {
-                TSDebug(DEBUG_TAG, "[%s] Header [%.*s] with value [%.*s] is a no-cache header", __FUNCTION__, name_len, name,
-                        value_len, value);
+                Dbg(dbg_ctl_local, "[%s] Header [%.*s] with value [%.*s] is a no-cache header", __FUNCTION__, name_len, name,
+                    value_len, value);
                 break;
               }
             }
@@ -479,7 +459,7 @@ ContData::getServerState()
 
 ContData::~ContData()
 {
-  TSDebug(debug_tag, "[%s] Destroying continuation data", __FUNCTION__);
+  CONT_DATA_DBG(this, "[%s] Destroying continuation data", __FUNCTION__);
   if (output_reader) {
     TSIOBufferReaderFree(output_reader);
   }
@@ -579,7 +559,7 @@ cacheNodeList(ContData *cont_data)
 {
   bool client_abort;
   if (TSHttpTxnAborted(cont_data->txnp, &client_abort) == TS_SUCCESS) {
-    TSDebug(cont_data->debug_tag, "[%s] Not caching node list as txn has been aborted", __FUNCTION__);
+    CONT_DATA_DBG(cont_data, "[%s] Not caching node list as txn has been aborted", __FUNCTION__);
     return;
   }
   string post_request("");
@@ -593,7 +573,6 @@ cacheNodeList(ContData *cont_data)
        ++list_iter) {
     post_request.append(ECHO_HEADER_PREFIX);
 
-    // TSDebug(cont_data->debug_tag, "[%s] header == %s", __FUNCTION__, list_iter->c_str());
     if (((int)list_iter->length() > HEADER_MASK_PREFIX_SIZE) &&
         (strncmp(list_iter->c_str(), HEADER_MASK_PREFIX, HEADER_MASK_PREFIX_SIZE) == 0)) {
       post_request.append(list_iter->c_str() + HEADER_MASK_PREFIX_SIZE, list_iter->length() - HEADER_MASK_PREFIX_SIZE);
@@ -614,9 +593,6 @@ cacheNodeList(ContData *cont_data)
   post_request.append(buf);
   post_request.append(body);
 
-  // TSError("[%s] DO caching node list size=%d", __FUNCTION__, (int)body.size());
-  // TSDebug(cont_data->debug_tag, "[%s] caching node list size=%d", __FUNCTION__, (int)body.size());
-
   TSFetchEvent event_ids = {0, 0, 0};
   TSFetchUrl(post_request.data(), post_request.size(), cont_data->client_addr, cont_data->contp, NO_CALLBACK, event_ids);
 }
@@ -636,19 +612,19 @@ transformData(TSCont contp)
   if (!TSVIOBufferGet(cont_data->input_vio)) {
     input_vio_buf_null = true;
     if (cont_data->curr_state == ContData::PROCESSING_COMPLETE) {
-      TSDebug(cont_data->debug_tag, "[%s] input_vio NULL, marking transformation to be terminated", __FUNCTION__);
+      CONT_DATA_DBG(cont_data, "[%s] input_vio NULL, marking transformation to be terminated", __FUNCTION__);
       return 1;
     } else if (cont_data->curr_state == ContData::READING_ESI_DOC) {
-      TSDebug(cont_data->debug_tag, "[%s] input_vio NULL while in read state. Assuming end of input", __FUNCTION__);
+      CONT_DATA_DBG(cont_data, "[%s] input_vio NULL while in read state. Assuming end of input", __FUNCTION__);
       process_input_complete = true;
     } else {
       if (!cont_data->data_fetcher->isFetchComplete()) {
-        TSDebug(cont_data->debug_tag, "[%s] input_vio NULL, but data needs to be fetched. Returning control", __FUNCTION__);
+        CONT_DATA_DBG(cont_data, "[%s] input_vio NULL, but data needs to be fetched. Returning control", __FUNCTION__);
         if (!cont_data->option_info->first_byte_flush) {
           return 1;
         }
       } else {
-        TSDebug(cont_data->debug_tag, "[%s] input_vio NULL, but processing needs to (and can) be completed", __FUNCTION__);
+        CONT_DATA_DBG(cont_data, "[%s] input_vio NULL, but processing needs to (and can) be completed", __FUNCTION__);
       }
     }
   }
@@ -656,7 +632,7 @@ transformData(TSCont contp)
   if (!process_input_complete && (cont_data->curr_state == ContData::READING_ESI_DOC)) {
     // Determine how much data we have left to read.
     toread = TSVIONTodoGet(cont_data->input_vio);
-    TSDebug(cont_data->debug_tag, "[%s] upstream VC has %" PRId64 " bytes available to read", __FUNCTION__, toread);
+    CONT_DATA_DBG(cont_data, "[%s] upstream VC has %" PRId64 " bytes available to read", __FUNCTION__, toread);
 
     if (toread > 0) {
       avail = TSIOBufferReaderAvail(cont_data->input_reader);
@@ -682,14 +658,14 @@ transformData(TSCont contp)
           } else {
             cont_data->packed_node_list.append(data, data_len);
           }
-          TSDebug(cont_data->debug_tag, "[%s] Added chunk of %" PRId64 " bytes starting with [%.10s] to parse list", __FUNCTION__,
-                  data_len, (data_len ? data : "(null)"));
+          CONT_DATA_DBG(cont_data, "[%s] Added chunk of %" PRId64 " bytes starting with [%.10s] to parse list", __FUNCTION__,
+                        data_len, (data_len ? data : "(null)"));
           consumed += data_len;
 
           block = TSIOBufferBlockNext(block);
         }
       }
-      TSDebug(cont_data->debug_tag, "[%s] Consumed %" PRId64 " bytes from upstream VC", __FUNCTION__, consumed);
+      CONT_DATA_DBG(cont_data, "[%s] Consumed %" PRId64 " bytes from upstream VC", __FUNCTION__, consumed);
 
       TSIOBufferReaderConsume(cont_data->input_reader, consumed);
 
@@ -708,10 +684,10 @@ transformData(TSCont contp)
     }
   }
   if (process_input_complete) {
-    TSDebug(cont_data->debug_tag, "[%s] Completed reading input", __FUNCTION__);
+    CONT_DATA_DBG(cont_data, "[%s] Completed reading input", __FUNCTION__);
     if (cont_data->input_type == DATA_TYPE_PACKED_ESI) {
-      TSDebug(DEBUG_TAG, "[%s] Going to use packed node list of size %d", __FUNCTION__,
-              static_cast<int>(cont_data->packed_node_list.size()));
+      Dbg(dbg_ctl_local, "[%s] Going to use packed node list of size %d", __FUNCTION__,
+          static_cast<int>(cont_data->packed_node_list.size()));
       if (cont_data->esi_proc->usePackedNodeList(cont_data->packed_node_list) == EsiProcessor::UNPACK_FAILURE) {
         removeCacheKey(cont_data->txnp);
 
@@ -743,22 +719,22 @@ transformData(TSCont contp)
   if ((cont_data->curr_state == ContData::FETCHING_DATA) &&
       (!cont_data->option_info->first_byte_flush)) { // retest as state may have changed in previous block
     if (cont_data->data_fetcher->isFetchComplete()) {
-      TSDebug(cont_data->debug_tag, "[%s] data ready; going to process doc", __FUNCTION__);
+      CONT_DATA_DBG(cont_data, "[%s] data ready; going to process doc", __FUNCTION__);
       const char *out_data;
       int out_data_len;
       EsiProcessor::ReturnCode retval = cont_data->esi_proc->process(out_data, out_data_len);
-      TSDebug(cont_data->debug_tag, "[%s] data length: %d, retval: %d", __FUNCTION__, out_data_len, retval);
+      CONT_DATA_DBG(cont_data, "[%s] data length: %d, retval: %d", __FUNCTION__, out_data_len, retval);
       if (retval == EsiProcessor::NEED_MORE_DATA) {
-        TSDebug(cont_data->debug_tag,
-                "[%s] ESI processor needs more data; "
-                "will wait for all data to be fetched",
-                __FUNCTION__);
+        CONT_DATA_DBG(cont_data,
+                      "[%s] ESI processor needs more data; "
+                      "will wait for all data to be fetched",
+                      __FUNCTION__);
         return 1;
       }
       cont_data->curr_state = ContData::PROCESSING_COMPLETE;
       if (retval == EsiProcessor::SUCCESS) {
-        TSDebug(cont_data->debug_tag, "[%s] ESI processor output document of size %d starting with [%.10s]", __FUNCTION__,
-                out_data_len, (out_data_len ? out_data : "(null)"));
+        CONT_DATA_DBG(cont_data, "[%s] ESI processor output document of size %d starting with [%.10s]", __FUNCTION__, out_data_len,
+                      (out_data_len ? out_data : "(null)"));
       } else {
         TSError("[esi][%s] ESI processor failed to process document; will return empty document", __FUNCTION__);
         out_data     = "";
@@ -774,8 +750,8 @@ transformData(TSCont contp)
             out_data_len = 0;
             out_data     = "";
           } else {
-            TSDebug(cont_data->debug_tag, "[%s] Compressed document from size %d to %d bytes via gzip", __FUNCTION__, out_data_len,
-                    static_cast<int>(cdata.size()));
+            CONT_DATA_DBG(cont_data, "[%s] Compressed document from size %d to %d bytes via gzip", __FUNCTION__, out_data_len,
+                          static_cast<int>(cdata.size()));
             out_data_len = cdata.size();
             out_data     = cdata.data();
           }
@@ -803,26 +779,26 @@ transformData(TSCont contp)
         TSVIOReenable(output_vio);
       }
     } else {
-      TSDebug(cont_data->debug_tag, "[%s] Data not available yet; cannot process document", __FUNCTION__);
+      CONT_DATA_DBG(cont_data, "[%s] Data not available yet; cannot process document", __FUNCTION__);
     }
   }
 
   if (((cont_data->curr_state == ContData::FETCHING_DATA) || (cont_data->curr_state == ContData::READING_ESI_DOC)) &&
       (cont_data->option_info->first_byte_flush)) { // retest as state may have changed in previous block
-    TSDebug(cont_data->debug_tag, "[%s] trying to process doc", __FUNCTION__);
+    CONT_DATA_DBG(cont_data, "[%s] trying to process doc", __FUNCTION__);
     string out_data;
     string cdata;
     int overall_len;
     EsiProcessor::ReturnCode retval = cont_data->esi_proc->flush(out_data, overall_len);
 
     if ((cont_data->curr_state == ContData::FETCHING_DATA) && cont_data->data_fetcher->isFetchComplete()) {
-      TSDebug(cont_data->debug_tag, "[%s] data ready; last process() will have finished the entire processing", __FUNCTION__);
+      CONT_DATA_DBG(cont_data, "[%s] data ready; last process() will have finished the entire processing", __FUNCTION__);
       cont_data->curr_state = ContData::PROCESSING_COMPLETE;
     }
 
     if (retval == EsiProcessor::SUCCESS) {
-      TSDebug(cont_data->debug_tag, "[%s] ESI processor output document of size %d starting with [%.10s]", __FUNCTION__,
-              static_cast<int>(out_data.size()), (out_data.size() ? out_data.data() : "(null)"));
+      CONT_DATA_DBG(cont_data, "[%s] ESI processor output document of size %d starting with [%.10s]", __FUNCTION__,
+                    static_cast<int>(out_data.size()), (out_data.size() ? out_data.data() : "(null)"));
     } else {
       TSError("[esi][%s] ESI processor failed to process document; will return empty document", __FUNCTION__);
       out_data.assign("");
@@ -839,8 +815,8 @@ transformData(TSCont contp)
         if (!cont_data->esi_gzip->stream_encode(out_data, cdata)) {
           TSError("[esi][%s] Error while gzipping content", __FUNCTION__);
         } else {
-          TSDebug(cont_data->debug_tag, "[%s] Compressed document from size %d to %d bytes via EsiGzip", __FUNCTION__,
-                  static_cast<int>(out_data.size()), static_cast<int>(cdata.size()));
+          CONT_DATA_DBG(cont_data, "[%s] Compressed document from size %d to %d bytes via EsiGzip", __FUNCTION__,
+                        static_cast<int>(out_data.size()), static_cast<int>(cdata.size()));
         }
         if (TSIOBufferWrite(TSVIOBufferGet(cont_data->output_vio), cdata.data(), cdata.size()) == TS_ERROR) {
           TSError("[esi][%s] Error while writing bytes to downstream VC", __FUNCTION__);
@@ -871,11 +847,11 @@ transformData(TSCont contp)
               TSError("[esi][%s] Error while writing bytes to downstream VC", __FUNCTION__);
               return 0;
             }
-            TSDebug(cont_data->debug_tag, "[%s] ESI processed overall/gzip: %d", __FUNCTION__, downstream_length);
+            CONT_DATA_DBG(cont_data, "[%s] ESI processed overall/gzip: %d", __FUNCTION__, downstream_length);
             TSVIONBytesSet(cont_data->output_vio, downstream_length);
           }
         } else {
-          TSDebug(cont_data->debug_tag, "[%s] ESI processed overall: %d", __FUNCTION__, overall_len);
+          CONT_DATA_DBG(cont_data, "[%s] ESI processed overall: %d", __FUNCTION__, overall_len);
           TSVIONBytesSet(cont_data->output_vio, overall_len);
         }
       }
@@ -897,7 +873,6 @@ transformHandler(TSCont contp, TSEvent event, void *edata)
 
   // we need these later, but declaring now avoid compiler warning w.r.t. goto
   bool process_event = true;
-  const char *cont_debug_tag;
   bool shutdown, is_fetch_event;
 
   if (!cont_data->initialized) {
@@ -905,38 +880,36 @@ transformHandler(TSCont contp, TSEvent event, void *edata)
       TSError("[esi][%s] Could not initialize continuation data; shutting down transformation", __FUNCTION__);
       goto lShutdown;
     }
-    TSDebug(cont_data->debug_tag, "[%s] initialized continuation data", __FUNCTION__);
+    CONT_DATA_DBG(cont_data, "[%s] initialized continuation data", __FUNCTION__);
   }
 
-  cont_debug_tag = cont_data->debug_tag; // just a handy reference
-
   cont_data->checkXformStatus();
 
   is_fetch_event = cont_data->data_fetcher->isFetchEvent(event);
 
   if (cont_data->xform_closed) {
-    TSDebug(cont_debug_tag, "[%s] Transformation closed, post-processing", __FUNCTION__);
+    CONT_DATA_DBG(cont_data, "[%s] Transformation closed, post-processing", __FUNCTION__);
     if (cont_data->curr_state == ContData::PROCESSING_COMPLETE) {
-      TSDebug(cont_debug_tag, "[%s] Processing is complete, not processing current event %d", __FUNCTION__, event);
+      CONT_DATA_DBG(cont_data, "[%s] Processing is complete, not processing current event %d", __FUNCTION__, event);
       process_event = false;
     } else if (cont_data->curr_state == ContData::READING_ESI_DOC) {
-      TSDebug(cont_debug_tag, "[%s] Parsing is incomplete, will force end of input", __FUNCTION__);
+      CONT_DATA_DBG(cont_data, "[%s] Parsing is incomplete, will force end of input", __FUNCTION__);
       cont_data->curr_state = ContData::FETCHING_DATA;
     }
     if (cont_data->curr_state == ContData::FETCHING_DATA) { // retest as it may be modified in prev. if block
       if (cont_data->data_fetcher->isFetchComplete()) {
-        TSDebug(cont_debug_tag, "[%s] Requested data has been fetched; will skip event and marking processing as complete ",
-                __FUNCTION__);
+        CONT_DATA_DBG(cont_data, "[%s] Requested data has been fetched; will skip event and marking processing as complete ",
+                      __FUNCTION__);
         cont_data->curr_state = ContData::PROCESSING_COMPLETE;
         process_event         = false;
       } else {
         if (is_fetch_event) {
-          TSDebug(cont_debug_tag, "[%s] Going to process received data", __FUNCTION__);
+          CONT_DATA_DBG(cont_data, "[%s] Going to process received data", __FUNCTION__);
         } else {
           // transformation is over, but data hasn't been fetched;
           // let's wait for data to be fetched - we will be called
           // by Fetch API and go through this loop again
-          TSDebug(cont_debug_tag, "[%s] Ignoring event %d; Will wait for pending data", __FUNCTION__, event);
+          CONT_DATA_DBG(cont_data, "[%s] Ignoring event %d; Will wait for pending data", __FUNCTION__, event);
           process_event = false;
         }
       }
@@ -959,31 +932,31 @@ transformHandler(TSCont contp, TSEvent event, void *edata)
       break;
 
     case TS_EVENT_VCONN_WRITE_READY:
-      TSDebug(cont_debug_tag, "[%s] WRITE_READY", __FUNCTION__);
+      CONT_DATA_DBG(cont_data, "[%s] WRITE_READY", __FUNCTION__);
       if (!cont_data->option_info->first_byte_flush) {
         TSVConnShutdown(TSTransformOutputVConnGet(contp), 0, 1);
       }
       break;
 
     case TS_EVENT_VCONN_WRITE_COMPLETE:
-      TSDebug(cont_debug_tag, "[%s] shutting down transformation", __FUNCTION__);
+      CONT_DATA_DBG(cont_data, "[%s] shutting down transformation", __FUNCTION__);
       TSVConnShutdown(TSTransformOutputVConnGet(contp), 0, 1);
       break;
 
     case TS_EVENT_IMMEDIATE:
-      TSDebug(cont_debug_tag, "[%s] handling TS_EVENT_IMMEDIATE", __FUNCTION__);
+      CONT_DATA_DBG(cont_data, "[%s] handling TS_EVENT_IMMEDIATE", __FUNCTION__);
       transformData(contp);
       break;
 
     default:
       if (is_fetch_event) {
-        TSDebug(cont_debug_tag, "[%s] Handling fetch event %d", __FUNCTION__, event);
+        CONT_DATA_DBG(cont_data, "[%s] Handling fetch event %d", __FUNCTION__, event);
         if (cont_data->data_fetcher->handleFetchEvent(event, edata)) {
           if ((cont_data->curr_state == ContData::FETCHING_DATA) || (cont_data->curr_state == ContData::READING_ESI_DOC)) {
             // there's a small chance that fetcher is ready even before
             // parsing is complete; hence we need to check the state too
             if (cont_data->option_info->first_byte_flush || cont_data->data_fetcher->isFetchComplete()) {
-              TSDebug(cont_debug_tag, "[%s] fetcher is ready with data, going into process stage", __FUNCTION__);
+              CONT_DATA_DBG(cont_data, "[%s] fetcher is ready with data, going into process stage", __FUNCTION__);
               transformData(contp);
             }
           }
@@ -997,8 +970,8 @@ transformHandler(TSCont contp, TSEvent event, void *edata)
     }
   }
 
-  TSDebug(cont_data->debug_tag, "[%s] transformHandler, event: %d, curr_state: %d", __FUNCTION__, static_cast<int>(event),
-          static_cast<int>(cont_data->curr_state));
+  CONT_DATA_DBG(cont_data, "[%s] transformHandler, event: %d, curr_state: %d", __FUNCTION__, static_cast<int>(event),
+                static_cast<int>(cont_data->curr_state));
 
   shutdown = (cont_data->xform_closed && (cont_data->curr_state == ContData::PROCESSING_COMPLETE));
   if (shutdown) {
@@ -1006,7 +979,7 @@ transformHandler(TSCont contp, TSEvent event, void *edata)
       // we need to return control to the fetch API to give up it's
       // lock on our continuation which will fail if we destroy
       // ourselves right now
-      TSDebug(cont_debug_tag, "[%s] Deferring shutdown as data event was just processed", __FUNCTION__);
+      CONT_DATA_DBG(cont_data, "[%s] Deferring shutdown as data event was just processed", __FUNCTION__);
       TSContScheduleOnPool(contp, 10, TS_THREAD_POOL_TASK);
     } else {
       goto lShutdown;
@@ -1016,7 +989,7 @@ transformHandler(TSCont contp, TSEvent event, void *edata)
   return 1;
 
 lShutdown:
-  TSDebug(cont_data->debug_tag, "[%s] transformation closed; cleaning up data", __FUNCTION__);
+  CONT_DATA_DBG(cont_data, "[%s] transformation closed; cleaning up data", __FUNCTION__);
   delete cont_data;
   TSContDestroy(contp);
   return 1;
@@ -1074,7 +1047,7 @@ modifyResponseHeader(TSCont contp, TSEvent event, void *edata)
     for (int i = 0; i < n_mime_headers; ++i) {
       field_loc = TSMimeHdrFieldGet(bufp, hdr_loc, i);
       if (!field_loc) {
-        TSDebug(DEBUG_TAG, "[%s] Error while obtaining header field #%d", __FUNCTION__, i);
+        Dbg(dbg_ctl_local, "[%s] Error while obtaining header field #%d", __FUNCTION__, i);
         continue;
       }
       name = TSMimeHdrFieldNameGet(bufp, hdr_loc, field_loc, &name_len);
@@ -1096,14 +1069,14 @@ modifyResponseHeader(TSCont contp, TSEvent event, void *edata)
         } else if (Utils::areEqual(name, name_len, TS_MIME_FIELD_CONTENT_LENGTH, TS_MIME_LEN_CONTENT_LENGTH)) {
           if (mod_data->head_only) {
             destroy_header = true;
-            TSDebug(DEBUG_TAG, "[%s] remove Content-Length", __FUNCTION__);
+            Dbg(dbg_ctl_local, "[%s] remove Content-Length", __FUNCTION__);
           }
         } else {
           int n_field_values = TSMimeHdrFieldValuesCount(bufp, hdr_loc, field_loc);
           for (int j = 0; j < n_field_values; ++j) {
             value = TSMimeHdrFieldValueStringGet(bufp, hdr_loc, field_loc, j, &value_len);
             if (nullptr == value || !value_len) {
-              TSDebug(DEBUG_TAG, "[%s] Error while getting value #%d of header [%.*s]", __FUNCTION__, j, name_len, name);
+              Dbg(dbg_ctl_local, "[%s] Error while getting value #%d of header [%.*s]", __FUNCTION__, j, name_len, name);
             } else {
               if (!mod_data->option_info->packed_node_support || mod_data->cache_txn) {
                 bool response_cacheable, is_cache_header;
@@ -1116,7 +1089,7 @@ modifyResponseHeader(TSCont contp, TSEvent event, void *edata)
           }   // end for
         }
         if (destroy_header) {
-          TSDebug(DEBUG_TAG, "[%s] Removing header with name [%.*s]", __FUNCTION__, name_len, name);
+          Dbg(dbg_ctl_local, "[%s] Removing header with name [%.*s]", __FUNCTION__, name_len, name);
           TSMimeHdrFieldDestroy(bufp, hdr_loc, field_loc);
           --n_mime_headers;
           --i;
@@ -1143,7 +1116,7 @@ modifyResponseHeader(TSCont contp, TSEvent event, void *edata)
     }
 
     TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
-    TSDebug(DEBUG_TAG, "[%s] Inspected client-bound headers", __FUNCTION__);
+    Dbg(dbg_ctl_local, "[%s] Inspected client-bound headers", __FUNCTION__);
     retval = 1;
   } else {
     TSError("[esi][%s] Error while getting response from txn", __FUNCTION__);
@@ -1180,7 +1153,7 @@ checkHeaderValue(TSMBuffer bufp, TSMLoc hdr_loc, const char *name, int name_len,
           retval = true;
         }
       } else {
-        TSDebug(DEBUG_TAG, "[%s] Error while getting value # %d of header [%.*s]", __FUNCTION__, i, name_len, name);
+        Dbg(dbg_ctl_local, "[%s] Error while getting value # %d of header [%.*s]", __FUNCTION__, i, name_len, name);
       }
       if (retval) {
         break;
@@ -1212,7 +1185,7 @@ maskOsCacheHeaders(TSHttpTxn txnp)
   for (int i = 0; i < n_mime_headers; ++i) {
     field_loc = TSMimeHdrFieldGet(bufp, hdr_loc, i);
     if (!field_loc) {
-      TSDebug(DEBUG_TAG, "[%s] Error while obtaining header field #%d", __FUNCTION__, i);
+      Dbg(dbg_ctl_local, "[%s] Error while obtaining header field #%d", __FUNCTION__, i);
       continue;
     }
     name = TSMimeHdrFieldNameGet(bufp, hdr_loc, field_loc, &name_len);
@@ -1222,15 +1195,15 @@ maskOsCacheHeaders(TSHttpTxn txnp)
       for (int j = 0; j < n_field_values; ++j) {
         value = TSMimeHdrFieldValueStringGet(bufp, hdr_loc, field_loc, j, &value_len);
         if (nullptr == value || !value_len) {
-          TSDebug(DEBUG_TAG, "[%s] Error while getting value #%d of header [%.*s]", __FUNCTION__, j, name_len, name);
+          Dbg(dbg_ctl_local, "[%s] Error while getting value #%d of header [%.*s]", __FUNCTION__, j, name_len, name);
         } else {
           bool is_cache_header = checkForCacheHeader(name, name_len, value, value_len, os_response_cacheable);
           if (!os_response_cacheable) {
             break;
           }
           if (is_cache_header) {
-            TSDebug(DEBUG_TAG, "[%s] Masking OS cache header [%.*s] with value [%.*s]. ", __FUNCTION__, name_len, name, value_len,
-                    value);
+            Dbg(dbg_ctl_local, "[%s] Masking OS cache header [%.*s] with value [%.*s]. ", __FUNCTION__, name_len, name, value_len,
+                value);
             mask_header = true;
           }
         } // end if got value string
@@ -1280,7 +1253,7 @@ isTxnTransformable(TSHttpTxn txnp, bool is_cache_txn, bool *intercept_header, bo
     *head_only = true;
   } else if (!(((method_len >= TS_HTTP_LEN_POST && memcmp(method, TS_HTTP_METHOD_POST, TS_HTTP_LEN_POST) == 0)) ||
                ((method_len >= TS_HTTP_LEN_GET && memcmp(method, TS_HTTP_METHOD_GET, TS_HTTP_LEN_GET) == 0)))) {
-    TSDebug(DEBUG_TAG, "[%s] method %.*s will be ignored", __FUNCTION__, method_len, method);
+    Dbg(dbg_ctl_local, "[%s] method %.*s will be ignored", __FUNCTION__, method_len, method);
     TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
     return false;
   }
@@ -1310,10 +1283,10 @@ isTxnTransformable(TSHttpTxn txnp, bool is_cache_txn, bool *intercept_header, bo
     *intercept_header = checkHeaderValue(bufp, hdr_loc, SERVER_INTERCEPT_HEADER, SERVER_INTERCEPT_HEADER_LEN);
     if (*intercept_header) {
       if (is_cache_txn) {
-        TSDebug(DEBUG_TAG, "[%s] Packed ESI document found in cache; will process", __FUNCTION__);
+        Dbg(dbg_ctl_local, "[%s] Packed ESI document found in cache; will process", __FUNCTION__);
         retval = true;
       } else {
-        TSDebug(DEBUG_TAG, "[%s] Found Intercept header in server response; document not processable", __FUNCTION__);
+        Dbg(dbg_ctl_local, "[%s] Found Intercept header in server response; document not processable", __FUNCTION__);
       }
       break; // found internal header; no other detection required
     }
@@ -1325,11 +1298,11 @@ isTxnTransformable(TSHttpTxn txnp, bool is_cache_txn, bool *intercept_header, bo
                            true)) &&
         (!checkHeaderValue(bufp, hdr_loc, TS_MIME_FIELD_CONTENT_TYPE, TS_MIME_LEN_CONTENT_TYPE, "application/json", 16, true)) &&
         (!checkHeaderValue(bufp, hdr_loc, TS_MIME_FIELD_CONTENT_TYPE, TS_MIME_LEN_CONTENT_TYPE, "multipart/mixed", 15, true))) {
-      TSDebug(DEBUG_TAG, "[%s] Not text content", __FUNCTION__);
+      Dbg(dbg_ctl_local, "[%s] Not text content", __FUNCTION__);
       break;
     }
     if (!checkHeaderValue(bufp, hdr_loc, MIME_FIELD_XESI, MIME_FIELD_XESI_LEN)) {
-      TSDebug(DEBUG_TAG, "[%s] ESI header [%s] not found", __FUNCTION__, MIME_FIELD_XESI);
+      Dbg(dbg_ctl_local, "[%s] ESI header [%s] not found", __FUNCTION__, MIME_FIELD_XESI);
       break;
     }
 
@@ -1349,10 +1322,10 @@ isCacheObjTransformable(TSHttpTxn txnp, bool *intercept_header, bool *head_only)
     return false;
   }
   if (obj_status == TS_CACHE_LOOKUP_HIT_FRESH) {
-    TSDebug(DEBUG_TAG, "[%s] doc found in cache, will add transformation", __FUNCTION__);
+    Dbg(dbg_ctl_local, "[%s] doc found in cache, will add transformation", __FUNCTION__);
     return isTxnTransformable(txnp, true, intercept_header, head_only);
   }
-  TSDebug(DEBUG_TAG, "[%s] cache object's status is %d; not transformable", __FUNCTION__, obj_status);
+  Dbg(dbg_ctl_local, "[%s] cache object's status is %d; not transformable", __FUNCTION__, obj_status);
   return false;
 }
 
@@ -1360,7 +1333,7 @@ static bool
 isInterceptRequest(TSHttpTxn txnp)
 {
   if (!TSHttpTxnIsInternal(txnp)) {
-    TSDebug(DEBUG_TAG, "[%s] Skipping external request", __FUNCTION__);
+    Dbg(dbg_ctl_local, "[%s] Skipping external request", __FUNCTION__);
     return false;
   }
 
@@ -1379,9 +1352,9 @@ isInterceptRequest(TSHttpTxn txnp)
     TSError("[esi][%s] Could not obtain method!", __FUNCTION__);
   } else {
     if ((method_len != TS_HTTP_LEN_POST) || (strncasecmp(method, TS_HTTP_METHOD_POST, TS_HTTP_LEN_POST))) {
-      TSDebug(DEBUG_TAG, "[%s] Method [%.*s] invalid, [%s] expected", __FUNCTION__, method_len, method, TS_HTTP_METHOD_POST);
+      Dbg(dbg_ctl_local, "[%s] Method [%.*s] invalid, [%s] expected", __FUNCTION__, method_len, method, TS_HTTP_METHOD_POST);
     } else {
-      TSDebug(DEBUG_TAG, "[%s] Valid server intercept method found", __FUNCTION__);
+      Dbg(dbg_ctl_local, "[%s] Valid server intercept method found", __FUNCTION__);
       valid_request = true;
     }
   }
@@ -1481,7 +1454,7 @@ addTransform(TSHttpTxn txnp, const bool processing_os_response, const bool inter
     TSHttpTxnUntransformedRespCache(txnp, 1);
   }
 
-  TSDebug(DEBUG_TAG, "[%s] Added transformation (0x%p)", __FUNCTION__, contp);
+  Dbg(dbg_ctl_local, "[%s] Added transformation (0x%p)", __FUNCTION__, contp);
   return true;
 
 lFail:
@@ -1505,15 +1478,15 @@ globalHookHandler(TSCont contp, TSEvent event, void *edata)
 
   switch (event) {
   case TS_EVENT_HTTP_READ_REQUEST_HDR:
-    TSDebug(DEBUG_TAG, "[%s] handling read request header event", __FUNCTION__);
+    Dbg(dbg_ctl_local, "[%s] handling read request header event", __FUNCTION__);
     if (intercept_req) {
       if (!setupServerIntercept(txnp)) {
         TSError("[esi][%s] Could not setup server intercept", __FUNCTION__);
       } else {
-        TSDebug(DEBUG_TAG, "[%s] Setup server intercept", __FUNCTION__);
+        Dbg(dbg_ctl_local, "[%s] Setup server intercept", __FUNCTION__);
       }
     } else {
-      TSDebug(DEBUG_TAG, "[%s] Not setting up intercept", __FUNCTION__);
+      Dbg(dbg_ctl_local, "[%s] Not setting up intercept", __FUNCTION__);
     }
     break;
 
@@ -1522,7 +1495,7 @@ globalHookHandler(TSCont contp, TSEvent event, void *edata)
     if (!intercept_req) {
       if (event == TS_EVENT_HTTP_READ_RESPONSE_HDR) {
         bool mask_cache_headers = false;
-        TSDebug(DEBUG_TAG, "[%s] handling read response header event", __FUNCTION__);
+        Dbg(dbg_ctl_local, "[%s] handling read response header event", __FUNCTION__);
         if (isTxnTransformable(txnp, false, &intercept_header, &head_only)) {
           addTransform(txnp, true, intercept_header, head_only, pOptionInfo);
           Stats::increment(Stats::N_OS_DOCS);
@@ -1535,7 +1508,7 @@ globalHookHandler(TSCont contp, TSEvent event, void *edata)
           maskOsCacheHeaders(txnp);
         }
       } else {
-        TSDebug(DEBUG_TAG, "[%s] handling cache lookup complete event", __FUNCTION__);
+        Dbg(dbg_ctl_local, "[%s] handling cache lookup complete event", __FUNCTION__);
         if (isCacheObjTransformable(txnp, &intercept_header, &head_only)) {
           // we make the assumption above that a transformable cache
           // object would already have a transformation. We should revisit
@@ -1548,7 +1521,7 @@ globalHookHandler(TSCont contp, TSEvent event, void *edata)
     break;
 
   default:
-    TSDebug(DEBUG_TAG, "[%s] Don't know how to handle event type %d", __FUNCTION__, event);
+    Dbg(dbg_ctl_local, "[%s] Don't know how to handle event type %d", __FUNCTION__, event);
     break;
   }
 
@@ -1568,7 +1541,7 @@ loadHandlerConf(const char *file_name, Utils::KeyValueMap &handler_conf)
     }
     TSfclose(conf_file);
     Utils::parseKeyValueConfig(conf_lines, handler_conf, gAllowlistCookies);
-    TSDebug(DEBUG_TAG, "[%s] Loaded handler conf file [%s]", __FUNCTION__, file_name);
+    Dbg(dbg_ctl_local, "[%s] Loaded handler conf file [%s]", __FUNCTION__, file_name);
   } else {
     TSError("[esi][%s] Failed to open handler config file [%s]", __FUNCTION__, file_name);
   }
@@ -1581,12 +1554,11 @@ esiPluginInit(int argc, const char *argv[], struct OptionInfo *pOptionInfo)
 
   if (statSystem == nullptr) {
     statSystem = new TSStatSystem();
-    Utils::init(&TSDebug, &TSError);
     Stats::init(statSystem);
   }
 
   if (gHandlerManager == nullptr) {
-    gHandlerManager = new HandlerManager(HANDLER_MGR_DEBUG_TAG, &TSDebug, &TSError);
+    gHandlerManager = new HandlerManager();
   }
 
   memset(pOptionInfo, 0, sizeof(struct OptionInfo));
@@ -1629,12 +1601,12 @@ esiPluginInit(int argc, const char *argv[], struct OptionInfo *pOptionInfo)
     }
   }
 
-  TSDebug(DEBUG_TAG,
-          "[%s] Plugin started, "
-          "packed-node-support: %d, private-response: %d, "
-          "disable-gzip-output: %d, first-byte-flush: %d ",
-          __FUNCTION__, pOptionInfo->packed_node_support, pOptionInfo->private_response, pOptionInfo->disable_gzip_output,
-          pOptionInfo->first_byte_flush);
+  Dbg(dbg_ctl_local,
+      "[%s] Plugin started, "
+      "packed-node-support: %d, private-response: %d, "
+      "disable-gzip-output: %d, first-byte-flush: %d ",
+      __FUNCTION__, pOptionInfo->packed_node_support, pOptionInfo->private_response, pOptionInfo->disable_gzip_output,
+      pOptionInfo->first_byte_flush);
 
   return 0;
 }
@@ -1693,7 +1665,7 @@ TSRemapInit(TSRemapInterface *api_info, char *errbuf, int errbuf_size)
     return TS_ERROR;
   }
 
-  TSDebug(DEBUG_TAG, "esi remap plugin is successfully initialized");
+  Dbg(dbg_ctl_local, "esi remap plugin is successfully initialized");
   return TS_SUCCESS;
 }
 
@@ -1760,10 +1732,10 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo * /* rri ATS_UNUSED
       if (!setupServerIntercept(txnp)) {
         TSError("[esi][%s] Could not setup server intercept", __FUNCTION__);
       } else {
-        TSDebug(DEBUG_TAG, "[%s] Setup server intercept", __FUNCTION__);
+        Dbg(dbg_ctl_local, "[%s] Setup server intercept", __FUNCTION__);
       }
     } else {
-      TSDebug(DEBUG_TAG, "[%s] Not setting up intercept", __FUNCTION__);
+      Dbg(dbg_ctl_local, "[%s] Not setting up intercept", __FUNCTION__);
     }
   }
 
diff --git a/plugins/esi/fetcher/HttpDataFetcherImpl.cc b/plugins/esi/fetcher/HttpDataFetcherImpl.cc
index 0f41feb3809..e9eb2438a77 100644
--- a/plugins/esi/fetcher/HttpDataFetcherImpl.cc
+++ b/plugins/esi/fetcher/HttpDataFetcherImpl.cc
@@ -33,6 +33,10 @@ using namespace EsiLib;
 
 const int HttpDataFetcherImpl::FETCH_EVENT_ID_BASE = 10000;
 
+// Can only be used in HttpDataFetcherImpl member functions.
+//
+#define DBG(FMT, ...) Dbg(_dbg_ctl, FMT " address=%p", ##__VA_ARGS__, this)
+
 inline void
 HttpDataFetcherImpl::_release(RequestData &req_data)
 {
@@ -46,11 +50,10 @@ HttpDataFetcherImpl::_release(RequestData &req_data)
   }
 }
 
-HttpDataFetcherImpl::HttpDataFetcherImpl(TSCont contp, sockaddr const *client_addr, const char *debug_tag)
-  : _contp(contp), _n_pending_requests(0), _curr_event_id_base(FETCH_EVENT_ID_BASE), _headers_str("")
+HttpDataFetcherImpl::HttpDataFetcherImpl(TSCont contp, sockaddr const *client_addr, char const *dbg_tag)
+  : _contp(contp), _n_pending_requests(0), _curr_event_id_base(FETCH_EVENT_ID_BASE), _headers_str(""), _dbg_ctl(dbg_tag)
 {
   _http_parser = TSHttpParserCreate();
-  snprintf(_debug_tag, sizeof(_debug_tag), "%s", debug_tag);
   // default client address to use for fetch url
   struct sockaddr_in sin;
   memset(&sin, 0, sizeof(sin));
@@ -87,7 +90,7 @@ HttpDataFetcherImpl::addFetchRequest(const string &url, FetchedDataProcessor *ca
     ((insert_result.first)->second).callback_objects.push_back(callback_obj);
   }
   if (!insert_result.second) {
-    TSDebug(_debug_tag, "[%s] Fetch request for url [%s] already added", __FUNCTION__, url.data());
+    DBG("[%s] Fetch request for url [%s] already added", __FUNCTION__, url.data());
     return true;
   }
 
@@ -122,7 +125,7 @@ HttpDataFetcherImpl::addFetchRequest(const string &url, FetchedDataProcessor *ca
     free(http_req);
   }
 
-  TSDebug(_debug_tag, "[%s] Successfully added fetch request for URL [%s]", __FUNCTION__, url.data());
+  DBG("[%s] Successfully added fetch request for URL [%s]", __FUNCTION__, url.data());
   _page_entry_lookup.push_back(insert_result.first);
   ++_n_pending_requests;
   return true;
@@ -133,8 +136,8 @@ HttpDataFetcherImpl::_isFetchEvent(TSEvent event, int &base_event_id) const
 {
   base_event_id = _getBaseEventId(event);
   if ((base_event_id < 0) || (base_event_id >= static_cast<int>(_page_entry_lookup.size()))) {
-    TSDebug(_debug_tag, "[%s] Event id %d not within fetch event id range [%d, %ld)", __FUNCTION__, event, FETCH_EVENT_ID_BASE,
-            static_cast<long int>(FETCH_EVENT_ID_BASE + (_page_entry_lookup.size() * 3)));
+    DBG("[%s] Event id %d not within fetch event id range [%d, %ld)", __FUNCTION__, event, FETCH_EVENT_ID_BASE,
+        static_cast<long int>(FETCH_EVENT_ID_BASE + (_page_entry_lookup.size() * 3)));
     return false;
   }
   return true;
@@ -186,8 +189,8 @@ HttpDataFetcherImpl::handleFetchEvent(TSEvent event, void *edata)
     if (req_data.resp_status == TS_HTTP_STATUS_OK) {
       req_data.body_len = endptr - startptr;
       req_data.body     = startptr;
-      TSDebug(_debug_tag, "[%s] Inserted page data of size %d starting with [%.6s] for request [%s]", __FUNCTION__,
-              req_data.body_len, (req_data.body_len ? req_data.body : "(null)"), req_str.c_str());
+      DBG("[%s] Inserted page data of size %d starting with [%.6s] for request [%s]", __FUNCTION__, req_data.body_len,
+          (req_data.body_len ? req_data.body : "(null)"), req_str.c_str());
 
       if (_checkHeaderValue(req_data.bufp, req_data.hdr_loc, TS_MIME_FIELD_CONTENT_ENCODING, TS_MIME_LEN_CONTENT_ENCODING,
                             TS_HTTP_VALUE_GZIP, TS_HTTP_LEN_GZIP, false)) {
@@ -210,7 +213,7 @@ HttpDataFetcherImpl::handleFetchEvent(TSEvent event, void *edata)
       }
 
     } else {
-      TSDebug(_debug_tag, "[%s] Received non-OK status %d for request [%s]", __FUNCTION__, req_data.resp_status, req_str.data());
+      DBG("[%s] Received non-OK status %d for request [%s]", __FUNCTION__, req_data.resp_status, req_str.data());
 
       string empty_response = "";
       for (CallbackObjectList::iterator list_iter = req_data.callback_objects.begin(); list_iter != req_data.callback_objects.end();
@@ -219,7 +222,7 @@ HttpDataFetcherImpl::handleFetchEvent(TSEvent event, void *edata)
       }
     }
   } else {
-    TSDebug(_debug_tag, "[%s] Could not parse response for request [%s]", __FUNCTION__, req_str.data());
+    DBG("[%s] Could not parse response for request [%s]", __FUNCTION__, req_str.data());
   }
 
   if (!valid_data_received) {
@@ -257,7 +260,7 @@ HttpDataFetcherImpl::_checkHeaderValue(TSMBuffer bufp, TSMLoc hdr_loc, const cha
           retval = true;
         }
       } else {
-        TSDebug(_debug_tag, "[%s] Error while getting value # %d of header [%.*s]", __FUNCTION__, i, name_len, name);
+        DBG("[%s] Error while getting value # %d of header [%.*s]", __FUNCTION__, i, name_len, name);
       }
       if (retval) {
         break;
@@ -293,8 +296,7 @@ HttpDataFetcherImpl::getData(const string &url, ResponseData &resp_data) const
   }
 
   resp_data.set(req_data.body, req_data.body_len, req_data.bufp, req_data.hdr_loc, req_data.resp_status);
-  TSDebug(_debug_tag, "[%s] Found data for URL [%s] of size %d starting with [%.5s]", __FUNCTION__, url.data(), req_data.body_len,
-          req_data.body);
+  DBG("[%s] Found data for URL [%s] of size %d starting with [%.5s]", __FUNCTION__, url.data(), req_data.body_len, req_data.body);
   return true;
 }
 
diff --git a/plugins/esi/fetcher/HttpDataFetcherImpl.h b/plugins/esi/fetcher/HttpDataFetcherImpl.h
index d29b1d47c58..47456acb082 100644
--- a/plugins/esi/fetcher/HttpDataFetcherImpl.h
+++ b/plugins/esi/fetcher/HttpDataFetcherImpl.h
@@ -36,7 +36,7 @@
 class HttpDataFetcherImpl : public HttpDataFetcher
 {
 public:
-  HttpDataFetcherImpl(TSCont contp, sockaddr const *client_addr, const char *debug_tag);
+  HttpDataFetcherImpl(TSCont contp, sockaddr const *client_addr, char const *dbg_tag);
 
   void useHeader(const EsiLib::HttpHeader &header);
 
@@ -103,7 +103,6 @@ class HttpDataFetcherImpl : public HttpDataFetcher
 
 private:
   TSCont _contp;
-  char _debug_tag[64];
 
   using CallbackObjectList = std::list<FetchedDataProcessor *>;
 
@@ -149,6 +148,8 @@ class HttpDataFetcherImpl : public HttpDataFetcher
   inline void _release(RequestData &req_data);
 
   struct sockaddr_storage _client_addr;
+
+  DbgCtl _dbg_ctl;
 };
 
 inline void
diff --git a/plugins/esi/lib/EsiGunzip.cc b/plugins/esi/lib/EsiGunzip.cc
index 3b24fdcef75..af8dcf89321 100644
--- a/plugins/esi/lib/EsiGunzip.cc
+++ b/plugins/esi/lib/EsiGunzip.cc
@@ -23,14 +23,14 @@
 
 #include "EsiGunzip.h"
 #include "gzip.h"
+#include <ts/ts.h>
 #include <cctype>
 #include <cstdint>
 
 using std::string;
 using namespace EsiLib;
 
-EsiGunzip::EsiGunzip(const char *debug_tag, ComponentBase::Debug debug_func, ComponentBase::Error error_func)
-  : ComponentBase(debug_tag, debug_func, error_func), _downstream_length(0), _total_data_length(0)
+EsiGunzip::EsiGunzip() : _downstream_length(0), _total_data_length(0)
 {
   _init    = false;
   _success = true;
@@ -44,7 +44,7 @@ EsiGunzip::stream_finish()
 {
   if (_init) {
     if (inflateEnd(&_zstrm) != Z_OK) {
-      _errorLog("[%s] inflateEnd failed!", __FUNCTION__);
+      TSError("[%s] inflateEnd failed!", __FUNCTION__);
       _success = false;
     }
     _init = false;
@@ -66,7 +66,7 @@ EsiGunzip::stream_decode(const char *data, int data_len, std::string &udata)
     _zstrm.avail_in = 0;
 
     if (inflateInit2(&_zstrm, MAX_WBITS + 16) != Z_OK) {
-      _errorLog("[%s] inflateInit2 failed!", __FUNCTION__);
+      TSError("[%s] inflateInit2 failed!", __FUNCTION__);
       _success = false;
       return false;
     }
@@ -91,11 +91,11 @@ EsiGunzip::stream_decode(const char *data, int data_len, std::string &udata)
         curr_buf_size = BUF_SIZE - _zstrm.avail_out;
       }
       if (curr_buf_size > BUF_SIZE) {
-        _errorLog("[%s] buf too large", __FUNCTION__);
+        TSError("[%s] buf too large", __FUNCTION__);
         break;
       }
       if (curr_buf_size < 1) {
-        _errorLog("[%s] buf below zero", __FUNCTION__);
+        TSError("[%s] buf below zero", __FUNCTION__);
         break;
       }
 
diff --git a/plugins/esi/lib/EsiGunzip.h b/plugins/esi/lib/EsiGunzip.h
index f1b8498a5cd..9733cfe1ded 100644
--- a/plugins/esi/lib/EsiGunzip.h
+++ b/plugins/esi/lib/EsiGunzip.h
@@ -23,17 +23,15 @@
 
 #pragma once
 
-#include "ComponentBase.h"
-
 #include <zlib.h>
 #include <string>
 
-class EsiGunzip : private EsiLib::ComponentBase
+class EsiGunzip
 {
 public:
-  EsiGunzip(const char *debug_tag, EsiLib::ComponentBase::Debug debug_func, EsiLib::ComponentBase::Error error_func);
+  EsiGunzip();
 
-  ~EsiGunzip() override;
+  ~EsiGunzip();
 
   bool stream_decode(const char *data, int data_len, std::string &udata);
 
diff --git a/plugins/esi/lib/EsiGzip.cc b/plugins/esi/lib/EsiGzip.cc
index ac095a6d323..9d6241da610 100644
--- a/plugins/esi/lib/EsiGzip.cc
+++ b/plugins/esi/lib/EsiGzip.cc
@@ -23,14 +23,14 @@
 
 #include "EsiGzip.h"
 #include "gzip.h"
+#include <ts/ts.h>
 #include <cctype>
 #include <cstdint>
 
 using std::string;
 using namespace EsiLib;
 
-EsiGzip::EsiGzip(const char *debug_tag, ComponentBase::Debug debug_func, ComponentBase::Error error_func)
-  : ComponentBase(debug_tag, debug_func, error_func), _downstream_length(0), _total_data_length(0), _crc(0)
+EsiGzip::EsiGzip() : _downstream_length(0), _total_data_length(0), _crc(0)
 {
   // Zlib _zstrm variables are initialized when they are required in runDeflateLoop
   // coverity[uninit_member]
@@ -86,7 +86,7 @@ EsiGzip::stream_encode(const char *data, int data_len, std::string &cdata)
   _zstrm.zfree  = Z_NULL;
   _zstrm.opaque = Z_NULL;
   if (deflateInit2(&_zstrm, COMPRESSION_LEVEL, Z_DEFLATED, -MAX_WBITS, ZLIB_MEM_LEVEL, Z_DEFAULT_STRATEGY) != Z_OK) {
-    _errorLog("[%s] deflateInit2 failed!", __FUNCTION__);
+    TSError("[%s] deflateInit2 failed!", __FUNCTION__);
     return false;
   }
 
@@ -96,7 +96,7 @@ EsiGzip::stream_encode(const char *data, int data_len, std::string &cdata)
     _zstrm.avail_in = data_len;
     deflate_result  = runDeflateLoop(_zstrm, Z_FULL_FLUSH, cdata);
     if (deflate_result != Z_OK) {
-      _errorLog("[%s] runDeflateLoop failed!", __FUNCTION__);
+      TSError("[%s] runDeflateLoop failed!", __FUNCTION__);
 
       deflateEnd(&_zstrm);
 
@@ -131,7 +131,7 @@ EsiGzip::stream_finish(std::string &cdata, int &downstream_length)
   _zstrm.zfree  = Z_NULL;
   _zstrm.opaque = Z_NULL;
   if (deflateInit2(&_zstrm, COMPRESSION_LEVEL, Z_DEFLATED, -MAX_WBITS, ZLIB_MEM_LEVEL, Z_DEFAULT_STRATEGY) != Z_OK) {
-    _errorLog("[%s] deflateInit2 failed!", __FUNCTION__);
+    TSError("[%s] deflateInit2 failed!", __FUNCTION__);
     return false;
   }
 
@@ -141,7 +141,7 @@ EsiGzip::stream_finish(std::string &cdata, int &downstream_length)
   int deflate_result = runDeflateLoop(_zstrm, Z_FINISH, cdata);
   deflateEnd(&_zstrm);
   if (deflate_result != Z_STREAM_END) {
-    _errorLog("[%s] deflateEnd failed!", __FUNCTION__);
+    TSError("[%s] deflateEnd failed!", __FUNCTION__);
     downstream_length = 0;
     return false;
   }
diff --git a/plugins/esi/lib/EsiGzip.h b/plugins/esi/lib/EsiGzip.h
index d6f68698617..bab4d95a220 100644
--- a/plugins/esi/lib/EsiGzip.h
+++ b/plugins/esi/lib/EsiGzip.h
@@ -23,17 +23,16 @@
 
 #pragma once
 
-#include "ComponentBase.h"
 #include <zlib.h>
 #include <string>
 #include <string_view>
 
-class EsiGzip : private EsiLib::ComponentBase
+class EsiGzip
 {
 public:
-  EsiGzip(const char *debug_tag, EsiLib::ComponentBase::Debug debug_func, EsiLib::ComponentBase::Error error_func);
+  EsiGzip();
 
-  ~EsiGzip() override;
+  ~EsiGzip();
 
   /** Compress the provided content.
    *
diff --git a/plugins/esi/lib/EsiParser.cc b/plugins/esi/lib/EsiParser.cc
index 3b07e1ae55a..6b897d944f2 100644
--- a/plugins/esi/lib/EsiParser.cc
+++ b/plugins/esi/lib/EsiParser.cc
@@ -24,11 +24,18 @@
 #include "EsiParser.h"
 #include "Utils.h"
 
+#include <ts/ts.h>
+
 #include <cctype>
 
 using std::string;
 using namespace EsiLib;
 
+namespace
+{
+DbgCtl dbg_ctl{"plugin_esi_parser"};
+}
+
 const char *EsiParser::ESI_TAG_PREFIX   = "<esi:";
 const int EsiParser::ESI_TAG_PREFIX_LEN = 5;
 
@@ -55,8 +62,7 @@ const EsiParser::EsiNodeInfo EsiParser::ESI_NODES[] = {
 
 const EsiParser::EsiNodeInfo EsiParser::HTML_COMMENT_NODE_INFO(DocNode::TYPE_HTML_COMMENT, "<!--esi", 7, "-->", 3);
 
-EsiParser::EsiParser(const char *debug_tag, ComponentBase::Debug debug_func, ComponentBase::Error error_func)
-  : ComponentBase(debug_tag, debug_func, error_func), _parse_start_pos(-1)
+EsiParser::EsiParser() : _parse_start_pos(-1)
 {
   // do this so that object doesn't move around in memory;
   // (because we return pointers into this object)
@@ -69,14 +75,14 @@ EsiParser::_setup(string &data, int &parse_start_pos, size_t &orig_output_list_s
 {
   bool retval = true;
   if (!data_ptr || !data_len) {
-    _debugLog(_debug_tag, "[%s] Returning true for empty data", __FUNCTION__);
+    Dbg(dbg_ctl, "[%s] Returning true for empty data", __FUNCTION__);
   } else {
     if (data_len == -1) {
       data_len = strlen(data_ptr);
     }
     if ((data.size() + data_len) > MAX_DOC_SIZE) {
-      _errorLog("[%s] Cannot allow attempted doc of size %d; Max allowed size is %d", __FUNCTION__, data.size() + data_len,
-                MAX_DOC_SIZE);
+      TSError("[%s] Cannot allow attempted doc of size %d; Max allowed size is %d", __FUNCTION__, int(data.size() + data_len),
+              MAX_DOC_SIZE);
       retval = false;
     } else {
       data.append(data_ptr, data_len);
@@ -96,8 +102,7 @@ EsiParser::parseChunk(const char *data, DocNodeList &node_list, int data_len /*
     return false;
   }
   if (!_parse(_data, _parse_start_pos, node_list)) {
-    _errorLog("[%s] Failed to parse chunk of size %d starting with [%.5s]...", __FUNCTION__, data_len,
-              (data_len ? data : "(null)"));
+    TSError("[%s] Failed to parse chunk of size %d starting with [%.5s]...", __FUNCTION__, data_len, (data_len ? data : "(null)"));
     return false;
   }
   return true;
@@ -111,12 +116,12 @@ EsiParser::_completeParse(string &data, int &parse_start_pos, size_t &orig_outpu
     return false;
   }
   if (!data.size()) {
-    _debugLog(_debug_tag, "[%s] No data to parse!", __FUNCTION__);
+    Dbg(dbg_ctl, "[%s] No data to parse!", __FUNCTION__);
     return true;
   }
   if (!_parse(data, parse_start_pos, node_list, true)) {
-    _errorLog("[%s] Failed to complete parse of data of total size %d starting with [%.5s]...", __FUNCTION__, data.size(),
-              (data.size() ? data.data() : "(null)"));
+    TSError("[%s] Failed to complete parse of data of total size %d starting with [%.5s]...", __FUNCTION__, int(data.size()),
+            (data.size() ? data.data() : "(null)"));
     node_list.resize(orig_output_list_size);
     return false;
   }
@@ -145,15 +150,14 @@ EsiParser::_searchData(const string &data, size_t start_pos, const char *str, in
 
   if (i_str == str_len) {
     pos = start_pos + i_data + 1 - i_str;
-    _debugLog(_debug_tag, "[%s] Found full match of %.*s in [%.5s...] at position %d", __FUNCTION__, str_len, str, data_ptr, pos);
+    Dbg(dbg_ctl, "[%s] Found full match of %.*s in [%.5s...] at position %d", __FUNCTION__, str_len, str, data_ptr, int(pos));
     return COMPLETE_MATCH;
   } else if (i_str) {
     pos = start_pos + i_data - i_str;
-    _debugLog(_debug_tag, "[%s] Found partial match of %.*s in [%.5s...] at position %d", __FUNCTION__, str_len, str, data_ptr,
-              pos);
+    Dbg(dbg_ctl, "[%s] Found partial match of %.*s in [%.5s...] at position %d", __FUNCTION__, str_len, str, data_ptr, int(pos));
     return PARTIAL_MATCH;
   } else {
-    _debugLog(_debug_tag, "[%s] Found no match of %.*s in [%.5s...]", __FUNCTION__, str_len, str, data_ptr);
+    Dbg(dbg_ctl, "[%s] Found no match of %.*s in [%.5s...]", __FUNCTION__, str_len, str, data_ptr);
     return NO_MATCH;
   }
 }
@@ -167,14 +171,14 @@ EsiParser::_compareData(const string &data, size_t pos, const char *str, int str
     if (data[i_data] == str[i_str]) {
       ++i_str;
       if (i_str == str_len) {
-        _debugLog(_debug_tag, "[%s] string [%.*s] is equal to data at position %d", __FUNCTION__, str_len, str, pos);
+        Dbg(dbg_ctl, "[%s] string [%.*s] is equal to data at position %d", __FUNCTION__, str_len, str, int(pos));
         return COMPLETE_MATCH;
       }
     } else {
       return NO_MATCH;
     }
   }
-  _debugLog(_debug_tag, "[%s] string [%.*s] is partially equal to data at position %d", __FUNCTION__, str_len, str, pos);
+  Dbg(dbg_ctl, "[%s] string [%.*s] is partially equal to data at position %d", __FUNCTION__, str_len, str, int(pos));
   return PARTIAL_MATCH;
 }
 
@@ -249,7 +253,7 @@ EsiParser::_processSimpleContentTag(DocNode::TYPE node_type, const char *data, i
 {
   DocNode new_node(node_type);
   if (!parse(new_node.child_nodes, data, data_len)) {
-    _errorLog("[%s] Could not parse simple content of [%s] node", __FUNCTION__, DocNode::type_names_[node_type]);
+    TSError("[%s] Could not parse simple content of [%s] node", __FUNCTION__, DocNode::type_names_[node_type]);
     return false;
   }
   node_list.push_back(new_node);
@@ -287,14 +291,14 @@ EsiParser::_parse(const string &data, int &parse_start_pos, DocNodeList &node_li
     // we have a complete match of the opening tag
     if ((curr_pos - parse_start_pos) > 0) {
       // add text till here as a PRE node
-      _debugLog(_debug_tag, "[%s], Adding data of size %d before (newly found) ESI tag as PRE node", __FUNCTION__,
-                curr_pos - parse_start_pos);
+      Dbg(dbg_ctl, "[%s], Adding data of size %d before (newly found) ESI tag as PRE node", __FUNCTION__,
+          int(curr_pos - parse_start_pos));
       node_list.push_back(DocNode(DocNode::TYPE_PRE, data_start_ptr + parse_start_pos, curr_pos - parse_start_pos));
       parse_start_pos = curr_pos;
     }
 
     if (is_html_comment_node) {
-      _debugLog(_debug_tag, "[%s] Found html comment tag at position %d", __FUNCTION__, curr_pos);
+      Dbg(dbg_ctl, "[%s] Found html comment tag at position %d", __FUNCTION__, int(curr_pos));
       node_info = &HTML_COMMENT_NODE_INFO;
       ++curr_pos;
     } else {
@@ -304,20 +308,20 @@ EsiParser::_parse(const string &data, int &parse_start_pos, DocNodeList &node_li
         search_result = _compareData(data, curr_pos, node_info->tag_suffix, node_info->tag_suffix_len);
         if (search_result == COMPLETE_MATCH) {
           if (node_info->tag_suffix[node_info->tag_suffix_len - 1] == '>') {
-            _debugLog(_debug_tag, "[%s] Found [%s] tag at position %d", __FUNCTION__, DocNode::type_names_[node_info->type],
-                      curr_pos - ESI_TAG_PREFIX_LEN);
+            Dbg(dbg_ctl, "[%s] Found [%s] tag at position %d", __FUNCTION__, DocNode::type_names_[node_info->type],
+                int(curr_pos - ESI_TAG_PREFIX_LEN));
             break;
           } else {
             if (curr_pos + node_info->tag_suffix_len < data_size) {
               char ch = data_start_ptr[curr_pos + node_info->tag_suffix_len];
               if (ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n') {
-                _debugLog(_debug_tag, "[%s] Found [%s] tag at position %d", __FUNCTION__, DocNode::type_names_[node_info->type],
-                          curr_pos - ESI_TAG_PREFIX_LEN);
+                Dbg(dbg_ctl, "[%s] Found [%s] tag at position %d", __FUNCTION__, DocNode::type_names_[node_info->type],
+                    int(curr_pos - ESI_TAG_PREFIX_LEN));
                 ++curr_pos; // skip the space char
                 break;
               } else if (ch == '/' || ch == '>') {
-                _debugLog(_debug_tag, "[%s] Found [%s] tag at position %d", __FUNCTION__, DocNode::type_names_[node_info->type],
-                          curr_pos - ESI_TAG_PREFIX_LEN);
+                Dbg(dbg_ctl, "[%s] Found [%s] tag at position %d", __FUNCTION__, DocNode::type_names_[node_info->type],
+                    int(curr_pos - ESI_TAG_PREFIX_LEN));
                 break;
               }
             } else {
@@ -329,7 +333,7 @@ EsiParser::_parse(const string &data, int &parse_start_pos, DocNodeList &node_li
         }
       }
       if (node_info->type == DocNode::TYPE_UNKNOWN) {
-        _errorLog("[%s] Unknown ESI tag starting with [%10s]...", __FUNCTION__, data.c_str());
+        TSError("[%s] Unknown ESI tag starting with [%10s]...", __FUNCTION__, data.c_str());
         goto lFail;
       }
     }
@@ -339,8 +343,8 @@ EsiParser::_parse(const string &data, int &parse_start_pos, DocNodeList &node_li
 
     if ((search_result == NO_MATCH) || (search_result == PARTIAL_MATCH)) {
       if (last_chunk) {
-        _errorLog("[%s] ESI tag starting with [%10s]... has no matching closing tag [%.*s]", __FUNCTION__, data.c_str(),
-                  node_info->closing_tag_len, node_info->closing_tag);
+        TSError("[%s] ESI tag starting with [%10s]... has no matching closing tag [%.*s]", __FUNCTION__, data.c_str(),
+                node_info->closing_tag_len, node_info->closing_tag);
         goto lFail;
       } else {
         goto lPartialMatch;
@@ -350,42 +354,42 @@ EsiParser::_parse(const string &data, int &parse_start_pos, DocNodeList &node_li
     // now we process only complete nodes
     switch (node_info->type) {
     case DocNode::TYPE_INCLUDE:
-      _debugLog(_debug_tag, "[%s] Handling include tag...", __FUNCTION__);
+      Dbg(dbg_ctl, "[%s] Handling include tag...", __FUNCTION__);
       parse_result = _processIncludeTag(data, curr_pos, end_pos, node_list);
       break;
     case DocNode::TYPE_COMMENT:
     case DocNode::TYPE_REMOVE:
-      _debugLog(_debug_tag, "[%s] Adding node [%s]", __FUNCTION__, DocNode::type_names_[node_info->type]);
+      Dbg(dbg_ctl, "[%s] Adding node [%s]", __FUNCTION__, DocNode::type_names_[node_info->type]);
       node_list.push_back(DocNode(node_info->type)); // no data required
       parse_result = true;
       break;
     case DocNode::TYPE_WHEN:
-      _debugLog(_debug_tag, "[%s] Handling when tag...", __FUNCTION__);
+      Dbg(dbg_ctl, "[%s] Handling when tag...", __FUNCTION__);
       parse_result = _processWhenTag(data, curr_pos, end_pos, node_list);
       break;
     case DocNode::TYPE_TRY:
-      _debugLog(_debug_tag, "[%s] Handling try tag...", __FUNCTION__);
+      Dbg(dbg_ctl, "[%s] Handling try tag...", __FUNCTION__);
       parse_result = _processTryTag(data, curr_pos, end_pos, node_list);
       break;
     case DocNode::TYPE_CHOOSE:
-      _debugLog(_debug_tag, "[%s] Handling choose tag...", __FUNCTION__);
+      Dbg(dbg_ctl, "[%s] Handling choose tag...", __FUNCTION__);
       parse_result = _processChooseTag(data, curr_pos, end_pos, node_list);
       break;
     case DocNode::TYPE_OTHERWISE:
     case DocNode::TYPE_ATTEMPT:
     case DocNode::TYPE_EXCEPT:
-      _debugLog(_debug_tag, "[%s] Handling %s tag...", __FUNCTION__, DocNode::type_names_[node_info->type]);
+      Dbg(dbg_ctl, "[%s] Handling %s tag...", __FUNCTION__, DocNode::type_names_[node_info->type]);
       parse_result = _processSimpleContentTag(node_info->type, data.data() + curr_pos, end_pos - curr_pos, node_list);
       break;
     case DocNode::TYPE_VARS:
     case DocNode::TYPE_HTML_COMMENT:
-      _debugLog(_debug_tag, "[%s] added string of size %d starting with [%.5s] for node %s", __FUNCTION__, end_pos - curr_pos,
-                data.data() + curr_pos, DocNode::type_names_[node_info->type]);
+      Dbg(dbg_ctl, "[%s] added string of size %d starting with [%.5s] for node %s", __FUNCTION__, int(end_pos - curr_pos),
+          data.data() + curr_pos, DocNode::type_names_[node_info->type]);
       node_list.push_back(DocNode(node_info->type, data.data() + curr_pos, end_pos - curr_pos));
       parse_result = true;
       break;
     case DocNode::TYPE_SPECIAL_INCLUDE:
-      _debugLog(_debug_tag, "[%s] Handling special include tag...", __FUNCTION__);
+      Dbg(dbg_ctl, "[%s] Handling special include tag...", __FUNCTION__);
       parse_result = _processSpecialIncludeTag(data, curr_pos, end_pos, node_list);
       break;
     default:
@@ -394,7 +398,7 @@ EsiParser::_parse(const string &data, int &parse_start_pos, DocNodeList &node_li
     }
 
     if (!parse_result) {
-      _errorLog("[%s] Cannot handle ESI tag [%.*s]", __FUNCTION__, node_info->tag_suffix_len, node_info->tag_suffix);
+      TSError("[%s] Cannot handle ESI tag [%.*s]", __FUNCTION__, node_info->tag_suffix_len, node_info->tag_suffix);
       goto lFail;
     }
 
@@ -403,18 +407,18 @@ EsiParser::_parse(const string &data, int &parse_start_pos, DocNodeList &node_li
 
   lPartialMatch:
     if (last_chunk) {
-      _debugLog(_debug_tag, "[%s] Found a partial ESI tag - will be treated as PRE text", __FUNCTION__);
+      Dbg(dbg_ctl, "[%s] Found a partial ESI tag - will be treated as PRE text", __FUNCTION__);
     } else {
-      _debugLog(_debug_tag, "[%s] Deferring to next chunk to find complete tag", __FUNCTION__);
+      Dbg(dbg_ctl, "[%s] Deferring to next chunk to find complete tag", __FUNCTION__);
     }
     break;
   }
   if (last_chunk && (parse_start_pos < static_cast<int>(data_size))) {
-    _debugLog(_debug_tag, "[%s] Adding trailing text of size %d starting at [%.5s] as a PRE node", __FUNCTION__,
-              data_size - parse_start_pos, data_start_ptr + parse_start_pos);
+    Dbg(dbg_ctl, "[%s] Adding trailing text of size %d starting at [%.5s] as a PRE node", __FUNCTION__,
+        int(data_size - parse_start_pos), data_start_ptr + parse_start_pos);
     node_list.push_back(DocNode(DocNode::TYPE_PRE, data_start_ptr + parse_start_pos, data_size - parse_start_pos));
   }
-  _debugLog(_debug_tag, "[%s] Added %d node(s) during parse", __FUNCTION__, node_list.size() - orig_list_size);
+  Dbg(dbg_ctl, "[%s] Added %d node(s) during parse", __FUNCTION__, int(node_list.size() - orig_list_size));
   return true;
 
 lFail:
@@ -427,12 +431,12 @@ EsiParser::_processIncludeTag(const string &data, size_t curr_pos, size_t end_po
 {
   Attribute src_info;
   if (!Utils::getAttribute(data, SRC_ATTR_STR, curr_pos, end_pos, src_info)) {
-    _errorLog("[%s] Could not find src attribute", __FUNCTION__);
+    TSError("[%s] Could not find src attribute", __FUNCTION__);
     return false;
   }
   node_list.push_back(DocNode(DocNode::TYPE_INCLUDE));
   node_list.back().attr_list.push_back(src_info);
-  _debugLog(_debug_tag, "[%s] Added include tag with url [%.*s]", __FUNCTION__, src_info.value_len, src_info.value);
+  Dbg(dbg_ctl, "[%s] Added include tag with url [%.*s]", __FUNCTION__, src_info.value_len, src_info.value);
   return true;
 }
 
@@ -441,7 +445,7 @@ EsiParser::_processSpecialIncludeTag(const string &data, size_t curr_pos, size_t
 {
   Attribute handler_info;
   if (!Utils::getAttribute(data, HANDLER_ATTR_STR, curr_pos, end_pos, handler_info)) {
-    _errorLog("[%s] Could not find handler attribute", __FUNCTION__);
+    TSError("[%s] Could not find handler attribute", __FUNCTION__);
     return false;
   }
   node_list.push_back(DocNode(DocNode::TYPE_SPECIAL_INCLUDE));
@@ -449,8 +453,8 @@ EsiParser::_processSpecialIncludeTag(const string &data, size_t curr_pos, size_t
   node.attr_list.push_back(handler_info);
   node.data     = data.data() + curr_pos;
   node.data_len = end_pos - curr_pos;
-  _debugLog(_debug_tag, "[%s] Added special include tag with handler [%.*s] and data [%.*s]", __FUNCTION__, handler_info.value_len,
-            handler_info.value, node.data_len, node.data);
+  Dbg(dbg_ctl, "[%s] Added special include tag with handler [%.*s] and data [%.*s]", __FUNCTION__, handler_info.value_len,
+      handler_info.value, node.data_len, node.data);
   return true;
 }
 
@@ -471,19 +475,19 @@ EsiParser::_processWhenTag(const string &data, size_t curr_pos, size_t end_pos,
   Attribute test_expr;
   size_t term_pos;
   if (!Utils::getAttribute(data, TEST_ATTR_STR, curr_pos, end_pos, test_expr, &term_pos, '>')) {
-    _errorLog("[%s] Could not find test attribute", __FUNCTION__);
+    TSError("[%s] Could not find test attribute", __FUNCTION__);
     return false;
   }
   ++term_pos; // go past the terminator
   const char *data_start_ptr = data.data() + term_pos;
   int data_size              = end_pos - term_pos;
   if (!_processSimpleContentTag(DocNode::TYPE_WHEN, data_start_ptr, data_size, node_list)) {
-    _errorLog("[%s] Could not parse when node's content", __FUNCTION__);
+    TSError("[%s] Could not parse when node's content", __FUNCTION__);
     return false;
   }
   node_list.back().attr_list.push_back(test_expr);
-  _debugLog(_debug_tag, "[%s] Added when tag with expression [%.*s] and data starting with [%.5s]", __FUNCTION__,
-            test_expr.value_len, test_expr.value, data_start_ptr);
+  Dbg(dbg_ctl, "[%s] Added when tag with expression [%.*s] and data starting with [%.5s]", __FUNCTION__, test_expr.value_len,
+      test_expr.value, data_start_ptr);
   return true;
 }
 
@@ -494,7 +498,7 @@ EsiParser::_processTryTag(const string &data, size_t curr_pos, size_t end_pos, D
   int data_size              = end_pos - curr_pos;
   DocNode try_node(DocNode::TYPE_TRY);
   if (!parse(try_node.child_nodes, data_start_ptr, data_size)) {
-    _errorLog("[%s] Could not parse try node's content", __FUNCTION__);
+    TSError("[%s] Could not parse try node's content", __FUNCTION__);
     return false;
   }
 
@@ -505,40 +509,40 @@ EsiParser::_processTryTag(const string &data, size_t curr_pos, size_t end_pos, D
   while (iter != end_node) {
     if (iter->type == DocNode::TYPE_ATTEMPT) {
       if (attempt_node != end_node) {
-        _errorLog("[%s] Can have exactly one attempt node in try block", __FUNCTION__);
+        TSError("[%s] Can have exactly one attempt node in try block", __FUNCTION__);
         return false;
       }
       attempt_node = iter;
     } else if (iter->type == DocNode::TYPE_EXCEPT) {
       if (except_node != end_node) {
-        _errorLog("[%s] Can have exactly one except node in try block", __FUNCTION__);
+        TSError("[%s] Can have exactly one except node in try block", __FUNCTION__);
         return false;
       }
       except_node = iter;
     } else if (iter->type == DocNode::TYPE_PRE) {
       if (!_isWhitespace(iter->data, iter->data_len)) {
-        _errorLog("[%s] Cannot have non-whitespace raw text as top level node in try block", __FUNCTION__);
+        TSError("[%s] Cannot have non-whitespace raw text as top level node in try block", __FUNCTION__);
         return false;
       }
-      _debugLog(_debug_tag, "[%s] Ignoring top-level whitespace raw text", __FUNCTION__);
+      Dbg(dbg_ctl, "[%s] Ignoring top-level whitespace raw text", __FUNCTION__);
       temp_iter = iter;
       ++temp_iter;
       try_node.child_nodes.erase(iter);
       iter = temp_iter;
       continue; // skip the increment
     } else {
-      _errorLog("[%s] Only attempt/except/text nodes allowed in try block; [%s] node invalid", __FUNCTION__,
-                DocNode::type_names_[iter->type]);
+      TSError("[%s] Only attempt/except/text nodes allowed in try block; [%s] node invalid", __FUNCTION__,
+              DocNode::type_names_[iter->type]);
       return false;
     }
     ++iter;
   }
   if ((attempt_node == end_node) || (except_node == end_node)) {
-    _errorLog("[%s] try block must contain one each of attempt and except nodes", __FUNCTION__);
+    TSError("[%s] try block must contain one each of attempt and except nodes", __FUNCTION__);
     return false;
   }
   node_list.push_back(try_node);
-  _debugLog(_debug_tag, "[%s] Added try node successfully", __FUNCTION__);
+  Dbg(dbg_ctl, "[%s] Added try node successfully", __FUNCTION__);
   return true;
 }
 
@@ -549,7 +553,7 @@ EsiParser::_processChooseTag(const string &data, size_t curr_pos, size_t end_pos
   size_t data_size           = end_pos - curr_pos;
   DocNode choose_node(DocNode::TYPE_CHOOSE);
   if (!parse(choose_node.child_nodes, data_start_ptr, data_size)) {
-    _errorLog("[%s] Couldn't parse choose node content", __FUNCTION__);
+    TSError("[%s] Couldn't parse choose node content", __FUNCTION__);
     return false;
   }
   DocNodeList::iterator end_node       = choose_node.child_nodes.end();
@@ -558,26 +562,26 @@ EsiParser::_processChooseTag(const string &data, size_t curr_pos, size_t end_pos
   while (iter != end_node) {
     if (iter->type == DocNode::TYPE_OTHERWISE) {
       if (otherwise_node != end_node) {
-        _errorLog("[%s] Cannot have more than one esi:otherwise node in an esi:choose node", __FUNCTION__);
+        TSError("[%s] Cannot have more than one esi:otherwise node in an esi:choose node", __FUNCTION__);
         return false;
       }
       otherwise_node = iter;
     } else if (iter->type == DocNode::TYPE_PRE) {
       if (!_isWhitespace(iter->data, iter->data_len)) {
-        _errorLog("[%s] Cannot have non-whitespace raw text as top-level node in choose data", __FUNCTION__,
-                  DocNode::type_names_[iter->type]);
+        TSError("[%s] Cannot have non-whitespace raw text (%s) as top-level node in choose data", __FUNCTION__,
+                DocNode::type_names_[iter->type]);
         return false;
       }
-      _debugLog(_debug_tag, "[%s] Ignoring top-level whitespace raw text", __FUNCTION__);
+      Dbg(dbg_ctl, "[%s] Ignoring top-level whitespace raw text", __FUNCTION__);
       temp_iter = iter;
       ++temp_iter;
       choose_node.child_nodes.erase(iter);
       iter = temp_iter;
       continue; // skip the increment
     } else if (iter->type != DocNode::TYPE_WHEN) {
-      _errorLog("[%s] Cannot have %s as top-level node in choose data; only when/otherwise/whitespace-text "
-                "permitted",
-                __FUNCTION__, DocNode::type_names_[iter->type]);
+      TSError("[%s] Cannot have %s as top-level node in choose data; only when/otherwise/whitespace-text "
+              "permitted",
+              __FUNCTION__, DocNode::type_names_[iter->type]);
       return false;
     }
     ++iter;
diff --git a/plugins/esi/lib/EsiParser.h b/plugins/esi/lib/EsiParser.h
index 41a77a9c23d..fdedde7f17e 100644
--- a/plugins/esi/lib/EsiParser.h
+++ b/plugins/esi/lib/EsiParser.h
@@ -25,13 +25,12 @@
 
 #include <string>
 
-#include "ComponentBase.h"
 #include "DocNode.h"
 
-class EsiParser : private EsiLib::ComponentBase
+class EsiParser
 {
 public:
-  EsiParser(const char *debug_tag, EsiLib::ComponentBase::Debug debug_func, EsiLib::ComponentBase::Error error_func);
+  EsiParser();
 
   /** clears state */
   void clear();
diff --git a/plugins/esi/lib/EsiProcessor.cc b/plugins/esi/lib/EsiProcessor.cc
index 265e3eb5226..43cd7b601fa 100644
--- a/plugins/esi/lib/EsiProcessor.cc
+++ b/plugins/esi/lib/EsiProcessor.cc
@@ -23,6 +23,7 @@
 
 #include "EsiProcessor.h"
 #include "Stats.h"
+#include <ts/ts.h>
 #include <cctype>
 
 using std::string;
@@ -32,12 +33,18 @@ const char *EsiProcessor::INCLUDE_DATA_ID_ATTR = reinterpret_cast<const char *>(
 
 #define FAILURE_INFO_TAG "plugin_esi_failureInfo"
 
-EsiProcessor::EsiProcessor(const char *debug_tag, const char *parser_debug_tag, const char *expression_debug_tag,
-                           ComponentBase::Debug debug_func, ComponentBase::Error error_func, HttpDataFetcher &fetcher,
-                           Variables &variables, const HandlerManager &handler_mgr)
-  : ComponentBase(debug_tag, debug_func, error_func),
-    _curr_state(STOPPED),
-    _parser(parser_debug_tag, debug_func, error_func),
+namespace
+{
+DbgCtl dbg_ctl{"plugin_esi_procesor"};
+}
+
+// This can only be used in member functions of EsiProcessor.
+//
+#define DBG(FMT, ...) Dbg(dbg_ctl, FMT " contp=%p", ##__VA_ARGS__, _cont_addr)
+
+EsiProcessor::EsiProcessor(void *cont_addr, HttpDataFetcher &fetcher, Variables &variables, const HandlerManager &handler_mgr)
+  : _curr_state(STOPPED),
+    _parser(),
     _n_prescanned_nodes(0),
     _n_processed_nodes(0),
     _n_processed_try_nodes(0),
@@ -45,9 +52,10 @@ EsiProcessor::EsiProcessor(const char *debug_tag, const char *parser_debug_tag,
     _fetcher(fetcher),
     _usePackedNodeList(false),
     _esi_vars(variables),
-    _expression(expression_debug_tag, debug_func, error_func, _esi_vars),
+    _expression(variables),
     _n_try_blocks_processed(0),
-    _handler_manager(handler_mgr)
+    _handler_manager(handler_mgr),
+    _cont_addr(cont_addr)
 {
 }
 
@@ -55,7 +63,7 @@ bool
 EsiProcessor::start()
 {
   if (_curr_state != STOPPED) {
-    _debugLog(_debug_tag, "[%s] Implicit call to stop()", __FUNCTION__);
+    DBG("[%s] Implicit call to stop()", __FUNCTION__);
     stop();
   }
   _curr_state        = PARSING;
@@ -70,21 +78,21 @@ EsiProcessor::addParseData(const char *data, int data_len)
     return false;
   }
   if (_curr_state == STOPPED) {
-    _debugLog(_debug_tag, "[%s] Implicit call to start()", __FUNCTION__);
+    DBG("[%s] Implicit call to start()", __FUNCTION__);
     start();
   } else if (_curr_state != PARSING) {
-    _debugLog(_debug_tag, "[%s] Can only parse in parse stage", __FUNCTION__);
+    DBG("[%s] Can only parse in parse stage", __FUNCTION__);
     return false;
   }
 
   if (!_parser.parseChunk(data, _node_list, data_len)) {
-    _errorLog("[%s] Failed to parse chunk; Stopping processor...", __FUNCTION__);
+    TSError("[%s] Failed to parse chunk; Stopping processor...", __FUNCTION__);
     error();
     Stats::increment(Stats::N_PARSE_ERRS);
     return false;
   }
   if (!_preprocess(_node_list, _n_prescanned_nodes)) {
-    _errorLog("[%s] Failed to preprocess parsed nodes; Stopping processor...", __FUNCTION__);
+    TSError("[%s] Failed to preprocess parsed nodes; Stopping processor...", __FUNCTION__);
     error();
     return false;
   }
@@ -98,15 +106,15 @@ EsiProcessor::completeParse(const char *data /* = 0 */, int data_len /* = -1 */)
     return false;
   }
   if (_curr_state == STOPPED) {
-    _debugLog(_debug_tag, "[%s] Implicit call to start()", __FUNCTION__);
+    DBG("[%s] Implicit call to start()", __FUNCTION__);
     start();
   } else if (_curr_state != PARSING) {
-    _debugLog(_debug_tag, "[%s] Can only parse in parse stage", __FUNCTION__);
+    DBG("[%s] Can only parse in parse stage", __FUNCTION__);
     return false;
   }
 
   if (!_parser.completeParse(_node_list, data, data_len)) {
-    _errorLog("[%s] Couldn't parse ESI document", __FUNCTION__);
+    TSError("[%s] Couldn't parse ESI document", __FUNCTION__);
     error();
     Stats::increment(Stats::N_PARSE_ERRS);
     return false;
@@ -118,12 +126,12 @@ EsiProcessor::UsePackedNodeResult
 EsiProcessor::usePackedNodeList(const char *data, int data_len)
 {
   if (_curr_state != STOPPED) {
-    _errorLog("[%s] Cannot use packed node list whilst processing other data", __FUNCTION__);
+    TSError("[%s] Cannot use packed node list whilst processing other data", __FUNCTION__);
     return PROCESS_IN_PROGRESS;
   }
   start();
   if (!_node_list.unpack(data, data_len)) {
-    _errorLog("[%s] Could not unpack node list from provided data!", __FUNCTION__);
+    TSError("[%s] Could not unpack node list from provided data!", __FUNCTION__);
     error();
     return UNPACK_FAILURE;
   }
@@ -135,11 +143,11 @@ bool
 EsiProcessor::_handleParseComplete()
 {
   if (_curr_state != PARSING) {
-    _debugLog(_debug_tag, "[%s] Cannot handle parse complete in state %d", __FUNCTION__, _curr_state);
+    DBG("[%s] Cannot handle parse complete in state %d", __FUNCTION__, _curr_state);
     return false;
   }
   if (!_preprocess(_node_list, _n_prescanned_nodes)) {
-    _errorLog("[%s] Failed to preprocess parsed nodes; Stopping processor...", __FUNCTION__);
+    TSError("[%s] Failed to preprocess parsed nodes; Stopping processor...", __FUNCTION__);
     error();
     return false;
   }
@@ -147,7 +155,7 @@ EsiProcessor::_handleParseComplete()
     map_iter->second->handleParseComplete();
   }
 
-  _debugLog(_debug_tag, "[%s] Parsed ESI document with %d nodes", __FUNCTION__, _node_list.size());
+  DBG("[%s] Parsed ESI document with %d nodes", __FUNCTION__, int(_node_list.size()));
   _curr_state = WAITING_TO_PROCESS;
 
   return true;
@@ -156,7 +164,7 @@ EsiProcessor::_handleParseComplete()
 DataStatus
 EsiProcessor::_getIncludeStatus(const DocNode &node)
 {
-  _debugLog(_debug_tag, "[%s] inside getIncludeStatus", __FUNCTION__);
+  DBG("[%s] inside getIncludeStatus", __FUNCTION__);
   if (node.type == DocNode::TYPE_INCLUDE) {
     const Attribute &url = node.attr_list.front();
 
@@ -167,13 +175,12 @@ EsiProcessor::_getIncludeStatus(const DocNode &node)
     string raw_url(url.value, url.value_len);
     StringHash::iterator iter = _include_urls.find(raw_url);
     if (iter == _include_urls.end()) {
-      _errorLog("[%s] Data not requested for URL [%.*s]; no data to include", __FUNCTION__, url.value_len, url.value);
+      TSError("[%s] Data not requested for URL [%.*s]; no data to include", __FUNCTION__, url.value_len, url.value);
       return STATUS_ERROR;
     }
     const string &processed_url = iter->second;
     DataStatus status           = _fetcher.getRequestStatus(processed_url);
-    _debugLog(_debug_tag, "[%s] Got status %d successfully for URL [%.*s]", __FUNCTION__, status, processed_url.size(),
-              processed_url.data());
+    DBG("[%s] Got status %d successfully for URL [%.*s]", __FUNCTION__, status, int(processed_url.size()), processed_url.data());
     return status;
   } else if (node.type == DocNode::TYPE_SPECIAL_INCLUDE) {
     int include_data_id            = 0;
@@ -186,15 +193,15 @@ EsiProcessor::_getIncludeStatus(const DocNode &node)
       }
     }
     if (include_data_id == 0 || handler == nullptr) {
-      _errorLog("[%s] Fail to find the special include data id attribute", __FUNCTION__);
+      TSError("[%s] Fail to find the special include data id attribute", __FUNCTION__);
       return STATUS_ERROR;
     }
     DataStatus status = handler->getIncludeStatus(include_data_id);
-    _debugLog(_debug_tag, "[%s] Successfully got status for special include with id %d", __FUNCTION__, status, include_data_id);
+    DBG("[%s] Successfully got status %d for special include with id %d", __FUNCTION__, int(status), int(include_data_id));
 
     return status;
   }
-  _debugLog(_debug_tag, "[%s] node of type %s", __FUNCTION__, DocNode::type_names_[node.type]);
+  DBG("[%s] node of type %s", __FUNCTION__, DocNode::type_names_[node.type]);
   return STATUS_DATA_AVAILABLE;
 }
 
@@ -217,7 +224,7 @@ EsiProcessor::_getIncludeData(const DocNode &node, const char **content_ptr /* =
     string raw_url(url.value, url.value_len);
     StringHash::iterator iter = _include_urls.find(raw_url);
     if (iter == _include_urls.end()) {
-      _errorLog("[%s] Data not requested for URL [%.*s]; no data to include", __FUNCTION__, url.value_len, url.value);
+      TSError("[%s] Data not requested for URL [%.*s]; no data to include", __FUNCTION__, url.value_len, url.value);
       return false;
     }
     const string &processed_url = iter->second;
@@ -228,11 +235,11 @@ EsiProcessor::_getIncludeData(const DocNode &node, const char **content_ptr /* =
       result = (_fetcher.getRequestStatus(processed_url) == STATUS_DATA_AVAILABLE);
     }
     if (!result) {
-      _errorLog("[%s] Couldn't get content for URL [%.*s]", __FUNCTION__, processed_url.size(), processed_url.data());
+      TSError("[%s] Couldn't get content for URL [%.*s]", __FUNCTION__, int(processed_url.size()), processed_url.data());
       Stats::increment(Stats::N_INCLUDE_ERRS);
       return false;
     }
-    _debugLog(_debug_tag, "[%s] Got content successfully for URL [%.*s]", __FUNCTION__, processed_url.size(), processed_url.data());
+    DBG("[%s] Got content successfully for URL [%.*s]", __FUNCTION__, int(processed_url.size()), processed_url.data());
     return true;
   } else if (node.type == DocNode::TYPE_SPECIAL_INCLUDE) {
     int include_data_id            = 0;
@@ -245,7 +252,7 @@ EsiProcessor::_getIncludeData(const DocNode &node, const char **content_ptr /* =
       }
     }
     if (include_data_id == 0 || handler == nullptr) {
-      _errorLog("[%s] Fail to find the special include data id attribute", __FUNCTION__);
+      TSError("[%s] Fail to find the special include data id attribute", __FUNCTION__);
       Stats::increment(Stats::N_SPCL_INCLUDE_ERRS);
       return false;
     }
@@ -256,14 +263,14 @@ EsiProcessor::_getIncludeData(const DocNode &node, const char **content_ptr /* =
       result = (handler->getIncludeStatus(include_data_id) == STATUS_DATA_AVAILABLE);
     }
     if (!result) {
-      _errorLog("[%s] Couldn't get content for special include with id %d", __FUNCTION__, include_data_id);
+      TSError("[%s] Couldn't get content for special include with id %d", __FUNCTION__, include_data_id);
       Stats::increment(Stats::N_SPCL_INCLUDE_ERRS);
       return false;
     }
-    _debugLog(_debug_tag, "[%s] Successfully got content for special include with id %d", __FUNCTION__, include_data_id);
+    DBG("[%s] Successfully got content for special include with id %d", __FUNCTION__, include_data_id);
     return true;
   }
-  _errorLog("[%s] Cannot get include data for node of type %s", __FUNCTION__, DocNode::type_names_[node.type]);
+  TSError("[%s] Cannot get include data for node of type %s", __FUNCTION__, DocNode::type_names_[node.type]);
   return false;
 }
 
@@ -274,7 +281,7 @@ EsiProcessor::process(const char *&data, int &data_len)
     return FAILURE;
   }
   if (_curr_state != WAITING_TO_PROCESS) {
-    _errorLog("[%s] Processor has to finish parsing via completeParse() before process() call", __FUNCTION__);
+    TSError("[%s] Processor has to finish parsing via completeParse() before process() call", __FUNCTION__);
     return FAILURE;
   }
   DocNodeList::iterator node_iter, iter;
@@ -292,29 +299,28 @@ EsiProcessor::process(const char *&data, int &data_len)
         string raw_url(url.value, url.value_len);
         if (!_getIncludeData(*node_iter)) {
           attempt_succeeded = false;
-          _errorLog("[%s] attempt section errored; due to url [%s]", __FUNCTION__, raw_url.c_str());
+          TSError("[%s] attempt section errored; due to url [%s]", __FUNCTION__, raw_url.c_str());
           break;
         }
       }
     }
 
     if (attempt_succeeded) {
-      _debugLog(_debug_tag, "[%s] attempt section succeeded; using attempt section", __FUNCTION__);
+      DBG("[%s] attempt section succeeded; using attempt section", __FUNCTION__);
       _node_list.splice(try_iter->pos, try_iter->attempt_nodes);
     } else {
-      _debugLog(_debug_tag, "[%s] attempt section errored; trying except section", __FUNCTION__);
+      DBG("[%s] attempt section errored; trying except section", __FUNCTION__);
       int n_prescanned_nodes = 0;
       if (!_preprocess(try_iter->except_nodes, n_prescanned_nodes)) {
-        _errorLog("[%s] Failed to preprocess except nodes", __FUNCTION__);
+        TSError("[%s] Failed to preprocess except nodes", __FUNCTION__);
         stop();
         return FAILURE;
       }
       _node_list.splice(try_iter->pos, try_iter->except_nodes);
       if (_fetcher.getNumPendingRequests()) {
-        _debugLog(_debug_tag,
-                  "[%s] New fetch requests were triggered by except block; "
-                  "Returning NEED_MORE_DATA...",
-                  __FUNCTION__);
+        DBG("[%s] New fetch requests were triggered by except block; "
+            "Returning NEED_MORE_DATA...",
+            __FUNCTION__);
         return NEED_MORE_DATA;
       }
     }
@@ -322,13 +328,13 @@ EsiProcessor::process(const char *&data, int &data_len)
   _curr_state = PROCESSED;
   for (node_iter = _node_list.begin(); node_iter != _node_list.end(); ++node_iter) {
     DocNode &doc_node = *node_iter; // handy reference
-    _debugLog(_debug_tag, "[%s] Processing ESI node [%s] with data of size %d starting with [%.10s...]", __FUNCTION__,
-              DocNode::type_names_[doc_node.type], doc_node.data_len, (doc_node.data_len ? doc_node.data : "(null)"));
+    DBG("[%s] Processing ESI node [%s] with data of size %d starting with [%.10s...]", __FUNCTION__,
+        DocNode::type_names_[doc_node.type], doc_node.data_len, (doc_node.data_len ? doc_node.data : "(null)"));
     if (doc_node.type == DocNode::TYPE_PRE) {
       // just copy the data
       _output_data.append(doc_node.data, doc_node.data_len);
     } else if (!_processEsiNode(node_iter)) {
-      _errorLog("[%s] Failed to process ESI node [%.*s]", __FUNCTION__, doc_node.data_len, doc_node.data);
+      TSError("[%s] Failed to process ESI node [%.*s]", __FUNCTION__, doc_node.data_len, doc_node.data);
       stop();
       return FAILURE;
     }
@@ -336,8 +342,7 @@ EsiProcessor::process(const char *&data, int &data_len)
   _addFooterData();
   data     = _output_data.c_str();
   data_len = _output_data.size();
-  _debugLog(_debug_tag, "[%s] ESI processed document of size %d starting with [%.10s]", __FUNCTION__, data_len,
-            (data_len ? data : "(null)"));
+  DBG("[%s] ESI processed document of size %d starting with [%.10s]", __FUNCTION__, data_len, (data_len ? data : "(null)"));
   return SUCCESS;
 }
 
@@ -383,29 +388,28 @@ EsiProcessor::flush(string &data, int &overall_len)
         string raw_url(url.value, url.value_len);
         if (_getIncludeStatus(*node_iter) != STATUS_DATA_AVAILABLE) {
           attempt_succeeded = false;
-          _errorLog("[%s] attempt section errored; due to url [%s]", __FUNCTION__, raw_url.c_str());
+          TSError("[%s] attempt section errored; due to url [%s]", __FUNCTION__, raw_url.c_str());
           break;
         }
       }
     }
 
     if (attempt_succeeded) {
-      _debugLog(_debug_tag, "[%s] attempt section succeeded; using attempt section", __FUNCTION__);
+      DBG("[%s] attempt section succeeded; using attempt section", __FUNCTION__);
       _n_prescanned_nodes = _n_prescanned_nodes + try_iter->attempt_nodes.size();
       _node_list.splice(try_iter->pos, try_iter->attempt_nodes);
     } else {
-      _debugLog(_debug_tag, "[%s] attempt section errored; trying except section", __FUNCTION__);
+      DBG("[%s] attempt section errored; trying except section", __FUNCTION__);
       int n_prescanned_nodes = 0;
       if (!_preprocess(try_iter->except_nodes, n_prescanned_nodes)) {
-        _errorLog("[%s] Failed to preprocess except nodes", __FUNCTION__);
+        TSError("[%s] Failed to preprocess except nodes", __FUNCTION__);
       }
       _n_prescanned_nodes = _n_prescanned_nodes + try_iter->except_nodes.size();
       _node_list.splice(try_iter->pos, try_iter->except_nodes);
       if (_fetcher.getNumPendingRequests()) {
-        _debugLog(_debug_tag,
-                  "[%s] New fetch requests were triggered by except block; "
-                  "Returning NEED_MORE_DATA...",
-                  __FUNCTION__);
+        DBG("[%s] New fetch requests were triggered by except block; "
+            "Returning NEED_MORE_DATA...",
+            __FUNCTION__);
       }
     }
   }
@@ -417,16 +421,16 @@ EsiProcessor::flush(string &data, int &overall_len)
   }
   for (; node_iter != _node_list.end(); ++node_iter) {
     DocNode &doc_node = *node_iter; // handy reference
-    _debugLog(_debug_tag, "[%s] Processing ESI node [%s] with data of size %d starting with [%.10s...]", __FUNCTION__,
-              DocNode::type_names_[doc_node.type], doc_node.data_len, (doc_node.data_len ? doc_node.data : "(null)"));
+    DBG("[%s] Processing ESI node [%s] with data of size %d starting with [%.10s...]", __FUNCTION__,
+        DocNode::type_names_[doc_node.type], doc_node.data_len, (doc_node.data_len ? doc_node.data : "(null)"));
 
     if (_getIncludeStatus(doc_node) == STATUS_DATA_PENDING) {
       node_pending = true;
       break;
     }
 
-    _debugLog(_debug_tag, "[%s] processed node: %d, try blocks processed: %d, processed try nodes: %d", __FUNCTION__,
-              _n_processed_nodes, _n_try_blocks_processed, _n_processed_try_nodes);
+    DBG("[%s] processed node: %d, try blocks processed: %d, processed try nodes: %d", __FUNCTION__, _n_processed_nodes,
+        _n_try_blocks_processed, _n_processed_try_nodes);
     if (doc_node.type == DocNode::TYPE_TRY) {
       if (_n_try_blocks_processed <= _n_processed_try_nodes) {
         node_pending = true;
@@ -436,15 +440,15 @@ EsiProcessor::flush(string &data, int &overall_len)
       }
     }
 
-    _debugLog(_debug_tag, "[%s] really Processing ESI node [%s] with data of size %d starting with [%.10s...]", __FUNCTION__,
-              DocNode::type_names_[doc_node.type], doc_node.data_len, (doc_node.data_len ? doc_node.data : "(null)"));
+    DBG("[%s] really Processing ESI node [%s] with data of size %d starting with [%.10s...]", __FUNCTION__,
+        DocNode::type_names_[doc_node.type], doc_node.data_len, (doc_node.data_len ? doc_node.data : "(null)"));
 
     if (doc_node.type == DocNode::TYPE_PRE) {
       // just copy the data
       _output_data.append(doc_node.data, doc_node.data_len);
       ++_n_processed_nodes;
     } else if (!_processEsiNode(node_iter)) {
-      _errorLog("[%s] Failed to process ESI node [%.*s]", __FUNCTION__, doc_node.data_len, doc_node.data);
+      TSError("[%s] Failed to process ESI node [%.*s]", __FUNCTION__, doc_node.data_len, doc_node.data);
       ++_n_processed_nodes;
     } else {
       ++_n_processed_nodes;
@@ -459,8 +463,8 @@ EsiProcessor::flush(string &data, int &overall_len)
   _overall_len = _overall_len + data.size();
   overall_len  = _overall_len;
 
-  _debugLog(_debug_tag, "[%s] ESI processed document of size %d starting with [%.10s]", __FUNCTION__, data.size(),
-            (data.size() ? data.data() : "(null)"));
+  DBG("[%s] ESI processed document of size %d starting with [%.10s]", __FUNCTION__, int(data.size()),
+      (data.size() ? data.data() : "(null)"));
   return SUCCESS;
 }
 
@@ -504,18 +508,18 @@ EsiProcessor::_processEsiNode(const DocNodeList::iterator &iter)
   } else if ((node.type == DocNode::TYPE_COMMENT) || (node.type == DocNode::TYPE_REMOVE) || (node.type == DocNode::TYPE_TRY) ||
              (node.type == DocNode::TYPE_CHOOSE) || (node.type == DocNode::TYPE_HTML_COMMENT)) {
     // choose, try and html-comment would've been dealt with earlier
-    _debugLog(_debug_tag, "[%s] No-op for [%s] node", __FUNCTION__, DocNode::type_names_[node.type]);
+    DBG("[%s] No-op for [%s] node", __FUNCTION__, DocNode::type_names_[node.type]);
     retval = true;
   } else if (node.type == DocNode::TYPE_VARS) {
     retval = _handleVars(node.data, node.data_len);
   } else {
-    _errorLog("[%s] Unknown ESI Doc node type %d", __FUNCTION__, node.type);
+    TSError("[%s] Unknown ESI Doc node type %d", __FUNCTION__, node.type);
     retval = false;
   }
   if (retval) {
-    _debugLog(_debug_tag, "[%s] Processed ESI [%s] node", __FUNCTION__, DocNode::type_names_[node.type]);
+    DBG("[%s] Processed ESI [%s] node", __FUNCTION__, DocNode::type_names_[node.type]);
   } else {
-    _errorLog("[%s] Failed to process ESI doc node of type %d", __FUNCTION__, node.type);
+    TSError("[%s] Failed to process ESI doc node of type %d", __FUNCTION__, node.type);
   }
   return retval;
 }
@@ -554,12 +558,12 @@ EsiProcessor::_handleChoose(DocNodeList::iterator &curr_node)
     }
   }
   if (winning_node == end_node) {
-    _debugLog(_debug_tag, "[%s] All when nodes failed to evaluate to true", __FUNCTION__);
+    DBG("[%s] All when nodes failed to evaluate to true", __FUNCTION__);
     if (otherwise_node != end_node) {
-      _debugLog(_debug_tag, "[%s] Using otherwise node...", __FUNCTION__);
+      DBG("[%s] Using otherwise node...", __FUNCTION__);
       winning_node = otherwise_node;
     } else {
-      _debugLog(_debug_tag, "[%s] No otherwise node, nothing to do...", __FUNCTION__);
+      DBG("[%s] No otherwise node, nothing to do...", __FUNCTION__);
       return true;
     }
   }
@@ -587,7 +591,7 @@ EsiProcessor::_handleTry(DocNodeList::iterator &curr_node)
   TryBlock try_info(attempt_node->child_nodes, except_node->child_nodes, curr_node);
   int n_prescanned_nodes = 0;
   if (!_preprocess(try_info.attempt_nodes, n_prescanned_nodes)) {
-    _errorLog("[%s] Couldn't preprocess attempt node of try block", __FUNCTION__);
+    TSError("[%s] Couldn't preprocess attempt node of try block", __FUNCTION__);
     return false;
   }
   _try_blocks.push_back(try_info);
@@ -598,8 +602,7 @@ bool
 EsiProcessor::_handleVars(const char *str, int str_len)
 {
   const string &str_value = _expression.expand(str, str_len);
-  _debugLog(_debug_tag, "[%s] Vars expression [%.*s] expanded to [%.*s]", __FUNCTION__, str_len, str, str_value.size(),
-            str_value.data());
+  DBG("[%s] Vars expression [%.*s] expanded to [%.*s]", __FUNCTION__, str_len, str, int(str_value.size()), str_value.data());
   _output_data.append(str_value);
   return true;
 }
@@ -609,11 +612,11 @@ EsiProcessor::_handleHtmlComment(const DocNodeList::iterator &curr_node)
 {
   DocNodeList inner_nodes;
   if (!_parser.parse(inner_nodes, curr_node->data, curr_node->data_len)) {
-    _errorLog("[%s] Couldn't parse html comment node content", __FUNCTION__);
+    TSError("[%s] Couldn't parse html comment node content", __FUNCTION__);
     Stats::increment(Stats::N_PARSE_ERRS);
     return false;
   }
-  _debugLog(_debug_tag, "[%s] parsed %d inner nodes from html comment node", __FUNCTION__, inner_nodes.size());
+  DBG("[%s] parsed %d inner nodes from html comment node", __FUNCTION__, int(inner_nodes.size()));
   DocNodeList::iterator next_node = curr_node;
   ++next_node;
   _node_list.splice(next_node, inner_nodes); // insert after curr node for pre-processing
@@ -636,17 +639,17 @@ EsiProcessor::_preprocess(DocNodeList &node_list, int &n_prescanned_nodes)
     switch (list_iter->type) {
     case DocNode::TYPE_CHOOSE:
       if (!_handleChoose(list_iter)) {
-        _errorLog("[%s] Failed to preprocess choose node", __FUNCTION__);
+        TSError("[%s] Failed to preprocess choose node", __FUNCTION__);
         return false;
       }
-      _debugLog(_debug_tag, "[%s] handled choose node successfully", __FUNCTION__);
+      DBG("[%s] handled choose node successfully", __FUNCTION__);
       break;
     case DocNode::TYPE_TRY:
       if (!_handleTry(list_iter)) {
-        _errorLog("[%s] Failed to preprocess try node", __FUNCTION__);
+        TSError("[%s] Failed to preprocess try node", __FUNCTION__);
         return false;
       }
-      _debugLog(_debug_tag, "[%s] handled try node successfully", __FUNCTION__);
+      DBG("[%s] handled try node successfully", __FUNCTION__);
       break;
     case DocNode::TYPE_HTML_COMMENT:
       /**
@@ -660,7 +663,7 @@ EsiProcessor::_preprocess(DocNodeList &node_list, int &n_prescanned_nodes)
        * is unpacked from the cache because the node list has been parsed.
        */
       if (!_usePackedNodeList && !_handleHtmlComment(list_iter)) {
-        _errorLog("[%s] Failed to preprocess try node", __FUNCTION__);
+        TSError("[%s] Failed to preprocess try node", __FUNCTION__);
         return false;
       }
       break;
@@ -668,21 +671,21 @@ EsiProcessor::_preprocess(DocNodeList &node_list, int &n_prescanned_nodes)
       Stats::increment(Stats::N_INCLUDES);
       const Attribute &src = list_iter->attr_list.front();
       raw_url.assign(src.value, src.value_len);
-      _debugLog(_debug_tag, "[%s] Adding fetch request for url [%.*s]", __FUNCTION__, raw_url.size(), raw_url.data());
+      DBG("[%s] Adding fetch request for url [%.*s]", __FUNCTION__, int(raw_url.size()), raw_url.data());
       hash_iter = _include_urls.find(raw_url);
       if (hash_iter != _include_urls.end()) { // we have already processed this URL
-        _debugLog(_debug_tag, "[%s] URL [%.*s] already processed", __FUNCTION__, raw_url.size(), raw_url.data());
+        DBG("[%s] URL [%.*s] already processed", __FUNCTION__, int(raw_url.size()), raw_url.data());
         continue;
       }
       const string &expanded_url = _expression.expand(raw_url);
       if (!expanded_url.size()) {
-        _errorLog("[%s] Couldn't expand raw URL [%.*s]", __FUNCTION__, raw_url.size(), raw_url.data());
+        TSError("[%s] Couldn't expand raw URL [%.*s]", __FUNCTION__, int(raw_url.size()), raw_url.data());
         Stats::increment(Stats::N_INCLUDE_ERRS);
         continue;
       }
 
       if (!_fetcher.addFetchRequest(expanded_url)) {
-        _errorLog("[%s] Couldn't add fetch request for URL [%.*s]", __FUNCTION__, raw_url.size(), raw_url.data());
+        TSError("[%s] Couldn't add fetch request for URL [%.*s]", __FUNCTION__, int(raw_url.size()), raw_url.data());
         Stats::increment(Stats::N_INCLUDE_ERRS);
         continue;
       }
@@ -698,27 +701,27 @@ EsiProcessor::_preprocess(DocNodeList &node_list, int &n_prescanned_nodes)
       if (map_iter == _include_handlers.end()) {
         handler = _handler_manager.getHandler(_esi_vars, _expression, _fetcher, handler_id);
         if (!handler) {
-          _errorLog("[%s] Couldn't create handler with id [%s]", __FUNCTION__, handler_id.c_str());
+          TSError("[%s] Couldn't create handler with id [%s]", __FUNCTION__, handler_id.c_str());
           Stats::increment(Stats::N_SPCL_INCLUDE_ERRS);
           return false;
         }
         _include_handlers.insert(IncludeHandlerMap::value_type(handler_id, handler));
-        _debugLog(_debug_tag, "[%s] Created new special include handler object for id [%s]", __FUNCTION__, handler_id.c_str());
+        DBG("[%s] Created new special include handler object for id [%s]", __FUNCTION__, handler_id.c_str());
       } else {
         handler = map_iter->second;
       }
       int special_data_id = handler->handleInclude(list_iter->data, list_iter->data_len);
       if (special_data_id == -1) {
-        _errorLog("[%s] Include handler [%s] couldn't process include with data [%.*s]", __FUNCTION__, handler_id.c_str(),
-                  list_iter->data_len, list_iter->data);
+        TSError("[%s] Include handler [%s] couldn't process include with data [%.*s]", __FUNCTION__, handler_id.c_str(),
+                list_iter->data_len, list_iter->data);
         Stats::increment(Stats::N_SPCL_INCLUDE_ERRS);
         return false;
       }
       // overloading this structure's members
       // handler will be in value and include id will be in value_len of the structure
       list_iter->attr_list.push_back(Attribute(INCLUDE_DATA_ID_ATTR, 0, reinterpret_cast<const char *>(handler), special_data_id));
-      _debugLog(_debug_tag, "[%s] Got id %d for special include at node %d from handler [%s]", __FUNCTION__, special_data_id,
-                n_prescanned_nodes + 1, handler_id.c_str());
+      DBG("[%s] Got id %d for special include at node %d from handler [%s]", __FUNCTION__, special_data_id, n_prescanned_nodes + 1,
+          handler_id.c_str());
     } break;
     default:
       break;
diff --git a/plugins/esi/lib/EsiProcessor.h b/plugins/esi/lib/EsiProcessor.h
index a632c4f2b60..1b32a639c6e 100644
--- a/plugins/esi/lib/EsiProcessor.h
+++ b/plugins/esi/lib/EsiProcessor.h
@@ -25,7 +25,6 @@
 
 #include <string>
 #include <map>
-#include "ComponentBase.h"
 #include "StringHash.h"
 #include "DocNode.h"
 #include "EsiParser.h"
@@ -35,7 +34,7 @@
 #include "SpecialIncludeHandler.h"
 #include "HandlerManager.h"
 
-class EsiProcessor : private EsiLib::ComponentBase
+class EsiProcessor
 {
 public:
   enum UsePackedNodeResult {
@@ -45,9 +44,7 @@ class EsiProcessor : private EsiLib::ComponentBase
     PROCESS_FAILURE,
   };
 
-  EsiProcessor(const char *debug_tag, const char *parser_debug_tag, const char *expression_debug_tag,
-               EsiLib::ComponentBase::Debug debug_func, EsiLib::ComponentBase::Error error_func, HttpDataFetcher &fetcher,
-               EsiLib::Variables &variables, const EsiLib::HandlerManager &handler_mgr);
+  EsiProcessor(void *cont_addr, HttpDataFetcher &fetcher, EsiLib::Variables &variables, const EsiLib::HandlerManager &handler_mgr);
 
   /** Initializes the processor with the context of the request to be processed */
   bool start();
@@ -180,4 +177,6 @@ class EsiProcessor : private EsiLib::ComponentBase
     stop();
     _curr_state = ERRORED;
   }
+
+  void *_cont_addr;
 };
diff --git a/plugins/esi/lib/Expression.cc b/plugins/esi/lib/Expression.cc
index cf83f962e68..b188258d8d1 100644
--- a/plugins/esi/lib/Expression.cc
+++ b/plugins/esi/lib/Expression.cc
@@ -21,12 +21,19 @@
   limitations under the License.
  */
 
+#include <ts/ts.h>
+
 #include "Expression.h"
 #include "Utils.h"
 
 using std::string;
 using namespace EsiLib;
 
+namespace
+{
+DbgCtl dbg_ctl{"plugin_esi_vars"};
+}
+
 const string Expression::EMPTY_STRING("");
 const string Expression::TRUE_STRING("true");
 const Expression::OperatorString Expression::OPERATOR_STRINGS[N_OPERATORS] = {
@@ -34,11 +41,7 @@ const Expression::OperatorString Expression::OPERATOR_STRINGS[N_OPERATORS] = {
   Expression::OperatorString(">=", 2), Expression::OperatorString("<", 1),  Expression::OperatorString(">", 1),
   Expression::OperatorString("!", 1),  Expression::OperatorString("|", 1),  Expression::OperatorString("&", 1)};
 
-Expression::Expression(const char *debug_tag, ComponentBase::Debug debug_func, ComponentBase::Error error_func,
-                       Variables &variables)
-  : ComponentBase(debug_tag, debug_func, error_func), _variables(variables), _value("")
-{
-}
+Expression::Expression(Variables &variables) : _variables(variables), _value("") {}
 
 inline bool
 Expression::_stripQuotes(const char *&expr, int &expr_len) const
@@ -51,7 +54,7 @@ Expression::_stripQuotes(const char *&expr, int &expr_len) const
   }
   if (quote_char) {
     if (expr[expr_len - 1] != quote_char) {
-      _errorLog("[%s] Unterminated quote in expression [%.*s]", __FUNCTION__, expr_len, expr);
+      TSError("[%s] Unterminated quote in expression [%.*s]", __FUNCTION__, expr_len, expr);
       return false;
     }
     expr_len -= 2;
@@ -66,7 +69,7 @@ Expression::expand(const char *expr, int expr_len /* = -1 */)
   int var_start_index = -1, var_size;
   Utils::trimWhiteSpace(expr, expr_len);
   if (!expr_len) {
-    _debugLog(_debug_tag, "[%s] Returning empty string for empty expression", __FUNCTION__);
+    Dbg(dbg_ctl, "[%s] Returning empty string for empty expression", __FUNCTION__);
     goto lFail;
   }
   if (!_stripQuotes(expr, expr_len)) {
@@ -77,7 +80,7 @@ Expression::expand(const char *expr, int expr_len /* = -1 */)
   for (int i = 0; i < expr_len; ++i) {
     if ((expr[i] == '$') && ((expr_len - i) >= 3) && (expr[i + 1] == '(')) {
       if (var_start_index != -1) {
-        _debugLog(_debug_tag, "[%s] Cannot have nested variables in expression [%.*s]", __FUNCTION__, expr_len, expr);
+        Dbg(dbg_ctl, "[%s] Cannot have nested variables in expression [%.*s]", __FUNCTION__, expr_len, expr);
         goto lFail;
       }
       var_start_index = i + 2; // skip the '$('
@@ -87,12 +90,12 @@ Expression::expand(const char *expr, int expr_len /* = -1 */)
       var_size               = i - var_start_index;
       if (var_size) {
         const string &var_value = _variables.getValue(expr + var_start_index, var_size);
-        _debugLog(_debug_tag, "[%s] Got value [%.*s] for variable [%.*s]", __FUNCTION__, var_value.size(), var_value.data(),
-                  var_size, expr + var_start_index);
+        Dbg(dbg_ctl, "[%s] Got value [%.*s] for variable [%.*s]", __FUNCTION__, int(var_value.size()), var_value.data(), var_size,
+            expr + var_start_index);
         last_variable_expanded  = (var_value.size() > 0);
         _value                 += var_value;
       } else {
-        _debugLog(_debug_tag, "[%s] Parsing out empty variable", __FUNCTION__);
+        Dbg(dbg_ctl, "[%s] Parsing out empty variable", __FUNCTION__);
       }
       if (expr[i] == '|') {
         int default_value_start = ++i;
@@ -103,8 +106,7 @@ Expression::expand(const char *expr, int expr_len /* = -1 */)
           ++i;
         }
         if (i == expr_len) {
-          _debugLog(_debug_tag, "[%s] Expression [%.*s] has unterminated variable (with default value)", __FUNCTION__, expr_len,
-                    expr);
+          Dbg(dbg_ctl, "[%s] Expression [%.*s] has unterminated variable (with default value)", __FUNCTION__, expr_len, expr);
           goto lFail;
         }
         const char *default_value = expr + default_value_start;
@@ -113,8 +115,8 @@ Expression::expand(const char *expr, int expr_len /* = -1 */)
           goto lFail;
         }
         if (!last_variable_expanded) {
-          _debugLog(_debug_tag, "[%s] Using default value [%.*s] as variable expanded to empty string", __FUNCTION__,
-                    default_value_len, default_value);
+          Dbg(dbg_ctl, "[%s] Using default value [%.*s] as variable expanded to empty string", __FUNCTION__, default_value_len,
+              default_value);
           _value.append(default_value, default_value_len);
         }
       }
@@ -124,11 +126,11 @@ Expression::expand(const char *expr, int expr_len /* = -1 */)
     }
   }
   if (var_start_index != -1) {
-    _debugLog(_debug_tag, "[%s] Returning empty string for expression with unterminated variable [%.*s]", __FUNCTION__,
-              expr_len - var_start_index, expr + var_start_index);
+    Dbg(dbg_ctl, "[%s] Returning empty string for expression with unterminated variable [%.*s]", __FUNCTION__,
+        expr_len - var_start_index, expr + var_start_index);
     goto lFail;
   }
-  _debugLog(_debug_tag, "[%s] Returning final expanded expression [%.*s]", __FUNCTION__, _value.size(), _value.data());
+  Dbg(dbg_ctl, "[%s] Returning final expanded expression [%.*s]", __FUNCTION__, int(_value.size()), _value.data());
   return _value;
 
 lFail:
@@ -155,7 +157,7 @@ inline bool
 Expression::_evalSimpleExpr(const char *expr, int expr_len)
 {
   const string &lhs = expand(expr, expr_len);
-  _debugLog(_debug_tag, "[%s] simple expression [%.*s] evaluated to [%.*s]", __FUNCTION__, expr_len, expr, lhs.size(), lhs.data());
+  Dbg(dbg_ctl, "[%s] simple expression [%.*s] evaluated to [%.*s]", __FUNCTION__, expr_len, expr, int(lhs.size()), lhs.data());
   double val;
   return _convert(lhs, val) ? val : !lhs.empty();
 }
@@ -165,7 +167,7 @@ Expression::evaluate(const char *expr, int expr_len /* = -1 */)
 {
   Utils::trimWhiteSpace(expr, expr_len);
   if (!expr_len) {
-    _debugLog(_debug_tag, "[%s] Returning false for empty expression", __FUNCTION__);
+    Dbg(dbg_ctl, "[%s] Returning false for empty expression", __FUNCTION__);
     return false;
   }
   Operator op = OP_EQ; // stupid initialized checking, make gcc happy
@@ -181,11 +183,11 @@ Expression::evaluate(const char *expr, int expr_len /* = -1 */)
     subexpr     = expr;
     subexpr_len = sep;
     lhs         = expand(subexpr, subexpr_len);
-    _debugLog(_debug_tag, "[%s] LHS [%.*s] expanded to [%.*s]", __FUNCTION__, subexpr_len, subexpr, lhs.size(), lhs.data());
+    Dbg(dbg_ctl, "[%s] LHS [%.*s] expanded to [%.*s]", __FUNCTION__, subexpr_len, subexpr, int(lhs.size()), lhs.data());
     subexpr     = expr + sep + OPERATOR_STRINGS[op].str_len;
     subexpr_len = expr_len - subexpr_len - OPERATOR_STRINGS[op].str_len;
     rhs         = expand(subexpr, subexpr_len);
-    _debugLog(_debug_tag, "[%s] RHS [%.*s] expanded to [%.*s]", __FUNCTION__, subexpr_len, subexpr, rhs.size(), rhs.data());
+    Dbg(dbg_ctl, "[%s] RHS [%.*s] expanded to [%.*s]", __FUNCTION__, subexpr_len, subexpr, int(rhs.size()), rhs.data());
     double lhs_numerical = 0;
     double rhs_numerical = 0;
     bool are_numerical   = _convert(lhs, lhs_numerical);
@@ -206,7 +208,7 @@ Expression::evaluate(const char *expr, int expr_len /* = -1 */)
     default:
       if (lhs.empty() || rhs.empty()) {
         // one of the sides expanded to nothing; invalid comparison
-        _debugLog(_debug_tag, "[%s] LHS/RHS empty. Cannot evaluate comparisons", __FUNCTION__);
+        Dbg(dbg_ctl, "[%s] LHS/RHS empty. Cannot evaluate comparisons", __FUNCTION__);
         retval = false;
       } else {
         switch (op) {
@@ -223,7 +225,7 @@ Expression::evaluate(const char *expr, int expr_len /* = -1 */)
           retval = are_numerical ? (lhs_numerical >= rhs_numerical) : (lhs >= rhs);
           break;
         default:
-          _debugLog(_debug_tag, "[%s] Unknown operator in expression [%.*s]; returning false", __FUNCTION__, expr_len, expr);
+          Dbg(dbg_ctl, "[%s] Unknown operator in expression [%.*s]; returning false", __FUNCTION__, expr_len, expr);
         }
       }
       break;
@@ -232,13 +234,12 @@ Expression::evaluate(const char *expr, int expr_len /* = -1 */)
     if (sep == 0) {
       retval = !_evalSimpleExpr(expr + 1, expr_len - 1);
     } else {
-      _debugLog(_debug_tag, "[%s] Unary negation not preceding literal in expression [%.*s]; assuming true", __FUNCTION__, expr_len,
-                expr);
+      Dbg(dbg_ctl, "[%s] Unary negation not preceding literal in expression [%.*s]; assuming true", __FUNCTION__, expr_len, expr);
       retval = true;
     }
   } else {
-    _debugLog(_debug_tag, "[%s] Unknown operator in expression [%.*s]; returning false", __FUNCTION__, expr_len, expr);
+    Dbg(dbg_ctl, "[%s] Unknown operator in expression [%.*s]; returning false", __FUNCTION__, expr_len, expr);
   }
-  _debugLog(_debug_tag, "[%s] Returning [%s] for expression [%.*s]", __FUNCTION__, (retval ? "true" : "false"), expr_len, expr);
+  Dbg(dbg_ctl, "[%s] Returning [%s] for expression [%.*s]", __FUNCTION__, (retval ? "true" : "false"), expr_len, expr);
   return retval;
 }
diff --git a/plugins/esi/lib/Expression.h b/plugins/esi/lib/Expression.h
index 318b039e4cf..2c7314ba5a3 100644
--- a/plugins/esi/lib/Expression.h
+++ b/plugins/esi/lib/Expression.h
@@ -26,15 +26,14 @@
 #include <string>
 #include <cstdlib>
 
-#include "ComponentBase.h"
 #include "Variables.h"
 
 namespace EsiLib
 {
-class Expression : private ComponentBase
+class Expression
 {
 public:
-  Expression(const char *debug_tag, ComponentBase::Debug debug_func, ComponentBase::Error error_func, Variables &variables);
+  Expression(Variables &variables);
 
   /** substitutes variables (if any) in given expression */
   const std::string &expand(const char *expr, int expr_len = -1);
@@ -56,7 +55,7 @@ class Expression : private ComponentBase
     return evaluate(expr.data(), expr.size());
   }
 
-  ~Expression() override{};
+  ~Expression(){};
 
 private:
   static const std::string EMPTY_STRING;
diff --git a/plugins/esi/lib/HandlerManager.cc b/plugins/esi/lib/HandlerManager.cc
index e23cafc90e8..bc40fd687c4 100644
--- a/plugins/esi/lib/HandlerManager.cc
+++ b/plugins/esi/lib/HandlerManager.cc
@@ -23,12 +23,19 @@
 
 #include <dlfcn.h>
 
+#include <ts/ts.h>
+
 #include "HandlerManager.h"
 
 using std::map;
 using std::string;
 using namespace EsiLib;
 
+namespace
+{
+DbgCtl dbg_ctl{"plugin_esi_handler_mgr"};
+}
+
 #define CLASS_NAME "HandlerManager"
 
 const char *const HandlerManager::FACTORY_FUNCTION_NAME = "createSpecialIncludeHandler";
@@ -51,17 +58,17 @@ HandlerManager::loadObjects(const Utils::KeyValueMap &handlers)
       // no, we have to load this object
       void *obj_handle = dlopen(path.c_str(), RTLD_LAZY | RTLD_LOCAL);
       if (!obj_handle) {
-        _errorLog("[%s::%s] Could not load module [%s]. Error [%s]", CLASS_NAME, __FUNCTION__, path.c_str(), dlerror());
+        TSError("[%s::%s] Could not load module [%s]. Error [%s]", CLASS_NAME, __FUNCTION__, path.c_str(), dlerror());
       } else {
         SpecialIncludeHandlerCreator func_handle = (SpecialIncludeHandlerCreator)(dlsym(obj_handle, FACTORY_FUNCTION_NAME));
         if (!func_handle) {
-          _errorLog("[%s::%s] Could not find factory function [%s] in module [%s]. Error [%s]", CLASS_NAME, __FUNCTION__,
-                    FACTORY_FUNCTION_NAME, path.c_str(), dlerror());
+          TSError("[%s::%s] Could not find factory function [%s] in module [%s]. Error [%s]", CLASS_NAME, __FUNCTION__,
+                  FACTORY_FUNCTION_NAME, path.c_str(), dlerror());
           dlclose(obj_handle);
         } else {
           _id_to_function_map.insert(FunctionHandleMap::value_type(id, func_handle));
           _path_to_module_map.insert(ModuleHandleMap::value_type(path, ModuleHandles(obj_handle, func_handle)));
-          _debugLog(_debug_tag, "[%s] Loaded handler module [%s]", __FUNCTION__, path.c_str());
+          Dbg(dbg_ctl, "[%s] Loaded handler module [%s]", __FUNCTION__, path.c_str());
         }
       }
     }
@@ -73,7 +80,7 @@ HandlerManager::getHandler(Variables &esi_vars, Expression &esi_expr, HttpDataFe
 {
   FunctionHandleMap::const_iterator iter = _id_to_function_map.find(id);
   if (iter == _id_to_function_map.end()) {
-    _errorLog("[%s::%s] handler id [%s] does not map to any loaded object", CLASS_NAME, __FUNCTION__, id.c_str());
+    TSError("[%s::%s] handler id [%s] does not map to any loaded object", CLASS_NAME, __FUNCTION__, id.c_str());
     return nullptr;
   }
   return (*(iter->second))(esi_vars, esi_expr, fetcher, id);
diff --git a/plugins/esi/lib/HandlerManager.h b/plugins/esi/lib/HandlerManager.h
index 350880cf648..1a9193f1ece 100644
--- a/plugins/esi/lib/HandlerManager.h
+++ b/plugins/esi/lib/HandlerManager.h
@@ -26,7 +26,6 @@
 #include <string>
 #include <map>
 
-#include "ComponentBase.h"
 #include "Utils.h"
 #include "SpecialIncludeHandler.h"
 #include "IncludeHandlerFactory.h"
@@ -35,17 +34,15 @@
 
 namespace EsiLib
 {
-class HandlerManager : protected ComponentBase
+class HandlerManager
 {
 public:
-  HandlerManager(const char *debug_tag, Debug debug_func, Error error_func) : ComponentBase(debug_tag, debug_func, error_func){};
-
   void loadObjects(const Utils::KeyValueMap &handlers);
 
   SpecialIncludeHandler *getHandler(Variables &esi_vars, Expression &esi_expr, HttpDataFetcher &http_fetcher,
                                     const std::string &id) const;
 
-  ~HandlerManager() override;
+  ~HandlerManager();
 
 private:
   using FunctionHandleMap = std::map<std::string, SpecialIncludeHandlerCreator>;
diff --git a/plugins/esi/lib/Variables.cc b/plugins/esi/lib/Variables.cc
index e9109b44c47..9732e2bb8f7 100644
--- a/plugins/esi/lib/Variables.cc
+++ b/plugins/esi/lib/Variables.cc
@@ -25,6 +25,8 @@
 #include "Attribute.h"
 #include "Utils.h"
 
+#include <ts/ts.h>
+
 #include <cerrno>
 
 using std::list;
@@ -32,6 +34,15 @@ using std::pair;
 using std::string;
 using namespace EsiLib;
 
+namespace
+{
+DbgCtl dbg_ctl{"plugin_esi_vars"};
+}
+
+// Can only be used in member functions of Variables.
+//
+#define DBG(FMT, ...) Dbg(dbg_ctl, FMT " contp=%p", ##__VA_ARGS__, _cont_addr)
+
 const string Variables::EMPTY_STRING("");
 const string Variables::TRUE_STRING("true");
 const string Variables::VENDOR_STRING("vendor");
@@ -116,7 +127,7 @@ Variables::populate(const HttpHeader &header)
 inline void
 Variables::_parseSimpleHeader(SimpleHeader hdr, const string &value)
 {
-  _debugLog(_debug_tag, "[%s] Inserting value for simple header [%s]", __FUNCTION__, SIMPLE_HEADERS[hdr].c_str());
+  DBG("[%s] Inserting value for simple header [%s]", __FUNCTION__, SIMPLE_HEADERS[hdr].c_str());
   _simple_data[NORM_SIMPLE_HEADERS[hdr]] = value;
 }
 
@@ -140,7 +151,7 @@ Variables::_parseSpecialHeader(SpecialHeader hdr, const char *value, int value_l
     _parseUserAgentString(value, value_len);
     break;
   default:
-    _debugLog(_debug_tag, "[%s] Skipping unrecognized header", __FUNCTION__);
+    DBG("[%s] Skipping unrecognized header", __FUNCTION__);
     break;
   }
 }
@@ -156,7 +167,7 @@ Variables::_parseHeader(const char *name, int name_len, const char *value, int v
     if (match_index != -1) {
       _parseSpecialHeader(static_cast<SpecialHeader>(match_index), value, value_len);
     } else {
-      _debugLog(_debug_tag, "[%s] Unrecognized header [%.*s]", __FUNCTION__, value_len, value);
+      DBG("[%s] Unrecognized header [%.*s]", __FUNCTION__, value_len, value);
     }
   }
 }
@@ -168,8 +179,8 @@ Variables::_parseQueryString(const char *query_string, int query_string_len)
   AttributeList attr_list;
   Utils::parseAttributes(query_string, query_string_len, attr_list, "&");
   for (auto &iter : attr_list) {
-    _debugLog(_debug_tag, "[%s] Inserting query string variable [%.*s] with value [%.*s]", __FUNCTION__, iter.name_len, iter.name,
-              iter.value_len, iter.value);
+    DBG("[%s] Inserting query string variable [%.*s] with value [%.*s]", __FUNCTION__, iter.name_len, iter.name, iter.value_len,
+        iter.value);
     _insert(_dict_data[QUERY_STRING], string(iter.name, iter.name_len), string(iter.value, iter.value_len));
   }
 }
@@ -177,7 +188,7 @@ Variables::_parseQueryString(const char *query_string, int query_string_len)
 void
 Variables::_parseCachedHeaders()
 {
-  _debugLog(_debug_tag, "[%s] Parsing headers", __FUNCTION__);
+  DBG("[%s] Parsing headers", __FUNCTION__);
   for (int i = 0; i < N_SIMPLE_HEADERS; ++i) {
     for (Utils::HeaderValueList::iterator value_iter = _cached_simple_headers[i].begin();
          value_iter != _cached_simple_headers[i].end(); ++value_iter) {
@@ -216,8 +227,8 @@ Variables::getValue(const string &name) const
   _toUpperCase(search_key);
   StringHash::const_iterator iter = _simple_data.find(search_key);
   if (iter != _simple_data.end()) {
-    _debugLog(_debug_tag, "[%s] Found value [%.*s] for variable [%.*s] in simple data", __FUNCTION__, iter->second.size(),
-              iter->second.data(), name.size(), name.data());
+    DBG("[%s] Found value [%.*s] for variable [%.*s] in simple data", __FUNCTION__, int(iter->second.size()), iter->second.data(),
+        int(name.size()), name.data());
     return iter->second;
   }
   const char *header;
@@ -225,19 +236,18 @@ Variables::getValue(const string &name) const
   const char *attr;
   int attr_len;
   if (!_parseDictVariable(name, header, header_len, attr, attr_len)) {
-    _debugLog(_debug_tag, "[%s] Unmatched simple variable [%.*s] not in dict variable form", __FUNCTION__, name.size(),
-              name.data());
+    DBG("[%s] Unmatched simple variable [%.*s] not in dict variable form", __FUNCTION__, int(name.size()), name.data());
     return EMPTY_STRING;
   }
   int dict_index = _searchHeaders(NORM_SPECIAL_HEADERS, header, header_len); // ignore the HTTP_ prefix
   if (dict_index == -1) {
-    _debugLog(_debug_tag, "[%s] Dict variable [%.*s] refers to unknown dictionary", __FUNCTION__, name.size(), name.data());
+    DBG("[%s] Dict variable [%.*s] refers to unknown dictionary", __FUNCTION__, int(name.size()), name.data());
     return EMPTY_STRING;
   }
 
   // Disallow Cookie retrieval though HTTP_HEADER
   if (dict_index == HTTP_HEADER && ((attr_len == 6) && (strncasecmp(attr, "Cookie", 6) == 0))) {
-    _errorLog("[%s] Cannot use HTTP_HEADER to retrieve Cookie", __FUNCTION__);
+    TSError("[%s] Cannot use HTTP_HEADER to retrieve Cookie", __FUNCTION__);
     return EMPTY_STRING;
   }
 
@@ -247,24 +257,23 @@ Variables::getValue(const string &name) const
   iter = _dict_data[dict_index].find(search_key);
 
   if (dict_index == HTTP_ACCEPT_LANGUAGE) {
-    _debugLog(_debug_tag, "[%s] Returning boolean literal for lang variable [%.*s]", __FUNCTION__, search_key.size(),
-              search_key.data());
+    DBG("[%s] Returning boolean literal for lang variable [%.*s]", __FUNCTION__, int(search_key.size()), search_key.data());
     return (iter == _dict_data[dict_index].end()) ? EMPTY_STRING : TRUE_STRING;
   }
 
   if (iter != _dict_data[dict_index].end()) {
-    _debugLog(_debug_tag, "[%s] Found variable [%.*s] in %s dictionary with value [%.*s]", __FUNCTION__, search_key.size(),
-              search_key.data(), NORM_SPECIAL_HEADERS[dict_index].c_str(), iter->second.size(), iter->second.data());
+    DBG("[%s] Found variable [%.*s] in %s dictionary with value [%.*s]", __FUNCTION__, int(search_key.size()), search_key.data(),
+        NORM_SPECIAL_HEADERS[dict_index].c_str(), int(iter->second.size()), iter->second.data());
     return iter->second;
   }
 
   size_t cookie_part_divider = (dict_index == HTTP_COOKIE) ? search_key.find(';') : search_key.size();
   if (cookie_part_divider && (cookie_part_divider < (search_key.size() - 1))) {
-    _debugLog(_debug_tag, "[%s] Cookie variable [%s] refers to sub cookie", __FUNCTION__, search_key.c_str());
+    DBG("[%s] Cookie variable [%s] refers to sub cookie", __FUNCTION__, search_key.c_str());
     return _getSubCookieValue(search_key, cookie_part_divider);
   }
 
-  _debugLog(_debug_tag, "[%s] Found no value for dict variable [%s]", __FUNCTION__, name.c_str());
+  DBG("[%s] Found no value for dict variable [%s]", __FUNCTION__, name.c_str());
   return EMPTY_STRING;
 }
 
@@ -283,8 +292,8 @@ Variables::_parseSubCookies()
     AttributeList attr_list;
     Utils::parseAttributes(value.c_str(), value.length(), attr_list, "&");
     for (auto &iter : attr_list) {
-      _debugLog(_debug_tag, "[%s] Inserting query string variable [%.*s] with value [%.*s]", __FUNCTION__, iter.name_len, iter.name,
-                iter.value_len, iter.value);
+      DBG("[%s] Inserting query string variable [%.*s] with value [%.*s]", __FUNCTION__, iter.name_len, iter.name, iter.value_len,
+          iter.value);
       _insert(subcookies, string(iter.name, iter.name_len), string(iter.value, iter.value_len));
     }
   }
@@ -295,7 +304,7 @@ Variables::_getSubCookieValue(const string &cookie_str, size_t cookie_part_divid
 {
   if (!_cookie_jar_created) {
     if (_cookie_str.size() == 0) {
-      _debugLog(_debug_tag, "[%s] Cookie string empty; nothing to construct jar from", __FUNCTION__);
+      DBG("[%s] Cookie string empty; nothing to construct jar from", __FUNCTION__);
       return EMPTY_STRING;
     }
 
@@ -316,19 +325,18 @@ Variables::_getSubCookieValue(const string &cookie_str, size_t cookie_part_divid
 
   StringKeyHash<StringHash>::const_iterator it_cookie = _sub_cookies.find(cookie_name);
   if (it_cookie == _sub_cookies.end()) {
-    _debugLog(_debug_tag, "[%s] Could not find value for cookie [%s]", __FUNCTION__, cookie_name);
+    DBG("[%s] Could not find value for cookie [%s]", __FUNCTION__, cookie_name);
     goto fail;
   }
 
   it_part = it_cookie->second.find(part_name);
   if (it_part == it_cookie->second.end()) {
-    _debugLog(_debug_tag, "[%s] Could not find value for part [%s] of cookie [%.*s]", __FUNCTION__, part_name, cookie_part_divider,
-              cookie_name);
+    DBG("[%s] Could not find value for part [%s] of?cookie [%.*s]", __FUNCTION__, part_name, int(cookie_part_divider), cookie_name);
     goto fail;
   }
 
-  _debugLog(_debug_tag, "[%s] Got value [%s] for cookie name [%.*s] and part [%s]", __FUNCTION__, it_part->second.c_str(),
-            cookie_part_divider, cookie_name, part_name);
+  DBG("[%s] Got value [%s] for cookie name [%.*s] and part [%s]", __FUNCTION__, it_part->second.c_str(), int(cookie_part_divider),
+      cookie_name, part_name);
 
   non_const_cookie_str[cookie_part_divider] = ';'; // restore before returning
 
@@ -379,8 +387,8 @@ Variables::_parseCookieString(const char *str, int str_len)
 
     if (found == true) {
       _insert(_dict_data[HTTP_COOKIE], string(iter.name, iter.name_len), string(iter.value, iter.value_len));
-      _debugLog(_debug_tag, "[%s] Inserted cookie with name [%.*s] and value [%.*s]", __FUNCTION__, iter.name_len, iter.name,
-                iter.value_len, iter.value);
+      DBG("[%s] Inserted cookie with name [%.*s] and value [%.*s]", __FUNCTION__, iter.name_len, iter.name, iter.value_len,
+          iter.value);
     }
   }
 }
@@ -407,7 +415,7 @@ Variables::_parseAcceptLangString(const char *str, int str_len)
       }
       if (lang_len) {
         _insert(_dict_data[HTTP_ACCEPT_LANGUAGE], string(lang, lang_len), EMPTY_STRING);
-        _debugLog(_debug_tag, "[%s] Added language [%.*s]", __FUNCTION__, lang_len, lang);
+        DBG("[%s] Added language [%.*s]", __FUNCTION__, lang_len, lang);
       }
       for (; (i < str_len) && ((isspace(str[i]) || str[i] == ',')); ++i) {
         ;
@@ -430,26 +438,26 @@ Variables::_parseDictVariable(const std::string &variable, const char *&header,
   for (int i = 0; i < (var_size - 1); ++i) {
     if (variable[i] == '{') {
       if (paranth_index != -1) {
-        _debugLog(_debug_tag, "[%s] Cannot have multiple parenthesis in dict variable [%.*s]", __FUNCTION__, var_size, var_ptr);
+        DBG("[%s] Cannot have multiple parenthesis in dict variable [%.*s]", __FUNCTION__, var_size, var_ptr);
         return false;
       }
       paranth_index = i;
     }
     if (variable[i] == '}') {
-      _debugLog(_debug_tag, "[%s] Cannot have multiple parenthesis in dict variable [%.*s]", __FUNCTION__, var_size, var_ptr);
+      DBG("[%s] Cannot have multiple parenthesis in dict variable [%.*s]", __FUNCTION__, var_size, var_ptr);
       return false;
     }
   }
   if (paranth_index == -1) {
-    _debugLog(_debug_tag, "[%s] Could not find opening parenthesis in variable [%.*s]", __FUNCTION__, var_size, var_ptr);
+    DBG("[%s] Could not find opening parenthesis in variable [%.*s]", __FUNCTION__, var_size, var_ptr);
     return false;
   }
   if (paranth_index == 0) {
-    _debugLog(_debug_tag, "[%s] Dict variable has no dict name [%.*s]", __FUNCTION__, var_size, var_ptr);
+    DBG("[%s] Dict variable has no dict name [%.*s]", __FUNCTION__, var_size, var_ptr);
     return false;
   }
   if (paranth_index == (var_size - 2)) {
-    _debugLog(_debug_tag, "[%s] Dict variable has no attribute name [%.*s]", __FUNCTION__, var_size, var_ptr);
+    DBG("[%s] Dict variable has no attribute name [%.*s]", __FUNCTION__, var_size, var_ptr);
     return false;
   }
   header     = var_ptr;
diff --git a/plugins/esi/lib/Variables.h b/plugins/esi/lib/Variables.h
index 0764b131f8a..f6bb40b9253 100644
--- a/plugins/esi/lib/Variables.h
+++ b/plugins/esi/lib/Variables.h
@@ -26,23 +26,17 @@
 #include <list>
 
 #include <cstring>
-#include "ComponentBase.h"
 #include "StringHash.h"
 #include "HttpHeader.h"
 #include "Utils.h"
 
 namespace EsiLib
 {
-class Variables : private ComponentBase
+class Variables
 {
 public:
-  Variables(const char *debug_tag, ComponentBase::Debug debug_func, ComponentBase::Error error_func,
-            Utils::HeaderValueList allowlistCookies)
-    : ComponentBase(debug_tag, debug_func, error_func),
-      _headers_parsed(false),
-      _query_string(""),
-      _query_string_parsed(false),
-      _cookie_jar_created(false)
+  Variables(void *cont_addr, Utils::HeaderValueList allowlistCookies)
+    : _headers_parsed(false), _query_string(""), _query_string_parsed(false), _cookie_jar_created(false), _cont_addr(cont_addr)
   {
     _allowlistCookies.insert(_allowlistCookies.end(), allowlistCookies.begin(), allowlistCookies.end());
   };
@@ -95,7 +89,7 @@ class Variables : private ComponentBase
 
   void clear();
 
-  ~Variables() override { _releaseCookieJar(); };
+  ~Variables() { _releaseCookieJar(); };
 
   // noncopyable
   Variables(const Variables &)            = delete; // non-copyable
@@ -175,5 +169,7 @@ class Variables : private ComponentBase
 
   mutable std::string _cached_sub_cookie_value;
   const std::string &_getSubCookieValue(const std::string &cookie_str, size_t cookie_part_divider) const;
+
+  void *_cont_addr;
 };
 }; // namespace EsiLib
diff --git a/plugins/esi/serverIntercept.cc b/plugins/esi/serverIntercept.cc
index 73afa234787..c32ccca8fa8 100644
--- a/plugins/esi/serverIntercept.cc
+++ b/plugins/esi/serverIntercept.cc
@@ -36,7 +36,7 @@ const int SERVER_INTERCEPT_HEADER_LEN = 12;
 
 using std::string;
 
-#define DEBUG_TAG "plugin_esi_intercept"
+static DbgCtl dbg_ctl{"plugin_esi_intercept"};
 
 struct SContData {
   TSVConn net_vc;
@@ -91,7 +91,7 @@ struct SContData {
 
   ~SContData()
   {
-    TSDebug(DEBUG_TAG, "[%s] Destroying continuation data", __FUNCTION__);
+    Dbg(dbg_ctl, "[%s] Destroying continuation data", __FUNCTION__);
     TSHttpParserDestroy(http_parser);
     if (req_hdr_loc) {
       TSHandleMLocRelease(req_hdr_bufp, TS_NULL_MLOC, req_hdr_loc);
@@ -121,7 +121,7 @@ SContData::init(TSVConn vconn)
   TSHttpHdrTypeSet(req_hdr_bufp, req_hdr_loc, TS_HTTP_TYPE_REQUEST);
 
   initialized = true;
-  TSDebug(DEBUG_TAG, "[%s] SContData initialized!", __FUNCTION__);
+  Dbg(dbg_ctl, "[%s] SContData initialized!", __FUNCTION__);
   return true;
 }
 
@@ -143,7 +143,7 @@ handleRead(SContData *cont_data, bool &read_complete)
     return false;
   }
 
-  TSDebug(DEBUG_TAG, "[%s] Parsed header, avail: %d", __FUNCTION__, avail);
+  Dbg(dbg_ctl, "[%s] Parsed header, avail: %d", __FUNCTION__, avail);
 
   int consumed = 0;
   if (avail > 0) {
@@ -156,7 +156,7 @@ handleRead(SContData *cont_data, bool &read_complete)
         const char *endptr = data + data_len;
         if (TSHttpHdrParseReq(cont_data->http_parser, cont_data->req_hdr_bufp, cont_data->req_hdr_loc, &data, endptr) ==
             TS_PARSE_DONE) {
-          TSDebug(DEBUG_TAG, "[%s] Parsed header", __FUNCTION__);
+          Dbg(dbg_ctl, "[%s] Parsed header", __FUNCTION__);
           TSMLoc content_len_loc =
             TSMimeHdrFieldFind(cont_data->req_hdr_bufp, cont_data->req_hdr_loc, TS_MIME_FIELD_CONTENT_LENGTH, -1);
           if (!content_len_loc) {
@@ -167,19 +167,19 @@ handleRead(SContData *cont_data, bool &read_complete)
           cont_data->req_content_len =
             TSMimeHdrFieldValueIntGet(cont_data->req_hdr_bufp, cont_data->req_hdr_loc, content_len_loc, 0);
           TSHandleMLocRelease(cont_data->req_hdr_bufp, cont_data->req_hdr_loc, content_len_loc);
-          TSDebug(DEBUG_TAG, "[%s] Got content length as %d", __FUNCTION__, cont_data->req_content_len);
+          Dbg(dbg_ctl, "[%s] Got content length as %d", __FUNCTION__, cont_data->req_content_len);
           if (cont_data->req_content_len <= 0) {
             TSError("[server_intercept][%s] Invalid content length [%d]", __FUNCTION__, cont_data->req_content_len);
             return false;
           }
           if (endptr - data) {
-            TSDebug(DEBUG_TAG, "[%s] Appending %ld bytes to body", __FUNCTION__, static_cast<long int>(endptr - data));
+            Dbg(dbg_ctl, "[%s] Appending %ld bytes to body", __FUNCTION__, static_cast<long int>(endptr - data));
             cont_data->body.append(data, endptr - data);
           }
           cont_data->req_hdr_parsed = true;
         }
       } else {
-        TSDebug(DEBUG_TAG, "[%s] Appending %" PRId64 " bytes to body", __FUNCTION__, data_len);
+        Dbg(dbg_ctl, "[%s] Appending %" PRId64 " bytes to body", __FUNCTION__, data_len);
         cont_data->body.append(data, data_len);
       }
       consumed += data_len;
@@ -189,18 +189,18 @@ handleRead(SContData *cont_data, bool &read_complete)
 
   TSIOBufferReaderConsume(cont_data->input.reader, consumed);
 
-  TSDebug(DEBUG_TAG, "[%s] Consumed %d bytes from input vio, avail: %d", __FUNCTION__, consumed, avail);
+  Dbg(dbg_ctl, "[%s] Consumed %d bytes from input vio, avail: %d", __FUNCTION__, consumed, avail);
 
   // Modify the input VIO to reflect how much data we've completed.
   TSVIONDoneSet(cont_data->input.vio, TSVIONDoneGet(cont_data->input.vio) + consumed);
 
   if (static_cast<int>(cont_data->body.size()) == cont_data->req_content_len) {
-    TSDebug(DEBUG_TAG, "[%s] Completely read body of size %d", __FUNCTION__, cont_data->req_content_len);
+    Dbg(dbg_ctl, "[%s] Completely read body of size %d", __FUNCTION__, cont_data->req_content_len);
     read_complete = true;
   } else {
     read_complete = false;
-    TSDebug(DEBUG_TAG, "[%s] Reenabling input vio as %ld bytes still need to be read", __FUNCTION__,
-            static_cast<long int>(cont_data->req_content_len - cont_data->body.size()));
+    Dbg(dbg_ctl, "[%s] Reenabling input vio as %ld bytes still need to be read", __FUNCTION__,
+        static_cast<long int>(cont_data->req_content_len - cont_data->body.size()));
     TSVIOReenable(cont_data->input.vio);
   }
   return true;
@@ -234,7 +234,7 @@ processRequest(SContData *cont_data)
           int value_len;
           value = TSMimeHdrFieldValueStringGet(cont_data->req_hdr_bufp, cont_data->req_hdr_loc, field_loc, i, &value_len);
           if (!value_len) {
-            TSDebug(DEBUG_TAG, "[%s] Error while getting value #%d of header [%.*s]", __FUNCTION__, i, name_len, name);
+            Dbg(dbg_ctl, "[%s] Error while getting value #%d of header [%.*s]", __FUNCTION__, i, name_len, name);
           } else {
             if (reply_header[reply_header.size() - 2] != ':') {
               reply_header.append(", ");
@@ -272,7 +272,7 @@ processRequest(SContData *cont_data)
     return false;
   }
   int total_bytes_written = reply_header.size() + body_size;
-  TSDebug(DEBUG_TAG, "[%s] Wrote reply of size %d", __FUNCTION__, total_bytes_written);
+  Dbg(dbg_ctl, "[%s] Wrote reply of size %d", __FUNCTION__, total_bytes_written);
   TSVIONBytesSet(cont_data->output.vio, total_bytes_written);
 
   TSVIOReenable(cont_data->output.vio);
@@ -282,14 +282,14 @@ processRequest(SContData *cont_data)
 static int
 serverIntercept(TSCont contp, TSEvent event, void *edata)
 {
-  TSDebug(DEBUG_TAG, "[%s] Received event: %d", __FUNCTION__, static_cast<int>(event));
+  Dbg(dbg_ctl, "[%s] Received event: %d", __FUNCTION__, static_cast<int>(event));
 
   SContData *cont_data = static_cast<SContData *>(TSContDataGet(contp));
   bool read_complete   = false;
   bool shutdown        = false;
   switch (event) {
   case TS_EVENT_NET_ACCEPT:
-    TSDebug(DEBUG_TAG, "[%s] Received net accept event", __FUNCTION__);
+    Dbg(dbg_ctl, "[%s] Received net accept event", __FUNCTION__);
     TSAssert(cont_data->initialized == false);
     if (!cont_data->init(static_cast<TSVConn>(edata))) {
       TSError("[server_intercept][%s] Could not initialize continuation data!", __FUNCTION__);
@@ -297,7 +297,7 @@ serverIntercept(TSCont contp, TSEvent event, void *edata)
     }
     break;
   case TS_EVENT_VCONN_READ_READY:
-    TSDebug(DEBUG_TAG, "[%s] Received read ready event", __FUNCTION__);
+    Dbg(dbg_ctl, "[%s] Received read ready event", __FUNCTION__);
     if (!handleRead(cont_data, read_complete)) {
       TSError("[server_intercept][%s] Error while reading from input vio", __FUNCTION__);
       return 0;
@@ -306,14 +306,14 @@ serverIntercept(TSCont contp, TSEvent event, void *edata)
   case TS_EVENT_VCONN_READ_COMPLETE:
   case TS_EVENT_VCONN_EOS:
     // intentional fall-through
-    TSDebug(DEBUG_TAG, "[%s] Received read complete/eos event %d", __FUNCTION__, event);
+    Dbg(dbg_ctl, "[%s] Received read complete/eos event %d", __FUNCTION__, event);
     read_complete = true;
     break;
   case TS_EVENT_VCONN_WRITE_READY:
-    TSDebug(DEBUG_TAG, "[%s] Received write ready event", __FUNCTION__);
+    Dbg(dbg_ctl, "[%s] Received write ready event", __FUNCTION__);
     break;
   case TS_EVENT_VCONN_WRITE_COMPLETE:
-    TSDebug(DEBUG_TAG, "[%s] Received write complete event", __FUNCTION__);
+    Dbg(dbg_ctl, "[%s] Received write complete event", __FUNCTION__);
     shutdown = true;
     break;
   case TS_EVENT_ERROR:
@@ -329,12 +329,12 @@ serverIntercept(TSCont contp, TSEvent event, void *edata)
     if (!processRequest(cont_data)) {
       TSError("[server_intercept][%s] Failed to process process", __FUNCTION__);
     } else {
-      TSDebug(DEBUG_TAG, "[%s] Processed request successfully", __FUNCTION__);
+      Dbg(dbg_ctl, "[%s] Processed request successfully", __FUNCTION__);
     }
   }
 
   if (shutdown) {
-    TSDebug(DEBUG_TAG, "[%s] Completed request processing. Shutting down...", __FUNCTION__);
+    Dbg(dbg_ctl, "[%s] Completed request processing. Shutting down...", __FUNCTION__);
     if (cont_data->net_vc) {
       TSVConnClose(cont_data->net_vc);
     }
@@ -358,6 +358,6 @@ setupServerIntercept(TSHttpTxn txnp)
   TSHttpTxnServerIntercept(contp, txnp);
   TSHttpTxnCntlSet(txnp, TS_HTTP_CNTL_RESPONSE_CACHEABLE, true);
   TSHttpTxnCntlSet(txnp, TS_HTTP_CNTL_REQUEST_CACHEABLE, true);
-  TSDebug(DEBUG_TAG, "[%s] Setup server intercept successfully", __FUNCTION__);
+  Dbg(dbg_ctl, "[%s] Setup server intercept successfully", __FUNCTION__);
   return true;
 }
diff --git a/plugins/esi/test/CMakeLists.txt b/plugins/esi/test/CMakeLists.txt
index cf75e36a6f0..3f4875a233b 100644
--- a/plugins/esi/test/CMakeLists.txt
+++ b/plugins/esi/test/CMakeLists.txt
@@ -16,7 +16,6 @@
 #######################
 
 add_library(esitest
-    print_funcs.cc
     HandlerMap.cc
     StubIncludeHandler.cc
     TestHandlerManager.cc
@@ -24,7 +23,7 @@ add_library(esitest
 target_link_libraries(esitest PUBLIC esi-common esicore)
 
 macro(ADD_ESI_TEST NAME)
-    add_executable(${NAME} ${ARGN})
+    add_executable(${NAME} print_funcs.cc ${ARGN})
     target_link_libraries(${NAME} PRIVATE esitest)
     add_test(NAME ${NAME}_esi COMMAND $<TARGET_FILE:${NAME}>)
 endmacro()
diff --git a/plugins/esi/test/docnode_test.cc b/plugins/esi/test/docnode_test.cc
index b87cdc8edb2..efd691f3e3d 100644
--- a/plugins/esi/test/docnode_test.cc
+++ b/plugins/esi/test/docnode_test.cc
@@ -27,7 +27,6 @@
 #include <catch.hpp>
 
 #include "EsiParser.h"
-#include "print_funcs.h"
 #include "Utils.h"
 
 using std::string;
@@ -148,11 +147,9 @@ checkNodeList2(const DocNodeList &node_list)
 
 TEST_CASE("esi docnode test")
 {
-  Utils::init(&Debug, &Error);
-
   SECTION("Test 1")
   {
-    EsiParser parser("parser_test", &Debug, &Error);
+    EsiParser parser;
     string input_data = "foo <esi:include src=blah /> bar";
 
     DocNodeList node_list;
@@ -183,7 +180,7 @@ TEST_CASE("esi docnode test")
 
   SECTION("Test 2")
   {
-    EsiParser parser("parser_test", &Debug, &Error);
+    EsiParser parser;
     string input_data("<esi:choose>"
                       "<esi:when test=c1>"
                       "<esi:try>"
diff --git a/plugins/esi/test/gzip_test.cc b/plugins/esi/test/gzip_test.cc
index e9153ab199c..7dd3f1e2e73 100644
--- a/plugins/esi/test/gzip_test.cc
+++ b/plugins/esi/test/gzip_test.cc
@@ -27,7 +27,6 @@
 #define CATCH_CONFIG_MAIN
 #include <catch.hpp>
 
-#include "print_funcs.h"
 #include "Utils.h"
 #include "gzip.h"
 
@@ -36,8 +35,6 @@ using namespace EsiLib;
 
 TEST_CASE("test esi plugin - gzip")
 {
-  Utils::init(&Debug, &Error);
-
   SECTION("===================== Test 1")
   {
     const char expected_cdata[] = "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\x03\xf3\x48\xcd\xc9\xc9\x57\x08\xcf\x2f\xca\x49\x51\x04\x00"
diff --git a/plugins/esi/test/parser_test.cc b/plugins/esi/test/parser_test.cc
index 1b5d341ed83..df5e60c7c2e 100644
--- a/plugins/esi/test/parser_test.cc
+++ b/plugins/esi/test/parser_test.cc
@@ -27,7 +27,6 @@
 #include <catch.hpp>
 
 #include "EsiParser.h"
-#include "print_funcs.h"
 #include "Utils.h"
 
 using std::string;
@@ -46,8 +45,7 @@ check_node_attr(const Attribute &attr, const char *name, const char *value)
 
 TEST_CASE("esi parser test")
 {
-  Utils::init(&Debug, &Error);
-  EsiParser parser("parser_test", &Debug, &Error);
+  EsiParser parser;
 
   SECTION("No src attr")
   {
diff --git a/plugins/esi/test/print_funcs.cc b/plugins/esi/test/print_funcs.cc
index 851545c776e..acb2b205a6e 100644
--- a/plugins/esi/test/print_funcs.cc
+++ b/plugins/esi/test/print_funcs.cc
@@ -22,14 +22,31 @@
  */
 
 #include <cstdio>
+#include <cstring>
 #include <cstdarg>
+#include <string>
+#include <map>
 
-#include "print_funcs.h"
+#include <ts/ts.h>
 
 static const int LINE_SIZE = 1024 * 1024;
 
+namespace
+{
+bool fakeDebugLogEnabled;
+}
+
+std::string gFakeDebugLog;
+
 void
-Debug(const char *tag, const char *fmt, ...)
+enableFakeDebugLog()
+{
+  fakeDebugLogEnabled = true;
+  gFakeDebugLog.assign("");
+}
+
+void
+DbgCtl::print(const char *tag, const char * /* file */, const char * /* function */, int /* line */, const char *fmt, ...)
 {
   char buf[LINE_SIZE];
   va_list ap;
@@ -37,10 +54,60 @@ Debug(const char *tag, const char *fmt, ...)
   vsnprintf(buf, LINE_SIZE, fmt, ap);
   printf("Debug (%s): %s\n", tag, buf);
   va_end(ap);
+  if (fakeDebugLogEnabled) {
+    gFakeDebugLog.append(buf);
+  }
+}
+
+class DbgCtl::_RegistryAccessor
+{
+public:
+  // No mutex protection, assuming unit test is single threaded.
+  //
+  static std::map<char const *, bool> &
+  registry()
+  {
+    static std::map<char const *, bool> r;
+    return r;
+  }
+  static inline int ref_count{0};
+};
+
+std::atomic<int> DbgCtl::_config_mode{1};
+
+DbgCtl::_TagData const *
+DbgCtl::_new_reference(char const *tag)
+{
+  ++_RegistryAccessor::ref_count;
+
+  auto it{_RegistryAccessor::registry().find(tag)};
+  if (it == _RegistryAccessor::registry().end()) {
+    char *s = new char[std::strlen(tag) + 1];
+    std::strcpy(s, tag);
+    auto r{_RegistryAccessor::registry().emplace(s, true)}; // Tag is always enabled.
+    it = r.first;
+  }
+  return &(*it);
+}
+
+void
+DbgCtl::_rm_reference()
+{
+  if (!--_RegistryAccessor::ref_count) {
+    for (auto &elem : _RegistryAccessor::registry()) {
+      delete[] elem.first;
+    }
+  }
+}
+
+bool
+DbgCtl::_override_global_on()
+{
+  return false;
 }
 
 void
-Error(const char *fmt, ...)
+tsapi::c::TSError(const char *fmt, ...)
 {
   char buf[LINE_SIZE];
   va_list ap;
diff --git a/plugins/esi/test/print_funcs.h b/plugins/esi/test/print_funcs.h
deleted file mode 100644
index 5aa0c7db010..00000000000
--- a/plugins/esi/test/print_funcs.h
+++ /dev/null
@@ -1,28 +0,0 @@
-/** @file
-
-  A brief file description
-
-  @section license License
-
-  Licensed to the Apache Software Foundation (ASF) under one
-  or more contributor license agreements.  See the NOTICE file
-  distributed with this work for additional information
-  regarding copyright ownership.  The ASF licenses this file
-  to you under the Apache License, Version 2.0 (the
-  "License"); you may not use this file except in compliance
-  with the License.  You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.
- */
-
-#pragma once
-
-void Debug(const char *tag, const char *fmt, ...);
-
-void Error(const char *fmt, ...);
diff --git a/plugins/esi/test/processor_test.cc b/plugins/esi/test/processor_test.cc
index 12d26146189..69414152dfd 100644
--- a/plugins/esi/test/processor_test.cc
+++ b/plugins/esi/test/processor_test.cc
@@ -28,7 +28,6 @@
 
 #include "EsiProcessor.h"
 #include "TestHttpDataFetcher.h"
-#include "print_funcs.h"
 #include "Utils.h"
 #include "HandlerMap.h"
 
@@ -40,12 +39,11 @@ static const int FETCHER_STATIC_DATA_SIZE = 30;
 TEST_CASE("esi processor test")
 {
   Utils::HeaderValueList allowlistCookies;
-  Variables esi_vars("vars", &Debug, &Error, allowlistCookies);
-  HandlerManager handler_mgr("handler_mgr", &Debug, &Error);
+  int dummy;
+  Variables esi_vars(&dummy, allowlistCookies);
+  HandlerManager handler_mgr;
   TestHttpDataFetcher data_fetcher;
-  EsiProcessor esi_proc("processor", "parser", "expression", &Debug, &Error, data_fetcher, esi_vars, handler_mgr);
-
-  Utils::init(&Debug, &Error);
+  EsiProcessor esi_proc(&dummy, data_fetcher, esi_vars, handler_mgr);
 
   SECTION("call sequence")
   {
@@ -849,7 +847,7 @@ TEST_CASE("esi processor test")
 
   SECTION("using packed node list 1")
   {
-    EsiParser parser("parser", &Debug, &Error);
+    EsiParser parser;
     DocNodeList node_list;
     string input_data("<esi:try>"
                       "<esi:attempt>"
@@ -898,7 +896,7 @@ TEST_CASE("esi processor test")
   {
     string input_data("<esi:comment text=\"bleh\"/>");
 
-    EsiParser parser("parser", &Debug, &Error);
+    EsiParser parser;
     DocNodeList node_list;
     string input_data2("<esi:try>"
                        "<esi:attempt>"
@@ -953,7 +951,7 @@ TEST_CASE("esi processor test")
 
   SECTION("using packed node list 3")
   {
-    EsiParser parser("parser", &Debug, &Error);
+    EsiParser parser;
     DocNodeList node_list;
     string input_data("<esi:try>"
                       "<esi:attempt>"
@@ -972,7 +970,7 @@ TEST_CASE("esi processor test")
 
   SECTION("using packed node list 4")
   {
-    EsiParser parser("parser", &Debug, &Error);
+    EsiParser parser;
     DocNodeList node_list;
     string input_data("<esi:try>"
                       "<esi:attempt>"
diff --git a/plugins/esi/test/utils_test.cc b/plugins/esi/test/utils_test.cc
index 5101861ebc5..c7640c98f4d 100644
--- a/plugins/esi/test/utils_test.cc
+++ b/plugins/esi/test/utils_test.cc
@@ -27,7 +27,6 @@
 #define CATCH_CONFIG_MAIN
 #include <catch.hpp>
 
-#include "print_funcs.h"
 #include "Utils.h"
 
 using std::cout;
@@ -51,8 +50,6 @@ checkAttributes(const char *check_id, const AttributeList &attr_list, const char
 
 TEST_CASE("esi utils test")
 {
-  Utils::init(&Debug, &Error);
-
   AttributeList attr_list;
 
   string str1("pos=SKY spaceid=12123");
diff --git a/plugins/esi/test/vars_test.cc b/plugins/esi/test/vars_test.cc
index 3bd49ed28b2..b1576d70f89 100644
--- a/plugins/esi/test/vars_test.cc
+++ b/plugins/esi/test/vars_test.cc
@@ -28,7 +28,6 @@
 #define CATCH_CONFIG_MAIN
 #include <catch.hpp>
 
-#include "print_funcs.h"
 #include "Variables.h"
 #include "Expression.h"
 #include "Utils.h"
@@ -49,24 +48,11 @@ addToHeaderList(const char *strings[], HttpHeaderList &headers)
   }
 }
 
-string gFakeDebugLog;
-
-void
-fakeDebug(const char *tag, const char *fmt, ...)
-{
-  static const int LINE_SIZE = 1024;
-  char buf[LINE_SIZE];
-  va_list ap;
-  va_start(ap, fmt);
-  vsnprintf(buf, LINE_SIZE, fmt, ap);
-  printf("Debug (%s): %s\n", tag, buf);
-  va_end(ap);
-  gFakeDebugLog.append(buf);
-}
+extern void enableFakeDebugLog();
+extern string gFakeDebugLog;
 
 TEST_CASE("esi vars test")
 {
-  Utils::init(&Debug, &Error);
   Utils::HeaderValueList allowlistCookies;
 
   SECTION("Test 1")
@@ -76,7 +62,8 @@ TEST_CASE("esi vars test")
     allowlistCookies.push_back("c3");
     allowlistCookies.push_back("c4");
     allowlistCookies.push_back("c5");
-    Variables esi_vars("vars_test", &Debug, &Error, allowlistCookies);
+    int dummy;
+    Variables esi_vars(&dummy, allowlistCookies);
     const char *strings[] = {"Cookie",
                              "; c1=v1; c2=v2; ;   c3; c4=;    c5=v5  ",
                              "Host",
@@ -144,7 +131,7 @@ TEST_CASE("esi vars test")
     esi_vars.populate(headers);
     esi_vars.populate("a=b&c=d&e=f");
 
-    Expression esi_expr("vars_test", &Debug, &Error, esi_vars);
+    Expression esi_expr(esi_vars);
     REQUIRE(esi_expr.expand(nullptr) == "");
     REQUIRE(esi_expr.expand("") == "");
     REQUIRE(esi_expr.expand("blah") == "blah");
@@ -301,8 +288,9 @@ TEST_CASE("esi vars test")
 
   SECTION("Test 2")
   {
-    gFakeDebugLog.assign("");
-    Variables esi_vars("vars_test", &fakeDebug, &Error, allowlistCookies);
+    enableFakeDebugLog();
+    int dummy;
+    Variables esi_vars(&dummy, allowlistCookies);
 
     esi_vars.populate(HttpHeader("Host", -1, "example.com", -1));
     esi_vars.populate(HttpHeader("Referer", -1, "google.com", -1));
@@ -340,14 +328,15 @@ TEST_CASE("esi vars test")
     allowlistCookies.push_back("t4");
     allowlistCookies.push_back("t5");
     allowlistCookies.push_back("c1");
-    Variables esi_vars("vars_test", &Debug, &Error, allowlistCookies);
+    int dummy;
+    Variables esi_vars(&dummy, allowlistCookies);
 
     esi_vars.populate(HttpHeader("Host", -1, "example.com", -1));
     esi_vars.populate(HttpHeader("Referer", -1, "google.com", -1));
     esi_vars.populate(HttpHeader("Cookie", -1, "age=21; grade=-5; avg=4.3; t1=\" \"; t2=0.0", -1));
     esi_vars.populate(HttpHeader("Cookie", -1, "t3=-0; t4=0; t5=6", -1));
 
-    Expression esi_expr("vars_test", &Debug, &Error, esi_vars);
+    Expression esi_expr(esi_vars);
     REQUIRE(esi_expr.evaluate("$(HTTP_COOKIE{age}) >= -9"));
     REQUIRE(esi_expr.evaluate("$(HTTP_COOKIE{age}) > 9"));
     REQUIRE(esi_expr.evaluate("$(HTTP_COOKIE{age}) < 22"));
@@ -383,7 +372,8 @@ TEST_CASE("esi vars test")
     allowlistCookies.push_back("F");
     allowlistCookies.push_back("a");
     allowlistCookies.push_back("c");
-    Variables esi_vars("vars_test", &Debug, &Error, allowlistCookies);
+    int dummy;
+    Variables esi_vars(&dummy, allowlistCookies);
     string cookie_str("FPS=dl; mb=d=OPsv7rvU4FFaAOoIRi75BBuqdMdbMLFuDwQmk6nKrCgno7L4xuN44zm7QBQJRmQSh8ken6GSVk8-&v=1; C=mg=1; "
                       "Y=v=1&n=fmaptagvuff50&l=fc0d94i7/o&p=m2f0000313000400&r=8j&lg=en-US&intl=us; "
                       "F=a=4KvLV9IMvTJnIAqCk25y9Use6hnPALtUf3n78PihlcIqvmzoW.Ax8UyW8_oxtgFNrrdmooqZmPa7WsX4gE."
@@ -425,7 +415,8 @@ TEST_CASE("esi vars test")
 
   SECTION("Test 5")
   {
-    Variables esi_vars("vars_test", &Debug, &Error, allowlistCookies);
+    int dummy;
+    Variables esi_vars(&dummy, allowlistCookies);
     esi_vars.populate(HttpHeader("hdr1", -1, "hval1", -1));
     esi_vars.populate(HttpHeader("Hdr2", -1, "hval2", -1));
     esi_vars.populate(HttpHeader("@Intenal-hdr1", -1, "internal-hval1", -1));
@@ -442,7 +433,8 @@ TEST_CASE("esi vars test")
   SECTION("Test 6")
   {
     allowlistCookies.push_back("*");
-    Variables esi_vars("vars_test", &Debug, &Error, allowlistCookies);
+    int dummy;
+    Variables esi_vars(&dummy, allowlistCookies);
 
     esi_vars.populate(HttpHeader("Host", -1, "example.com", -1));
     esi_vars.populate(HttpHeader("Cookie", -1, "age=21; grade=-5; avg=4.3; t1=\" \"; t2=0.0", -1));
diff --git a/plugins/experimental/access_control/common.cc b/plugins/experimental/access_control/common.cc
index f2570e6015c..dbbd17c2e6d 100644
--- a/plugins/experimental/access_control/common.cc
+++ b/plugins/experimental/access_control/common.cc
@@ -34,6 +34,12 @@ PrintToStdErr(const char *fmt, ...)
   vfprintf(stderr, fmt, args);
   va_end(args);
 }
+#else
+
+namespace access_control_ns
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
 
 #endif /* ACCESS_CONTROL_UNIT_TEST */
 
diff --git a/plugins/experimental/access_control/common.h b/plugins/experimental/access_control/common.h
index e6f6f56e812..0b7f922c419 100644
--- a/plugins/experimental/access_control/common.h
+++ b/plugins/experimental/access_control/common.h
@@ -54,16 +54,23 @@ void PrintToStdErr(const char *fmt, ...);
 #else /* ACCESS_CONTROL_UNIT_TEST */
 #include "ts/ts.h"
 
-#define AccessControlDebug(fmt, ...)                                                      \
-  do {                                                                                    \
-    TSDebug(PLUGIN_NAME, "%s:%d:%s() " fmt, __FILE__, __LINE__, __func__, ##__VA_ARGS__); \
+#define AccessControlDebug(fmt, ...)                                              \
+  do {                                                                            \
+    Dbg(dbg_ctl, "%s:%d:%s() " fmt, __FILE__, __LINE__, __func__, ##__VA_ARGS__); \
   } while (0)
 
-#define AccessControlError(fmt, ...)                                                      \
-  do {                                                                                    \
-    TSError("(%s) " fmt, PLUGIN_NAME, ##__VA_ARGS__);                                     \
-    TSDebug(PLUGIN_NAME, "%s:%d:%s() " fmt, __FILE__, __LINE__, __func__, ##__VA_ARGS__); \
+#define AccessControlError(fmt, ...)                                              \
+  do {                                                                            \
+    TSError("(%s) " fmt, PLUGIN_NAME, ##__VA_ARGS__);                             \
+    Dbg(dbg_ctl, "%s:%d:%s() " fmt, __FILE__, __LINE__, __func__, ##__VA_ARGS__); \
   } while (0)
+
+namespace access_control_ns
+{
+extern DbgCtl dbg_ctl;
+}
+using namespace access_control_ns;
+
 #endif /* ACCESS_CONTROL_UNIT_TEST */
 
 int string2int(const StringView &s);
diff --git a/plugins/experimental/access_control/headers.cc b/plugins/experimental/access_control/headers.cc
index 1d5089b05f3..a4681fbb9fa 100644
--- a/plugins/experimental/access_control/headers.cc
+++ b/plugins/experimental/access_control/headers.cc
@@ -176,7 +176,7 @@ setHeader(TSMBuffer bufp, TSMLoc hdrLoc, const char *header, int headerlen, cons
 /**
  * @brief Dump a header on stderr
  *
- * Useful together with TSDebug().
+ * Useful together with Dbg().
  *
  * @param bufp request's buffer
  * @param hdrLoc request's header location
diff --git a/plugins/experimental/cache_fill/background_fetch.cc b/plugins/experimental/cache_fill/background_fetch.cc
index 2b4a655dad1..a4897be22ab 100644
--- a/plugins/experimental/cache_fill/background_fetch.cc
+++ b/plugins/experimental/cache_fill/background_fetch.cc
@@ -40,6 +40,11 @@
 #include "background_fetch.h"
 using OutstandingRequests = std::unordered_map<std::string, bool>;
 
+namespace cache_fill_ns
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 ///////////////////////////////////////////////////////////////////////////
 // Set a header to a specific value. This will avoid going to through a
 // remove / add sequence in case of an existing header.
@@ -86,7 +91,7 @@ set_header(TSMBuffer bufp, TSMLoc hdr_loc, const char *header, int len, const ch
 }
 
 ///////////////////////////////////////////////////////////////////////////
-// Dump a header on stderr, useful together with TSDebug().
+// Dump a header on stderr, useful together with Dbg().
 static void
 dump_headers(TSMBuffer bufp, TSMLoc hdr_loc)
 {
@@ -106,7 +111,7 @@ dump_headers(TSMBuffer bufp, TSMLoc hdr_loc)
   do {
     const char *block_start = TSIOBufferBlockReadStart(block, reader, &block_avail);
     if (block_avail > 0) {
-      TSDebug(PLUGIN_NAME, "Headers are:\n%.*s", static_cast<int>(block_avail), block_start);
+      Dbg(dbg_ctl, "Headers are:\n%.*s", static_cast<int>(block_avail), block_start);
     }
     TSIOBufferReaderConsume(reader, block_avail);
     block = TSIOBufferReaderStart(reader);
@@ -156,7 +161,7 @@ BgFetchData::initialize(TSMBuffer request, TSMLoc req_hdr, TSHttpTxn txnp)
           if (TS_SUCCESS == TSHttpTxnCacheLookupUrlGet(txnp, request, c_url)) {
             url = TSUrlStringGet(request, c_url, &len);
             TSHandleMLocRelease(request, TS_NULL_MLOC, c_url);
-            TSDebug(PLUGIN_NAME, "Cache URL is %.*s", len, url);
+            Dbg(dbg_ctl, "Cache URL is %.*s", len, url);
           }
         }
 
@@ -169,7 +174,7 @@ BgFetchData::initialize(TSMBuffer request, TSMLoc req_hdr, TSHttpTxn txnp)
             const char *hostp = TSUrlHostGet(mbuf, url_loc, &len);
 
             if (set_header(mbuf, hdr_loc, TS_MIME_FIELD_HOST, TS_MIME_LEN_HOST, hostp, len)) {
-              TSDebug(PLUGIN_NAME, "Set header Host: %.*s", len, hostp);
+              Dbg(dbg_ctl, "Set header Host: %.*s", len, hostp);
             }
             ret = true;
           }
@@ -218,24 +223,24 @@ cont_bg_fetch(TSCont contp, TSEvent event, void * /* edata ATS_UNUSED */)
   case TS_EVENT_IMMEDIATE:
   case TS_EVENT_TIMEOUT:
     // Debug info for this particular bg fetch (put all debug in here please)
-    if (TSIsDebugTagSet(PLUGIN_NAME)) {
+    if (dbg_ctl.on()) {
       char buf[INET6_ADDRSTRLEN];
       const sockaddr *sockaddress = reinterpret_cast<const sockaddr *>(&data->client_ip);
 
       switch (sockaddress->sa_family) {
       case AF_INET:
         inet_ntop(AF_INET, &(((struct sockaddr_in *)sockaddress)->sin_addr), buf, INET_ADDRSTRLEN);
-        TSDebug(PLUGIN_NAME, "Client IPv4 = %s", buf);
+        Dbg(dbg_ctl, "Client IPv4 = %s", buf);
         break;
       case AF_INET6:
         inet_ntop(AF_INET6, &(((struct sockaddr_in6 *)sockaddress)->sin6_addr), buf, INET6_ADDRSTRLEN);
-        TSDebug(PLUGIN_NAME, "Client IPv6 = %s", buf);
+        Dbg(dbg_ctl, "Client IPv6 = %s", buf);
         break;
       default:
         TSError("[%s] Unknown address family %d", PLUGIN_NAME, sockaddress->sa_family);
         break;
       }
-      TSDebug(PLUGIN_NAME, "Starting background fetch, replaying:");
+      Dbg(dbg_ctl, "Starting background fetch, replaying:");
       dump_headers(data->mbuf, data->hdr_loc);
     }
 
@@ -257,7 +262,7 @@ cont_bg_fetch(TSCont contp, TSEvent event, void * /* edata ATS_UNUSED */)
   case TS_EVENT_VCONN_WRITE_COMPLETE:
     // TSVConnShutdown(data->vc, 0, 1);
     // TSVIOReenable(data->w_vio);
-    TSDebug(PLUGIN_NAME, "Write Complete");
+    Dbg(dbg_ctl, "Write Complete");
     break;
 
   case TS_EVENT_VCONN_READ_READY:
@@ -273,13 +278,13 @@ cont_bg_fetch(TSCont contp, TSEvent event, void * /* edata ATS_UNUSED */)
   case TS_EVENT_VCONN_INACTIVITY_TIMEOUT:
   case TS_EVENT_ERROR:
     if (event == TS_EVENT_VCONN_INACTIVITY_TIMEOUT) {
-      TSDebug(PLUGIN_NAME, "Encountered Inactivity Timeout");
+      Dbg(dbg_ctl, "Encountered Inactivity Timeout");
       TSVConnAbort(data->vc, TS_VC_CLOSE_ABORT);
     } else {
       TSVConnClose(data->vc);
     }
 
-    TSDebug(PLUGIN_NAME, "Closing down background transaction, event= %s(%d)", TSHttpEventNameLookup(event), event);
+    Dbg(dbg_ctl, "Closing down background transaction, event= %s(%d)", TSHttpEventNameLookup(event), event);
     avail = TSIOBufferReaderAvail(data->resp_io_buf_reader);
     data->addBytes(avail);
     TSIOBufferReaderConsume(data->resp_io_buf_reader, avail);
@@ -291,7 +296,7 @@ cont_bg_fetch(TSCont contp, TSEvent event, void * /* edata ATS_UNUSED */)
     break;
 
   default:
-    TSDebug(PLUGIN_NAME, "Unhandled event: %s (%d)", TSHttpEventNameLookup(event), event);
+    Dbg(dbg_ctl, "Unhandled event: %s (%d)", TSHttpEventNameLookup(event), event);
     break;
   }
 
diff --git a/plugins/experimental/cache_fill/background_fetch.h b/plugins/experimental/cache_fill/background_fetch.h
index cedebf068c2..4c87946e30e 100644
--- a/plugins/experimental/cache_fill/background_fetch.h
+++ b/plugins/experimental/cache_fill/background_fetch.h
@@ -43,6 +43,12 @@
 using OutstandingRequests = std::unordered_map<std::string, bool>;
 const char PLUGIN_NAME[]  = "cache_fill";
 
+namespace cache_fill_ns
+{
+extern DbgCtl dbg_ctl;
+}
+using namespace cache_fill_ns;
+
 class BgFetchState
 {
 public:
@@ -73,7 +79,7 @@ class BgFetchState
     }
     TSMutexUnlock(_lock);
 
-    TSDebug(PLUGIN_NAME, "BgFetchState.acquire(): ret = %d, url = %s", ret, url.c_str());
+    Dbg(dbg_ctl, "BgFetchState.acquire(): ret = %d, url = %s", ret, url.c_str());
 
     return ret;
   }
diff --git a/plugins/experimental/cache_fill/cache_fill.cc b/plugins/experimental/cache_fill/cache_fill.cc
index c7b97f50b29..f29fc3e78d9 100644
--- a/plugins/experimental/cache_fill/cache_fill.cc
+++ b/plugins/experimental/cache_fill/cache_fill.cc
@@ -76,12 +76,12 @@ cont_check_cacheable(TSHttpTxn txnp)
     TSError("[%s] Couldn't get cache status of object", PLUGIN_NAME);
     return false;
   }
-  TSDebug(PLUGIN_NAME, "lookup status: %s", getCacheLookupResultName(static_cast<TSCacheLookupResult>(lookupStatus)));
+  Dbg(dbg_ctl, "lookup status: %s", getCacheLookupResultName(static_cast<TSCacheLookupResult>(lookupStatus)));
   bool ret = false;
   if (TS_CACHE_LOOKUP_MISS == lookupStatus || TS_CACHE_LOOKUP_HIT_STALE == lookupStatus) {
     bool const nostore = TSHttpTxnServerRespNoStoreGet(txnp);
 
-    TSDebug(PLUGIN_NAME, "is nostore set %d", nostore);
+    Dbg(dbg_ctl, "is nostore set %d", nostore);
     if (!nostore) {
       TSMBuffer request;
       TSMLoc req_hdr;
@@ -89,7 +89,7 @@ cont_check_cacheable(TSHttpTxn txnp)
         BgFetchData *data = new BgFetchData();
         // Initialize the data structure (can fail) and acquire a privileged lock on the URL
         if (data->initialize(request, req_hdr, txnp) && data->acquireUrl()) {
-          TSDebug(PLUGIN_NAME, "scheduling background fetch");
+          Dbg(dbg_ctl, "scheduling background fetch");
           data->schedule();
           ret = true;
         } else {
@@ -115,14 +115,14 @@ cont_handle_cache(TSCont contp, TSEvent event, void *edata)
     bool const requested = cont_check_cacheable(txnp);
     if (requested) // Made a background fetch request, do not cache the response
     {
-      TSDebug(PLUGIN_NAME, "setting no store");
+      Dbg(dbg_ctl, "setting no store");
       TSHttpTxnCntlSet(txnp, TS_HTTP_CNTL_SERVER_NO_STORE, true);
       TSHttpTxnCacheLookupStatusSet(txnp, TS_CACHE_LOOKUP_MISS);
     }
 
   } else {
     TSError("[%s] Unknown event for this plugin %d", PLUGIN_NAME, event);
-    TSDebug(PLUGIN_NAME, "unknown event for this plugin %d", event);
+    Dbg(dbg_ctl, "unknown event for this plugin %d", event);
   }
 
   // Reenable and continue with the state machine.
@@ -139,7 +139,7 @@ TSReturnCode
 TSRemapInit(TSRemapInterface *api_info, char *errbuf, int errbuf_size)
 {
   CHECK_REMAP_API_COMPATIBILITY(api_info, errbuf, errbuf_size);
-  TSDebug(PLUGIN_NAME, "cache fill remap is successfully initialized");
+  Dbg(dbg_ctl, "cache fill remap is successfully initialized");
   return TS_SUCCESS;
 }
 
@@ -172,7 +172,7 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo * /* rri */)
   }
   TSCont const cont = static_cast<TSCont>(ih);
   TSHttpTxnHookAdd(txnp, TS_HTTP_CACHE_LOOKUP_COMPLETE_HOOK, cont);
-  TSDebug(PLUGIN_NAME, "TSRemapDoRemap() added hook");
+  Dbg(dbg_ctl, "TSRemapDoRemap() added hook");
 
   return TSREMAP_NO_REMAP;
 }
diff --git a/plugins/experimental/cache_key_genid/cache_key_genid.cc b/plugins/experimental/cache_key_genid/cache_key_genid.cc
index cb4db03b64d..81911683454 100644
--- a/plugins/experimental/cache_key_genid/cache_key_genid.cc
+++ b/plugins/experimental/cache_key_genid/cache_key_genid.cc
@@ -66,7 +66,7 @@ get_genid(char *host)
 
   /* open the database */
   if (!kcdbopen(db, genid_kyoto_db, KCOREADER | KCONOLOCK)) {
-    TSDebug(PLUGIN_NAME, "could not open the genid database %s", genid_kyoto_db);
+    Dbg(dbg_ctl, "could not open the genid database %s", genid_kyoto_db);
     TSError("[%s] could not open the genid database %s: %s", PLUGIN_NAME, genid_kyoto_db, strerror(errno));
     return 0;
   }
@@ -74,12 +74,12 @@ get_genid(char *host)
   vbuf = kcdbget(db, host, strlen(host), &vsiz);
 
   if (vbuf) {
-    TSDebug(PLUGIN_NAME, "kcdbget(%s) = %s", host, vbuf);
+    Dbg(dbg_ctl, "kcdbget(%s) = %s", host, vbuf);
     answer = (int)strtol(vbuf, nullptr, 10);
     kcfree(vbuf);
   } else {
     host_size = strlen(host);
-    TSDebug(PLUGIN_NAME, "kcdbget(%s) - no record found, len(%d)", host, host_size);
+    Dbg(dbg_ctl, "kcdbget(%s) - no record found, len(%d)", host, host_size);
     answer = 0;
   }
 
@@ -103,7 +103,7 @@ handle_hook(TSCont *contp, TSEvent event, void *edata)
 
   switch (event) {
   case TS_EVENT_HTTP_READ_REQUEST_HDR:
-    TSDebug(PLUGIN_NAME, "handling TS_EVENT_HTTP_READ_REQUEST_HDR");
+    Dbg(dbg_ctl, "handling TS_EVENT_HTTP_READ_REQUEST_HDR");
 
     if (ok) {
       url = TSHttpTxnEffectiveUrlStringGet(txnp, &url_length);
@@ -122,10 +122,10 @@ handle_hook(TSCont *contp, TSEvent event, void *edata)
     }
 
     if (ok) {
-      TSDebug(PLUGIN_NAME, "From url (%s) discovered host (%s)", url, host);
+      Dbg(dbg_ctl, "From url (%s) discovered host (%s)", url, host);
       if ((gen_id = get_genid(host)) != 0) {
         if (TSHttpTxnConfigIntSet(txnp, TS_CONFIG_HTTP_CACHE_GENERATION, gen_id) != TS_SUCCESS) {
-          TSDebug(PLUGIN_NAME, "Error, unable to modify cache url");
+          Dbg(dbg_ctl, "Error, unable to modify cache url");
           TSError("[%s] Unable to set cache generation for %s to %d", PLUGIN_NAME, url, gen_id);
           ok = 0;
         }
diff --git a/plugins/experimental/cert_reporting_tool/cert_reporting_tool.cc b/plugins/experimental/cert_reporting_tool/cert_reporting_tool.cc
index ece483d38a2..4027417cee1 100644
--- a/plugins/experimental/cert_reporting_tool/cert_reporting_tool.cc
+++ b/plugins/experimental/cert_reporting_tool/cert_reporting_tool.cc
@@ -36,6 +36,11 @@
 #define PLUGIN_NAME "cert_reporting_tool"
 TSTextLogObject cert_reporting_log;
 
+namespace
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 char *
 asn1_string_extract(ASN1_STRING *s)
 {
@@ -130,8 +135,8 @@ dump_context(const char *ca_path, const char *ck_path)
         length = BIO_get_mem_data(time_bio, &data);
         time_s = std::string(data, length);
         BIO_free(time_bio);
-        TSDebug(PLUGIN_NAME, "LookupName: %s:%s, Subject: %s. SAN: %s. Serial: %s. NotAfter: %s.", ca_path, ck_path,
-                subject_s.c_str(), san_s.c_str(), serial_s.c_str(), time_s.c_str());
+        Dbg(dbg_ctl, "LookupName: %s:%s, Subject: %s. SAN: %s. Serial: %s. NotAfter: %s.", ca_path, ck_path, subject_s.c_str(),
+            san_s.c_str(), serial_s.c_str(), time_s.c_str());
         TSTextLogObjectWrite(cert_reporting_log, "LookupName: %s:%s, Subject: %s. SAN: %s. Serial: %s. NotAfter: %s.", ca_path,
                              ck_path, subject_s.c_str(), san_s.c_str(), serial_s.c_str(), time_s.c_str());
       }
@@ -186,6 +191,6 @@ TSPluginInit(int argc, const char *argv[])
     TSError("[%s] Failed to create log file", PLUGIN_NAME);
     return;
   }
-  TSDebug(PLUGIN_NAME, "Initialized.");
+  Dbg(dbg_ctl, "Initialized.");
   TSLifecycleHookAdd(TS_LIFECYCLE_MSG_HOOK, TSContCreate(CB_context_dump, nullptr));
 }
diff --git a/plugins/experimental/cookie_remap/cookie_remap.cc b/plugins/experimental/cookie_remap/cookie_remap.cc
index 86005959460..42e7de86a19 100644
--- a/plugins/experimental/cookie_remap/cookie_remap.cc
+++ b/plugins/experimental/cookie_remap/cookie_remap.cc
@@ -41,6 +41,11 @@ using namespace std;
 
 #define MY_NAME "cookie_remap"
 
+namespace
+{
+DbgCtl dbg_ctl{MY_NAME};
+}
+
 const int OVECCOUNT = 30; // We support $1 - $9 only, and this needs to be 3x that
 
 class UrlComponents
@@ -254,12 +259,12 @@ class subop
       bucket("")
 
   {
-    TSDebug(MY_NAME, "subop constructor called");
+    Dbg(dbg_ctl, "subop constructor called");
   }
 
   ~subop()
   {
-    TSDebug(MY_NAME, "subop destructor called");
+    Dbg(dbg_ctl, "subop destructor called");
     if (regex) {
       pcre_free(regex);
     }
@@ -429,19 +434,19 @@ class subop
   void
   printSubOp() const
   {
-    TSDebug(MY_NAME, "\t+++subop+++");
-    TSDebug(MY_NAME, "\t\tcookie: %s", cookie.c_str());
-    TSDebug(MY_NAME, "\t\toperation: %s", operation.c_str());
+    Dbg(dbg_ctl, "\t+++subop+++");
+    Dbg(dbg_ctl, "\t\tcookie: %s", cookie.c_str());
+    Dbg(dbg_ctl, "\t\toperation: %s", operation.c_str());
     if (str_match.size() > 0) {
-      TSDebug(MY_NAME, "\t\tmatching: %s", str_match.c_str());
+      Dbg(dbg_ctl, "\t\tmatching: %s", str_match.c_str());
     }
     if (regex) {
-      TSDebug(MY_NAME, "\t\tregex: %s", regex_string.c_str());
+      Dbg(dbg_ctl, "\t\tregex: %s", regex_string.c_str());
     }
     if (bucket.size() > 0) {
-      TSDebug(MY_NAME, "\t\tbucket: %s", bucket.c_str());
-      TSDebug(MY_NAME, "\t\ttaking: %d", how_many);
-      TSDebug(MY_NAME, "\t\tout of: %d", out_of);
+      Dbg(dbg_ctl, "\t\tbucket: %s", bucket.c_str());
+      Dbg(dbg_ctl, "\t\ttaking: %d", how_many);
+      Dbg(dbg_ctl, "\t\tout of: %d", out_of);
     }
   }
 
@@ -469,11 +474,11 @@ using SubOpQueue = std::vector<const subop *>;
 class op
 {
 public:
-  op() { TSDebug(MY_NAME, "op constructor called"); }
+  op() { Dbg(dbg_ctl, "op constructor called"); }
 
   ~op()
   {
-    TSDebug(MY_NAME, "op destructor called");
+    Dbg(dbg_ctl, "op destructor called");
     for (auto &subop : subops) {
       delete subop;
     }
@@ -522,15 +527,15 @@ class op
   void
   printOp() const
   {
-    TSDebug(MY_NAME, "++++operation++++");
-    TSDebug(MY_NAME, "sending to: %s", sendto.c_str());
-    TSDebug(MY_NAME, "if these operations match: ");
+    Dbg(dbg_ctl, "++++operation++++");
+    Dbg(dbg_ctl, "sending to: %s", sendto.c_str());
+    Dbg(dbg_ctl, "if these operations match: ");
 
     for (auto subop : subops) {
       subop->printSubOp();
     }
     if (else_sendto.size() > 0) {
-      TSDebug(MY_NAME, "else: %s", else_sendto.c_str());
+      Dbg(dbg_ctl, "else: %s", else_sendto.c_str());
     }
   }
 
@@ -550,7 +555,7 @@ class op
                              // cookie, or
                              // request url
 
-    TSDebug(MY_NAME, "starting to process a new operation");
+    Dbg(dbg_ctl, "starting to process a new operation");
 
     for (auto subop : subops) {
       // subop* s = *it;
@@ -559,24 +564,24 @@ class op
 
       c = subop->getCookieName();
       if (c.length()) {
-        TSDebug(MY_NAME, "processing cookie: %s", c.c_str());
+        Dbg(dbg_ctl, "processing cookie: %s", c.c_str());
 
         size_t period_pos = c.find_first_of('.');
 
         if (period_pos == std::string::npos) { // not a sublevel
                                                // cookie name
-          TSDebug(MY_NAME, "processing non-sublevel cookie");
+          Dbg(dbg_ctl, "processing non-sublevel cookie");
 
           cookie_found = jar.get_full(c, cookie_data);
-          TSDebug(MY_NAME, "full cookie: %s", cookie_data.c_str());
+          Dbg(dbg_ctl, "full cookie: %s", cookie_data.c_str());
           object_name = c;
         } else { // is in the format FOO.BAR
           std::string cookie_main   = c.substr(0, period_pos);
           std::string cookie_subkey = c.substr(period_pos + 1);
 
-          TSDebug(MY_NAME, "processing sublevel cookie");
-          TSDebug(MY_NAME, "c key: %s", cookie_main.c_str());
-          TSDebug(MY_NAME, "c subkey: %s", cookie_subkey.c_str());
+          Dbg(dbg_ctl, "processing sublevel cookie");
+          Dbg(dbg_ctl, "c key: %s", cookie_main.c_str());
+          Dbg(dbg_ctl, "c subkey: %s", cookie_subkey.c_str());
 
           cookie_found = jar.get_part(cookie_main, cookie_subkey, cookie_data);
           object_name  = cookie_main + " . " + cookie_subkey;
@@ -588,16 +593,16 @@ class op
         if (cookie_found == false) { // cookie name or sub-key not found
                                      // inside cookies
           if (subop_type == NOTEXISTS) {
-            TSDebug(MY_NAME,
-                    "cookie %s was not "
-                    "found (and we wanted "
-                    "that)",
-                    object_name.c_str());
+            Dbg(dbg_ctl,
+                "cookie %s was not "
+                "found (and we wanted "
+                "that)",
+                object_name.c_str());
             continue; // we can short
                       // circuit more
                       // testing
           }
-          TSDebug(MY_NAME, "cookie %s was not found", object_name.c_str());
+          Dbg(dbg_ctl, "cookie %s was not found", object_name.c_str());
           retval &= 0;
           break;
         } else {
@@ -605,28 +610,28 @@ class op
           if (subop_type == NOTEXISTS) { // we found the cookie
                                          // but are asking
             // for non existence
-            TSDebug(MY_NAME,
-                    "cookie %s was found, "
-                    "but operation "
-                    "requires "
-                    "non-existence",
-                    object_name.c_str());
+            Dbg(dbg_ctl,
+                "cookie %s was found, "
+                "but operation "
+                "requires "
+                "non-existence",
+                object_name.c_str());
             retval &= 0;
             break;
           }
 
           if (subop_type == EXISTS) {
-            TSDebug(MY_NAME, "cookie %s was found", object_name.c_str()); // got what
-                                                                          // we were
-                                                                          // looking
-                                                                          // for
-            continue;                                                     // we can short
-                                                                          // circuit more
-                                                                          // testing
+            Dbg(dbg_ctl, "cookie %s was found", object_name.c_str()); // got what
+                                                                      // we were
+                                                                      // looking
+                                                                      // for
+            continue;                                                 // we can short
+                                                                      // circuit more
+                                                                      // testing
           }
         } // handled EXISTS / NOTEXISTS subops
 
-        TSDebug(MY_NAME, "processing cookie data: \"%s\"", cookie_data.c_str());
+        Dbg(dbg_ctl, "processing cookie data: \"%s\"", cookie_data.c_str());
       } else if (target != PRE_REMAP_URI) {
         target = URI;
       }
@@ -639,9 +644,9 @@ class op
       if (!rri) { // too dangerous to continue without the
                   // rri; hopefully that
         // never happens
-        TSDebug(MY_NAME, "request info structure is "
-                         "empty; can't continue "
-                         "processing this subop");
+        Dbg(dbg_ctl, "request info structure is "
+                     "empty; can't continue "
+                     "processing this subop");
         retval &= 0;
         break;
       }
@@ -657,7 +662,7 @@ class op
       const std::string &string_to_match(use_url ? request_uri : cookie_data);
       if (use_url) {
         request_uri = req_url.path(target == PRE_REMAP_URI);
-        TSDebug(MY_NAME, "process req_url.path = %s", request_uri.c_str());
+        Dbg(dbg_ctl, "process req_url.path = %s", request_uri.c_str());
         if (request_uri.length() && request_uri[0] != '/') {
           request_uri.insert(0, 1, '/');
         }
@@ -676,10 +681,10 @@ class op
       // OPERATION::string matching
       if (subop_type == STRING) {
         if (string_to_match == subop->getStringMatch()) {
-          TSDebug(MY_NAME, "string match succeeded");
+          Dbg(dbg_ctl, "string match succeeded");
           continue;
         } else {
-          TSDebug(MY_NAME, "string match failed");
+          Dbg(dbg_ctl, "string match failed");
           retval &= 0;
           break;
         }
@@ -703,12 +708,12 @@ class op
           // sucks we can't precalculate this
           // like regex_remap.
 
-          TSDebug(MY_NAME, "found %d matches", ret);
-          TSDebug(MY_NAME,
-                  "successful regex "
-                  "match of: %s with %s "
-                  "rewriting string: %s",
-                  string_to_match.c_str(), subop->getRegexString().c_str(), sendto.c_str());
+          Dbg(dbg_ctl, "found %d matches", ret);
+          Dbg(dbg_ctl,
+              "successful regex "
+              "match of: %s with %s "
+              "rewriting string: %s",
+              string_to_match.c_str(), subop->getRegexString().c_str(), sendto.c_str());
 
           // replace the $(1-9) in the sendto url
           // as necessary
@@ -723,13 +728,13 @@ class op
                 dest += string_to_match.substr(ovector[ix * 2], ovector[ix * 2 + 1] - ovector[ix * 2]);
                 ppos  = pos + 2;
               } else {
-                TSDebug(MY_NAME,
-                        "bad "
-                        "rewriting "
-                        "string, "
-                        "for group "
-                        "%d: %s",
-                        ix, sendto.c_str());
+                Dbg(dbg_ctl,
+                    "bad "
+                    "rewriting "
+                    "string, "
+                    "for group "
+                    "%d: %s",
+                    ix, sendto.c_str());
               }
             }
             pos = sendto.find('$', pos + 1);
@@ -737,11 +742,11 @@ class op
           dest += sendto.substr(ppos);
           continue; // next subop, please
         } else {
-          TSDebug(MY_NAME,
-                  "could not match "
-                  "regular expression "
-                  "%s to %s",
-                  subop->getRegexString().c_str(), string_to_match.c_str());
+          Dbg(dbg_ctl,
+              "could not match "
+              "regular expression "
+              "%s to %s",
+              subop->getRegexString().c_str(), string_to_match.c_str());
           retval &= 0;
           break;
         }
@@ -755,27 +760,27 @@ class op
         uint32_t hash;
 
         if (taking == 0 || out_of == 0) {
-          TSDebug(MY_NAME,
-                  "taking %d out of %d "
-                  "makes no sense?!",
-                  taking, out_of);
+          Dbg(dbg_ctl,
+              "taking %d out of %d "
+              "makes no sense?!",
+              taking, out_of);
           retval &= 0;
           break;
         }
 
         hash = hash_fnv32_buckets(cookie_data.c_str(), cookie_data.size(), out_of);
-        TSDebug(MY_NAME,
-                "we hashed this to bucket: %u "
-                "taking: %u out of: %u",
-                hash, taking, out_of);
+        Dbg(dbg_ctl,
+            "we hashed this to bucket: %u "
+            "taking: %u out of: %u",
+            hash, taking, out_of);
 
         if (hash < taking) {
-          TSDebug(MY_NAME, "we hashed in the range, yay!");
+          Dbg(dbg_ctl, "we hashed in the range, yay!");
           continue; // we hashed in the range
         } else {
-          TSDebug(MY_NAME, "we didn't hash in the "
-                           "range requested, so "
-                           "sad");
+          Dbg(dbg_ctl, "we didn't hash in the "
+                       "range requested, so "
+                       "sad");
           retval &= 0;
           break;
         }
@@ -825,11 +830,11 @@ build_op(op &o, OpMap const &q)
     std::string const &key = pr.first;
     std::string const &val = pr.second;
 
-    TSDebug(MY_NAME, "build_op: key=%s val=%s", key.c_str(), val.c_str());
+    Dbg(dbg_ctl, "build_op: key=%s val=%s", key.c_str(), val.c_str());
 
     if (key == "cookie") {
       if (!sub->empty()) {
-        TSDebug(MY_NAME, "ERROR: you need to define a connector");
+        Dbg(dbg_ctl, "ERROR: you need to define a connector");
         goto error;
       }
       sub->setCookieName(val);
@@ -881,7 +886,7 @@ build_op(op &o, OpMap const &q)
   return true;
 
 error:
-  TSDebug(MY_NAME, "error building operation");
+  Dbg(dbg_ctl, "error building operation");
   return false;
 }
 
@@ -902,7 +907,7 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char *errbuf, int errbuf_s
 {
   if (argc != 3) {
     TSError("arguments not equal to 3: %d", argc);
-    TSDebug(MY_NAME, "arguments not equal to 3: %d", argc);
+    Dbg(dbg_ctl, "arguments not equal to 3: %d", argc);
     return TS_ERROR;
   }
 
@@ -953,7 +958,7 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char *errbuf, int errbuf_s
       }
     }
 
-    TSDebug(MY_NAME, "# of ops: %d", static_cast<int>(ops->size()));
+    Dbg(dbg_ctl, "# of ops: %d", static_cast<int>(ops->size()));
     *ih = static_cast<void *>(ops.release());
   } catch (const YAML::Exception &e) {
     TSError("YAML::Exception %s when parsing YAML config file %s for cookie_remap", e.what(), filename.c_str());
@@ -975,8 +980,8 @@ unmatched_path(UrlComponents &req_url, bool pre_remap)
   if (pos != std::string::npos) {
     path.erase(pos, from_path.size());
   }
-  TSDebug(MY_NAME, "from_path: %*s", FMT_SV(from_path));
-  TSDebug(MY_NAME, "%s: %s", pre_remap ? "unmatched_ppath" : "unmatched_path", path.c_str());
+  Dbg(dbg_ctl, "from_path: %*s", FMT_SV(from_path));
+  Dbg(dbg_ctl, "%s: %s", pre_remap ? "unmatched_ppath" : "unmatched_path", path.c_str());
 
   return path;
 }
@@ -1071,9 +1076,9 @@ cr_substitutions(std::string &obj, UrlComponents &req_url)
 {
   {
     auto path = req_url.path(false);
-    TSDebug(MY_NAME, "x req_url.path: %*s %d", FMT_SV(path), static_cast<int>(path.size()));
+    Dbg(dbg_ctl, "x req_url.path: %*s %d", FMT_SV(path), static_cast<int>(path.size()));
     auto url = req_url.url(false);
-    TSDebug(MY_NAME, "x req_url.url: %*s %d", FMT_SV(url), static_cast<int>(url.size()));
+    Dbg(dbg_ctl, "x req_url.url: %*s %d", FMT_SV(url), static_cast<int>(url.size()));
   }
 
   auto npos = std::string::npos;
@@ -1142,7 +1147,7 @@ cr_substitutions(std::string &obj, UrlComponents &req_url)
 
     } // end switch
 
-    TSDebug(MY_NAME, "%*s => %*s", FMT_SV(variable), FMT_SV(value));
+    Dbg(dbg_ctl, "%*s => %*s", FMT_SV(variable), FMT_SV(value));
 
     obj.replace(pos, variable.size(), value);
 
@@ -1165,7 +1170,7 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo *rri)
   if (ops == (OpsQueue *)nullptr) {
     TSError("serious error with encountered while attempting to "
             "cookie_remap");
-    TSDebug(MY_NAME, "serious error with encountered while attempting to remap");
+    Dbg(dbg_ctl, "serious error with encountered while attempting to remap");
     return TSREMAP_NO_REMAP;
   }
 
@@ -1176,7 +1181,7 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo *rri)
     client_req_query_params  = "?";
     client_req_query_params += query;
   }
-  TSDebug(MY_NAME, "Query Parameters: %s", client_req_query_params.c_str());
+  Dbg(dbg_ctl, "Query Parameters: %s", client_req_query_params.c_str());
 
   std::string rewrite_to;
   char cookie_str[] = "Cookie";
@@ -1184,7 +1189,7 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo *rri)
 
   // cookie header doesn't exist
   if (field == nullptr) {
-    TSDebug(MY_NAME, "no cookie header");
+    Dbg(dbg_ctl, "no cookie header");
     // return TSREMAP_NO_REMAP;
   }
 
@@ -1198,7 +1203,7 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo *rri)
   jar.create(temp_cookie);
 
   for (auto &op : *ops) {
-    TSDebug(MY_NAME, ">>> processing new operation");
+    Dbg(dbg_ctl, ">>> processing new operation");
     if (op->process(jar, rewrite_to, status, rri, req_url)) {
       cr_substitutions(rewrite_to, req_url);
 
@@ -1217,11 +1222,11 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo *rri)
         rewrite_to.append(client_req_query_params);
       }
 
-      TSDebug(MY_NAME, "rewriting to: %s", rewrite_to.c_str());
+      Dbg(dbg_ctl, "rewriting to: %s", rewrite_to.c_str());
 
       // Maybe set the return status
       if (status > TS_HTTP_STATUS_NONE) {
-        TSDebug(MY_NAME, "Setting return status to %d", status);
+        Dbg(dbg_ctl, "Setting return status to %d", status);
         TSHttpTxnStatusSet(txnp, status);
         if ((status == TS_HTTP_STATUS_MOVED_PERMANENTLY) || (status == TS_HTTP_STATUS_MOVED_TEMPORARILY)) {
           if (rewrite_to.size() > 8192) {
@@ -1275,8 +1280,8 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo *rri)
     }
   }
 
-  TSDebug(MY_NAME, "could not execute ANY of the cookie remap operations... "
-                   "falling back to default in remap.config");
+  Dbg(dbg_ctl, "could not execute ANY of the cookie remap operations... "
+               "falling back to default in remap.config");
 
   if (field != nullptr) {
     TSHandleMLocRelease(rri->requestBufp, rri->requestHdrp, field);
@@ -1291,7 +1296,7 @@ TSRemapDeleteInstance(void *ih)
 {
   OpsQueue *ops = static_cast<OpsQueue *>(ih);
 
-  TSDebug(MY_NAME, "deleting loaded operations");
+  Dbg(dbg_ctl, "deleting loaded operations");
   for (auto &op : *ops) {
     delete op;
   }
diff --git a/plugins/experimental/custom_redirect/custom_redirect.cc b/plugins/experimental/custom_redirect/custom_redirect.cc
index 5c1d82742ca..b7bd78e36b6 100644
--- a/plugins/experimental/custom_redirect/custom_redirect.cc
+++ b/plugins/experimental/custom_redirect/custom_redirect.cc
@@ -34,6 +34,8 @@
 #include <cstring>
 #include <cstdlib>
 
+static DbgCtl dbg_ctl{"[custom_redirect]"};
+
 static char *redirect_url_header   = nullptr;
 static int redirect_url_header_len = 0;
 static int return_code             = TS_HTTP_STATUS_NONE;
@@ -93,13 +95,13 @@ plugin_main_handler(TSCont contp, TSEvent event, void *edata)
   switch (event) {
   case TS_EVENT_HTTP_READ_RESPONSE_HDR: {
     TSHttpTxn txnp = static_cast<TSHttpTxn>(edata);
-    TSDebug("[custom_redirect1]", "MAIN_HANDLER::TS_HTTP_READ_RESPONSE_HDR_HOOK");
+    Dbg(dbg_ctl, "MAIN_HANDLER::TS_HTTP_READ_RESPONSE_HDR_HOOK");
     handle_response(txnp, contp);
     break;
   }
 
   default: {
-    TSDebug("[custom_redirect]", "default event");
+    Dbg(dbg_ctl, "default event");
     break;
   }
   }
diff --git a/plugins/experimental/fastcgi/src/ats_fastcgi.cc b/plugins/experimental/fastcgi/src/ats_fastcgi.cc
index 4d9ef495433..41a2eddfc6b 100644
--- a/plugins/experimental/fastcgi/src/ats_fastcgi.cc
+++ b/plugins/experimental/fastcgi/src/ats_fastcgi.cc
@@ -83,11 +83,11 @@ class InterceptGlobalPlugin : public GlobalPlugin
   {
     if (transaction.getCacheStatus() == Transaction::CACHE_LOOKUP_HIT_FRESH) {
       transaction.resume();
-      TSDebug(PLUGIN_NAME, " Cache hit.");
+      Dbg(dbg_ctl, " Cache hit.");
       return;
     }
     if (static_cast<TSHttpTxn>(transaction.getAtsHandle()) == nullptr) {
-      TSDebug(PLUGIN_NAME, "Invalid Transaction.");
+      Dbg(dbg_ctl, "Invalid Transaction.");
       return;
     }
     string path = transaction.getClientRequest().getUrl().getPath();
@@ -214,6 +214,6 @@ TSPluginInit(int argc, const char *argv[])
     TSStatIntSet(phpConnCount, 0);
 
   } else {
-    TSDebug(PLUGIN_NAME, " plugin is disabled.");
+    Dbg(dbg_ctl, " plugin is disabled.");
   }
 }
diff --git a/plugins/experimental/fastcgi/src/ats_fcgi_client.cc b/plugins/experimental/fastcgi/src/ats_fcgi_client.cc
index 7795132ddde..5b23666e5da 100644
--- a/plugins/experimental/fastcgi/src/ats_fcgi_client.cc
+++ b/plugins/experimental/fastcgi/src/ats_fcgi_client.cc
@@ -198,7 +198,7 @@ FCGIClientRequest::emptyParam()
     state_->pBuffInc += sizeof(FCGI_Header);
     return;
   }
-  TSDebug(PLUGIN_NAME, "empty Post Header Len: %ld ", state_->pBuffInc - state_->buff);
+  Dbg(dbg_ctl, "empty Post Header Len: %ld ", state_->pBuffInc - state_->buff);
 }
 
 FCGI_Header *
@@ -227,7 +227,7 @@ FCGIClientRequest::createBeginRequest()
   state_->pBuffInc += sizeof(FCGI_Header);
   serialize(state_->pBuffInc, state_->request->body, sizeof(FCGI_BeginRequestBody));
   state_->pBuffInc += sizeof(FCGI_BeginRequestBody);
-  TSDebug(PLUGIN_NAME, "Header Len: %ld ", state_->pBuffInc - state_->buff);
+  Dbg(dbg_ctl, "Header Len: %ld ", state_->pBuffInc - state_->buff);
   // FCGI Params headers
   state_->header = createHeader(FCGI_PARAMS);
   int len = 0, nb = 0;
@@ -239,8 +239,7 @@ FCGIClientRequest::createBeginRequest()
 
   state_->header->contentLengthB0 = BYTE_0(len);
   state_->header->contentLengthB1 = BYTE_1(len);
-  TSDebug(PLUGIN_NAME, "ParamsLen: %d ContLenB0: %d ContLenB1: %d", len, state_->header->contentLengthB0,
-          state_->header->contentLengthB1);
+  Dbg(dbg_ctl, "ParamsLen: %d ContLenB0: %d ContLenB1: %d", len, state_->header->contentLengthB0, state_->header->contentLengthB1);
   serialize(state_->pBuffInc, state_->header, sizeof(FCGI_Header));
   state_->pBuffInc += sizeof(FCGI_Header);
 
@@ -275,7 +274,7 @@ FCGIClientRequest::postBodyChunk()
   state_->postHeader->contentLengthB1 = 0;
   serialize(state_->pBuffInc, state_->postHeader, sizeof(FCGI_Header));
   state_->pBuffInc += sizeof(FCGI_Header);
-  TSDebug(PLUGIN_NAME, "Serialized Post Data. Post Header Len: %ld ", state_->pBuffInc - state_->buff);
+  Dbg(dbg_ctl, "Serialized Post Data. Post Header Len: %ld ", state_->pBuffInc - state_->buff);
 }
 
 unsigned char *
@@ -567,7 +566,7 @@ FCGIClientRequest::fcgiProcessBuffer(uchar *beg_buf, uchar *end_buf, std::ostrin
         TSMBuffer bufp      = TSMBufferCreate();
         TSMimeHdrCreate(bufp, &mime_hdr_loc1);
         if ((retval = TSMimeHdrParse(parser, bufp, mime_hdr_loc1, &start1, endPtr)) == TS_PARSE_ERROR) {
-          TSDebug(PLUGIN_NAME, "[FCGIClientRequest:%s] Hdr Parse Error.", __FUNCTION__);
+          Dbg(dbg_ctl, "[FCGIClientRequest:%s] Hdr Parse Error.", __FUNCTION__);
         } else {
           if (retval == TS_PARSE_DONE) {
             temp = convert_mime_hdr_to_string(bufp, mime_hdr_loc1); // Implements TSMimeHdrPrint.
@@ -591,7 +590,7 @@ FCGIClientRequest::fcgiProcessBuffer(uchar *beg_buf, uchar *end_buf, std::ostrin
                 // }
               }
             } else {
-              TSDebug(PLUGIN_NAME, "[FCGIClientRequest:%s] Incorrect Parsing.", __FUNCTION__);
+              Dbg(dbg_ctl, "[FCGIClientRequest:%s] Incorrect Parsing.", __FUNCTION__);
               output << "HTTP/1.0 200 OK\r\n";
             }
             TSfree(temp);
@@ -614,11 +613,11 @@ FCGIClientRequest::fcgiProcessBuffer(uchar *beg_buf, uchar *end_buf, std::ostrin
         // XXX(oschaaf): we may want to treat this differently, but for now this will do.
         output << "HTTP/1.0 500 Server Error\r\n\r\n";
         output << std::string((const char *)_headerRecord->content, _headerRecord->length);
-        TSDebug(PLUGIN_NAME, "[ FCGIClientRequest:%s ] Response FCGI_STDERR.*****\n\n", __FUNCTION__);
+        Dbg(dbg_ctl, "[ FCGIClientRequest:%s ] Response FCGI_STDERR.*****\n\n", __FUNCTION__);
         return true;
       }
       if (_headerRecord->header->type == FCGI_END_REQUEST) {
-        TSDebug(PLUGIN_NAME, "[ FCGIClientRequest:%s ] Response FCGI_END_REQUEST.*****\n\n", __FUNCTION__);
+        Dbg(dbg_ctl, "[ FCGIClientRequest:%s ] Response FCGI_END_REQUEST.*****\n\n", __FUNCTION__);
         return true;
       }
     }
diff --git a/plugins/experimental/fastcgi/src/connection_pool.cc b/plugins/experimental/fastcgi/src/connection_pool.cc
index b13d115bac8..d8bdeb8a3b3 100644
--- a/plugins/experimental/fastcgi/src/connection_pool.cc
+++ b/plugins/experimental/fastcgi/src/connection_pool.cc
@@ -33,7 +33,7 @@ ConnectionPool::ConnectionPool(Server *server, TSEventFunc funcp)
 
 ConnectionPool::~ConnectionPool()
 {
-  TSDebug(PLUGIN_NAME, "Destroying connectionPool Obj...");
+  Dbg(dbg_ctl, "Destroying connectionPool Obj...");
   TSMutexDestroy(_availableConn_mutex);
   TSMutexDestroy(_conn_mutex);
 }
@@ -49,16 +49,16 @@ ConnectionPool::getAvailableConnection()
 {
   ServerConnection *conn = nullptr;
   if (!_available_connections.empty() && _connections.size() >= _maxConn) {
-    TSDebug(PLUGIN_NAME, "%s: available connections %ld", __FUNCTION__, _available_connections.size());
+    Dbg(dbg_ctl, "%s: available connections %ld", __FUNCTION__, _available_connections.size());
     conn = _available_connections.front();
     _available_connections.pop_front();
     conn->setState(ServerConnection::READY);
-    TSDebug(PLUGIN_NAME, "%s: available connections %ld. Connection from available pool, %p", __FUNCTION__,
-            _available_connections.size(), conn);
+    Dbg(dbg_ctl, "%s: available connections %ld. Connection from available pool, %p", __FUNCTION__, _available_connections.size(),
+        conn);
   }
 
   if (_connections.size() < _maxConn) {
-    TSDebug(PLUGIN_NAME, "%s: Setting up new connection, maxConn: %d", __FUNCTION__, _maxConn);
+    Dbg(dbg_ctl, "%s: Setting up new connection, maxConn: %d", __FUNCTION__, _maxConn);
     conn = new ServerConnection(_server, _funcp);
     addConnection(conn);
   }
@@ -79,7 +79,7 @@ ConnectionPool::reuseConnection(ServerConnection *connection)
 
   connection->setState(ServerConnection::READY);
   _available_connections.push_back(connection);
-  TSDebug(PLUGIN_NAME, "%s: Connection added, available connections %ld", __FUNCTION__, _available_connections.size());
+  Dbg(dbg_ctl, "%s: Connection added, available connections %ld", __FUNCTION__, _available_connections.size());
 }
 
 void
diff --git a/plugins/experimental/fastcgi/src/fcgi_config.cc b/plugins/experimental/fastcgi/src/fcgi_config.cc
index 91aa52550bb..d68c399964e 100644
--- a/plugins/experimental/fastcgi/src/fcgi_config.cc
+++ b/plugins/experimental/fastcgi/src/fcgi_config.cc
@@ -566,7 +566,7 @@ FcgiPluginConfig::initConfig(const char *fn)
   InterceptPluginData *plugin_data = new InterceptPluginData();
   FcgiPluginConfig *config         = new FcgiPluginConfig(); // static_cast<FcgiPluginConfig *>(TSmalloc(sizeof(FcgiPluginConfig)));
                                                              // Default config
-  TSDebug(PLUGIN_NAME, "Setting config...");
+  Dbg(dbg_ctl, "Setting config...");
   if (plugin_data || nullptr == plugin_data->getGlobalConfigObj()) {
     config->enabled            = true;
     config->hostname           = DEFAULT_HOSTNAME;
@@ -725,13 +725,13 @@ FcgiPluginConfig::initConfig(const char *fn)
           case fcgiInclude:
             if (4 == strlen(tok) && 0 == strcmp(tok, "NULL")) {
               config->include = nullptr;
-              TSDebug(PLUGIN_NAME, "Failed to load FCGIParams config file.");
+              Dbg(dbg_ctl, "Failed to load FCGIParams config file.");
             } else {
               config->include = TSstrdup(tok);
               // This will read fcgiparams from config file and stored in config->params map
               FCGIParams *params = config->params;
               initFcgiParam(config->include, params);
-              TSDebug(PLUGIN_NAME, "Reading fcgiParams config from %s file complete.", config->include);
+              Dbg(dbg_ctl, "Reading fcgiParams config from %s file complete.", config->include);
               // FCGIParams::iterator it = params->begin();
               // std::cout << "mymap contains:\n";
               // for (it = params->begin(); it != params->end(); ++it)
@@ -756,20 +756,20 @@ FcgiPluginConfig::initConfig(const char *fn)
 
           case fcgiMinConnections: {
             config->min_connections = strtoll(tok, nullptr, 10);
-            TSDebug(PLUGIN_NAME, "min_connections = %ld", config->min_connections);
+            Dbg(dbg_ctl, "min_connections = %ld", config->min_connections);
           } break;
 
           case fcgiMaxConnections: {
             config->max_connections = strtoll(tok, nullptr, 10);
-            TSDebug(PLUGIN_NAME, "max_connections = %ld", config->max_connections);
+            Dbg(dbg_ctl, "max_connections = %ld", config->max_connections);
           } break;
           case fcgiMaxRequests: {
             config->max_requests = strtoll(tok, nullptr, 10);
-            TSDebug(PLUGIN_NAME, "max_requests = %ld", config->max_requests);
+            Dbg(dbg_ctl, "max_requests = %ld", config->max_requests);
           } break;
           case fcgiRequestQueueSize: {
             config->request_queue_size = strtoll(tok, nullptr, 10);
-            TSDebug(PLUGIN_NAME, "request_queue_size = %ld", config->request_queue_size);
+            Dbg(dbg_ctl, "request_queue_size = %ld", config->request_queue_size);
           } break;
           default:
             break;
@@ -781,13 +781,13 @@ FcgiPluginConfig::initConfig(const char *fn)
     }
   }
 
-  TSDebug(PLUGIN_NAME, "enabled = %d", static_cast<int>(config->enabled));
-  TSDebug(PLUGIN_NAME, "hostname = %s", config->hostname);
-  TSDebug(PLUGIN_NAME, "server_ip = %s", config->server_ip);
-  TSDebug(PLUGIN_NAME, "server_port = %s", config->server_port);
-  TSDebug(PLUGIN_NAME, "include = %s", config->include);
-  TSDebug(PLUGIN_NAME, "document_root = %s", config->document_root);
-  TSDebug(PLUGIN_NAME, "html = %s", config->html);
+  Dbg(dbg_ctl, "enabled = %d", static_cast<int>(config->enabled));
+  Dbg(dbg_ctl, "hostname = %s", config->hostname);
+  Dbg(dbg_ctl, "server_ip = %s", config->server_ip);
+  Dbg(dbg_ctl, "server_port = %s", config->server_port);
+  Dbg(dbg_ctl, "include = %s", config->include);
+  Dbg(dbg_ctl, "document_root = %s", config->document_root);
+  Dbg(dbg_ctl, "html = %s", config->html);
   return config;
 }
 
diff --git a/plugins/experimental/fastcgi/src/fcgi_config.h b/plugins/experimental/fastcgi/src/fcgi_config.h
index fdc78182f4d..32e35338977 100644
--- a/plugins/experimental/fastcgi/src/fcgi_config.h
+++ b/plugins/experimental/fastcgi/src/fcgi_config.h
@@ -165,7 +165,7 @@ class InterceptPluginData
       tol_remap_hook_reqs(0),
       tol_non_cacheable_reqs(0),
       tol_got_passed_reqs(0){
-        // TSDebug(PLUGIN_NAME, "FCGIPluginData Initialised.");
+        // Dbg(dbg_ctl, "FCGIPluginData Initialised.");
       };
   ~InterceptPluginData();
   FcgiPluginConfig *getGlobalConfigObj();
diff --git a/plugins/experimental/fastcgi/src/server.cc b/plugins/experimental/fastcgi/src/server.cc
index c115b603c61..afb42a233a0 100644
--- a/plugins/experimental/fastcgi/src/server.cc
+++ b/plugins/experimental/fastcgi/src/server.cc
@@ -49,7 +49,7 @@ interceptTransferData(ServerIntercept *intercept, ServerConnection *server_conn)
   }
 
   if (consumed) {
-    TSDebug(PLUGIN_NAME, "[%s] Read %ld bytes from server and writing it to client side.", __FUNCTION__, consumed);
+    Dbg(dbg_ctl, "[%s] Read %ld bytes from server and writing it to client side.", __FUNCTION__, consumed);
     TSIOBufferReaderConsume(server_conn->readio.reader, consumed);
   }
   TSVIONDoneSet(server_conn->readio.vio, TSVIONDoneGet(server_conn->readio.vio) + consumed);
@@ -66,7 +66,7 @@ interceptTransferData(ServerIntercept *intercept, ServerConnection *server_conn)
 static int
 handlePHPConnectionEvents(TSCont contp, TSEvent event, void *edata)
 {
-  TSDebug(PLUGIN_NAME, "[%s]:  event( %d )\tEventName: %s\tContp: %p ", __FUNCTION__, event, TSHttpEventNameLookup(event), contp);
+  Dbg(dbg_ctl, "[%s]:  event( %d )\tEventName: %s\tContp: %p ", __FUNCTION__, event, TSHttpEventNameLookup(event), contp);
   ServerConnectionInfo *conn_info     = (ServerConnectionInfo *)TSContDataGet(contp);
   Server *server                      = conn_info->server;
   ServerConnection *server_connection = conn_info->server_connection;
@@ -76,7 +76,7 @@ handlePHPConnectionEvents(TSCont contp, TSEvent event, void *edata)
     TSStatIntIncrement(InterceptGlobal::phpConnCount, 1);
     server_connection->vc_ = (TSVConn)edata;
     server_connection->setState(ServerConnection::READY);
-    TSDebug(PLUGIN_NAME, "%s: New Connection success, %p", __FUNCTION__, server_connection);
+    Dbg(dbg_ctl, "%s: New Connection success, %p", __FUNCTION__, server_connection);
     ServerIntercept *intercept = server->getIntercept(server_connection->requestId());
     if (intercept)
       server_connection->createFCGIClient(intercept);
@@ -104,8 +104,8 @@ handlePHPConnectionEvents(TSCont contp, TSEvent event, void *edata)
   } break;
 
   case TS_EVENT_VCONN_READ_COMPLETE: {
-    TSDebug(PLUGIN_NAME, "[%s]: ResponseComplete...Sending Response to client stream. _request_id: %d", __FUNCTION__,
-            server_connection->requestId());
+    Dbg(dbg_ctl, "[%s]: ResponseComplete...Sending Response to client stream. _request_id: %d", __FUNCTION__,
+        server_connection->requestId());
     ServerIntercept *intercept = server->getIntercept(server_connection->requestId());
     server_connection->setState(ServerConnection::COMPLETE);
     intercept->setResponseOutputComplete();
@@ -127,9 +127,8 @@ handlePHPConnectionEvents(TSCont contp, TSEvent event, void *edata)
   case TS_EVENT_VCONN_EOS: {
     ServerIntercept *intercept = server->getIntercept(server_connection->requestId());
     if (!server_connection->writeio.readEnable) {
-      TSDebug(PLUGIN_NAME, "[%s]: EOS Request Failed. _request_id: %d, connection: %p,maxConn: %d, requestCount: %d", __FUNCTION__,
-              server_connection->requestId(), server_connection, server_connection->maxRequests(),
-              server_connection->requestCount());
+      Dbg(dbg_ctl, "[%s]: EOS Request Failed. _request_id: %d, connection: %p,maxConn: %d, requestCount: %d", __FUNCTION__,
+          server_connection->requestId(), server_connection, server_connection->maxRequests(), server_connection->requestCount());
 
       server->reConnect(server_connection->requestId());
       server_connection->setState(ServerConnection::CLOSED);
@@ -139,8 +138,8 @@ handlePHPConnectionEvents(TSCont contp, TSEvent event, void *edata)
 
     if (server_connection->getState() != ServerConnection::COMPLETE)
       if (intercept && !intercept->getOutputCompleteState()) {
-        TSDebug(PLUGIN_NAME, "[%s]: EOS intercept->setResponseOutputComplete, _request_id: %d, connection: %p", __FUNCTION__,
-                server_connection->requestId(), server_connection);
+        Dbg(dbg_ctl, "[%s]: EOS intercept->setResponseOutputComplete, _request_id: %d, connection: %p", __FUNCTION__,
+            server_connection->requestId(), server_connection);
         Transaction &transaction = utils::internal::getTransaction(intercept->_txn);
         transaction.error("Internal server error");
       }
@@ -152,7 +151,7 @@ handlePHPConnectionEvents(TSCont contp, TSEvent event, void *edata)
     TSVConnAbort(server_connection->vc_, 1);
     ServerIntercept *intercept = server->getIntercept(server_connection->requestId());
     if (intercept) {
-      TSDebug(PLUGIN_NAME, "[%s]:ERROR  intercept->setResponseOutputComplete", __FUNCTION__);
+      Dbg(dbg_ctl, "[%s]:ERROR  intercept->setResponseOutputComplete", __FUNCTION__);
       server_connection->setState(ServerConnection::CLOSED);
       Transaction &transaction = utils::internal::getTransaction(intercept->_txn);
       transaction.setStatusCode(HTTP_STATUS_BAD_GATEWAY);
@@ -192,21 +191,21 @@ Server::setupThreadLocalStorage()
     if ((threadData = static_cast<ThreadData *>(pthread_getspecific(InterceptGlobal::threadKey))) == nullptr) {
       threadData = new ThreadData(this);
       if (pthread_setspecific(InterceptGlobal::threadKey, threadData)) {
-        TSDebug(PLUGIN_NAME, "[Server:%s] Unable to set threadData to the key", __FUNCTION__);
+        Dbg(dbg_ctl, "[Server:%s] Unable to set threadData to the key", __FUNCTION__);
         pthread_key_delete(InterceptGlobal::threadKey);
         InterceptGlobal::threadKey = 0;
         return false;
       }
 
       TSStatIntIncrement(InterceptGlobal::threadCount, 1);
-      TSDebug(PLUGIN_NAME, "[Server:%s] Data is set for this thread [threadData]%p [threadID]%lu", __FUNCTION__, threadData,
-              pthread_self());
+      Dbg(dbg_ctl, "[Server:%s] Data is set for this thread [threadData]%p [threadID]%lu", __FUNCTION__, threadData,
+          pthread_self());
     }
 
     return true;
   }
 
-  TSDebug(PLUGIN_NAME, "[Server:%s] Could not create key", __FUNCTION__);
+  Dbg(dbg_ctl, "[Server:%s] Could not create key", __FUNCTION__);
   return false;
 }
 
@@ -247,9 +246,9 @@ Server::removeIntercept(uint request_id)
 
     _intercept_list.erase(itr);
     TSMutexUnlock(_intecept_mutex);
-    TSDebug(PLUGIN_NAME, "[Server:%s] ReqQueueLength:%d ,request_id: %d,ServerConn: %p ,max_requests: %d, req_count: %d ",
-            __FUNCTION__, tdata->getRequestQueue()->getSize(), serv_conn->requestId(), serv_conn, serv_conn->maxRequests(),
-            serv_conn->requestCount());
+    Dbg(dbg_ctl, "[Server:%s] ReqQueueLength:%d ,request_id: %d,ServerConn: %p ,max_requests: %d, req_count: %d ", __FUNCTION__,
+        tdata->getRequestQueue()->getSize(), serv_conn->requestId(), serv_conn, serv_conn->maxRequests(),
+        serv_conn->requestCount());
 
     serv_conn->releaseFCGIClient();
     serv_conn->setRequestId(0);
@@ -280,8 +279,7 @@ Server::writeRequestHeader(uint request_id)
     return false;
   }
 
-  TSDebug(PLUGIN_NAME, "[Server::%s] : Write Request Header: _request_id: %d,ServerConn: %p", __FUNCTION__, request_id,
-          server_conn);
+  Dbg(dbg_ctl, "[Server::%s] : Write Request Header: _request_id: %d,ServerConn: %p", __FUNCTION__, request_id, server_conn);
 
   FCGIClientRequest *fcgiRequest = server_conn->fcgiRequest();
   unsigned char *clientReq;
@@ -302,7 +300,7 @@ Server::writeRequestBody(uint request_id, const string &data)
     return false;
   }
 
-  TSDebug(PLUGIN_NAME, "[Server::%s] : Write Request Body: request_id: %d,Server_conn: %p", __FUNCTION__, request_id, server_conn);
+  Dbg(dbg_ctl, "[Server::%s] : Write Request Body: request_id: %d,Server_conn: %p", __FUNCTION__, request_id, server_conn);
   FCGIClientRequest *fcgiRequest = server_conn->fcgiRequest();
   // TODO: possibly move all this as one function in server_connection
   unsigned char *clientReq;
@@ -323,8 +321,7 @@ Server::writeRequestBodyComplete(uint request_id)
     return false;
   }
 
-  TSDebug(PLUGIN_NAME, "[Server::%s] : Write Request Complete: request_id: %d,Server_conn: %p", __FUNCTION__, request_id,
-          server_conn);
+  Dbg(dbg_ctl, "[Server::%s] : Write Request Complete: request_id: %d,Server_conn: %p", __FUNCTION__, request_id, server_conn);
   FCGIClientRequest *fcgiRequest = server_conn->fcgiRequest();
   // TODO: possibly move all this as one function in server_connection
   unsigned char *clientReq;
@@ -348,7 +345,7 @@ Server::connect(ServerIntercept *intercept)
       initiateBackendConnection(intercept, conn);
       return 0;
     }
-    TSDebug(PLUGIN_NAME, "[Server:%s] : Added to RequestQueue. QueueSize: %d", __FUNCTION__, tdata->getRequestQueue()->getSize());
+    Dbg(dbg_ctl, "[Server:%s] : Added to RequestQueue. QueueSize: %d", __FUNCTION__, tdata->getRequestQueue()->getSize());
     tdata->getRequestQueue()->addToQueue(intercept);
     return 0;
   }
@@ -364,7 +361,7 @@ Server::reConnect(uint request_id)
     _intercept_list.erase(request_id);
     TSMutexUnlock(_intecept_mutex);
     connect(intercept);
-    TSDebug(PLUGIN_NAME, "[Server:%s]: Initiating reconnection...", __FUNCTION__);
+    Dbg(dbg_ctl, "[Server:%s]: Initiating reconnection...", __FUNCTION__);
   }
 }
 
@@ -382,9 +379,9 @@ Server::initiateBackendConnection(ServerIntercept *intercept, ServerConnection *
   _intercept_list[request_id] = std::make_tuple(intercept, conn);
   TSMutexUnlock(_intecept_mutex);
 
-  TSDebug(PLUGIN_NAME, "[Server: %s] ServerConn: %p,_request_id: %d", __FUNCTION__, conn, request_id);
+  Dbg(dbg_ctl, "[Server: %s] ServerConn: %p,_request_id: %d", __FUNCTION__, conn, request_id);
   if (conn->getState() != ServerConnection::READY) {
-    TSDebug(PLUGIN_NAME, "[Server: %s] Setting up a new php Connection..", __FUNCTION__);
+    Dbg(dbg_ctl, "[Server: %s] Setting up a new php Connection..", __FUNCTION__);
     conn->createConnection();
     return;
   }
diff --git a/plugins/experimental/fastcgi/src/server_connection.cc b/plugins/experimental/fastcgi/src/server_connection.cc
index 889d230769e..8ef2fa6bf80 100644
--- a/plugins/experimental/fastcgi/src/server_connection.cc
+++ b/plugins/experimental/fastcgi/src/server_connection.cc
@@ -52,7 +52,7 @@ InterceptIOChannel::read(TSVConn vc, TSCont contp)
       TSError("[InterceptIOChannel:%s] ERROR While reading from server", __FUNCTION__);
       return;
     }
-    TSDebug(PLUGIN_NAME, "[InterceptIOChannel:%s] ReadIO.vio :%p ", __FUNCTION__, this->vio);
+    Dbg(dbg_ctl, "[InterceptIOChannel:%s] ReadIO.vio :%p ", __FUNCTION__, this->vio);
   }
 }
 
@@ -104,7 +104,7 @@ InterceptIOChannel::phpWrite(TSVConn vc, TSCont contp, unsigned char *buf, int d
   }
 
   this->readEnable = true;
-  TSDebug(PLUGIN_NAME, "[%s] Done: %ld \tnBytes: %ld", __FUNCTION__, TSVIONDoneGet(this->vio), TSVIONBytesGet(this->vio));
+  Dbg(dbg_ctl, "[%s] Done: %ld \tnBytes: %ld", __FUNCTION__, TSVIONDoneGet(this->vio), TSVIONBytesGet(this->vio));
 }
 
 ServerConnection::ServerConnection(Server *server, TSEventFunc funcp)
@@ -125,8 +125,8 @@ ServerConnection::ServerConnection(Server *server, TSEventFunc funcp)
 
 ServerConnection::~ServerConnection()
 {
-  TSDebug(PLUGIN_NAME, "Destroying server Connection Obj.ServerConn: %p ,request_id: %d,max_requests: %d, req_count: %d ", this,
-          _requestId, _max_requests, _req_count);
+  Dbg(dbg_ctl, "Destroying server Connection Obj.ServerConn: %p ,request_id: %d,max_requests: %d, req_count: %d ", this, _requestId,
+      _max_requests, _req_count);
 
   if (vc_) {
     TSVConnClose(vc_);
@@ -161,9 +161,8 @@ void
 ServerConnection::releaseFCGIClient()
 {
   if (_state == COMPLETE) {
-    TSDebug(PLUGIN_NAME,
-            "[ServerConnection:%s] Release FCGI resource of ServerConn: %p ,request_id: %d,max_requests: %d, req_count: %d ",
-            __FUNCTION__, this, _requestId, _max_requests, _req_count);
+    Dbg(dbg_ctl, "[ServerConnection:%s] Release FCGI resource of ServerConn: %p ,request_id: %d,max_requests: %d, req_count: %d ",
+        __FUNCTION__, this, _requestId, _max_requests, _req_count);
     delete _fcgiRequest;
     _fcgiRequest = nullptr;
     _state       = READY;
diff --git a/plugins/experimental/fastcgi/src/server_intercept.cc b/plugins/experimental/fastcgi/src/server_intercept.cc
index 1bc0a9a71f5..4fa84ae34cc 100644
--- a/plugins/experimental/fastcgi/src/server_intercept.cc
+++ b/plugins/experimental/fastcgi/src/server_intercept.cc
@@ -42,7 +42,7 @@ using namespace ats_plugin;
 
 ServerIntercept::~ServerIntercept()
 {
-  TSDebug(PLUGIN_NAME, "~ServerIntercept : Shutting down server intercept._request_id: %d", _request_id);
+  Dbg(dbg_ctl, "~ServerIntercept : Shutting down server intercept._request_id: %d", _request_id);
   _txn = nullptr;
   if (!outputCompleteState) {
     clientAborted = true;
@@ -73,7 +73,7 @@ ServerIntercept::streamReqHeader(const string &data)
 void
 ServerIntercept::streamReqBody(const string &data)
 {
-  TSDebug(PLUGIN_NAME, "[ServerIntercept:%s] bodyCount: %d", __FUNCTION__, bodyCount++);
+  Dbg(dbg_ctl, "[ServerIntercept:%s] bodyCount: %d", __FUNCTION__, bodyCount++);
   if (!Server::server()->writeRequestBody(_request_id, data)) {
     dataBuffered  = true;
     clientBody   += data;
@@ -83,7 +83,7 @@ ServerIntercept::streamReqBody(const string &data)
 void
 ServerIntercept::handleInputComplete()
 {
-  TSDebug(PLUGIN_NAME, "[ServerIntercept:%s] Count : %d \t_request_id: %d", __FUNCTION__, emptyCount++, _request_id);
+  Dbg(dbg_ctl, "[ServerIntercept:%s] Count : %d \t_request_id: %d", __FUNCTION__, emptyCount++, _request_id);
   if (!Server::server()->writeRequestBodyComplete(_request_id)) {
     return;
   }
diff --git a/plugins/experimental/fastcgi/src/server_intercept.h b/plugins/experimental/fastcgi/src/server_intercept.h
index 9fc0ded5ad8..d594e14e4da 100644
--- a/plugins/experimental/fastcgi/src/server_intercept.h
+++ b/plugins/experimental/fastcgi/src/server_intercept.h
@@ -61,7 +61,7 @@ class ServerIntercept : public InterceptPlugin
     serverDataBuffered  = false;
     inputCompleteState  = false;
     outputCompleteState = false;
-    TSDebug(PLUGIN_NAME, "ServerIntercept : Added Server intercept");
+    Dbg(dbg_ctl, "ServerIntercept : Added Server intercept");
   }
 
   ~ServerIntercept() override;
diff --git a/plugins/experimental/fq_pacing/fq_pacing.cc b/plugins/experimental/fq_pacing/fq_pacing.cc
index c91cea4b83a..1e2a2c69942 100644
--- a/plugins/experimental/fq_pacing/fq_pacing.cc
+++ b/plugins/experimental/fq_pacing/fq_pacing.cc
@@ -29,6 +29,8 @@
 
 static const char *PLUGIN_NAME = "fq_pacing";
 
+static DbgCtl dbg_ctl{PLUGIN_NAME};
+
 // Sanity check max rate at 100Gbps
 #define MAX_PACING_RATE 100000000000
 
@@ -105,7 +107,7 @@ TSRemapInit(TSRemapInterface *api_info, char *errbuf, int errbuf_size)
     return TS_ERROR;
   }
 
-  TSDebug(PLUGIN_NAME, "plugin is successfully initialized");
+  Dbg(dbg_ctl, "plugin is successfully initialized");
   return TS_SUCCESS;
 }
 
@@ -115,7 +117,7 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char *errbuf, int errbuf_s
   fq_pacing_cfg_t *cfg      = nullptr;
   unsigned long pacing_rate = 0;
 
-  TSDebug(PLUGIN_NAME, "Instantiating a new remap.config plugin rule");
+  Dbg(dbg_ctl, "Instantiating a new remap.config plugin rule");
 
   if (argc > 1) {
     int c;
@@ -151,7 +153,7 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char *errbuf, int errbuf_s
   memset(cfg, 0, sizeof(*cfg));
   cfg->pacing_rate = pacing_rate;
   *ih              = cfg;
-  TSDebug(PLUGIN_NAME, "Setting pacing rate to %lu", pacing_rate);
+  Dbg(dbg_ctl, "Setting pacing rate to %lu", pacing_rate);
 
   return TS_SUCCESS;
 }
@@ -175,7 +177,7 @@ reset_pacing_cont(TSCont contp, TSEvent event, void *edata)
 #ifdef SO_MAX_PACING_RATE
   unsigned int pacing_off = ~0U;
   if (txn_data->client_fd > 0) {
-    TSDebug(PLUGIN_NAME, "Disabling SO_MAX_PACING_RATE for client_fd=%d", txn_data->client_fd);
+    Dbg(dbg_ctl, "Disabling SO_MAX_PACING_RATE for client_fd=%d", txn_data->client_fd);
     int res = 0;
     res     = safe_setsockopt(txn_data->client_fd, SOL_SOCKET, SO_MAX_PACING_RATE, (char *)&pacing_off, sizeof(pacing_off));
     // EBADF indicates possible client abort
@@ -195,7 +197,7 @@ TSRemapStatus
 TSRemapDoRemap(void *instance, TSHttpTxn txnp, TSRemapRequestInfo *rri)
 {
   if (TSHttpTxnClientProtocolStackContains(txnp, TS_PROTO_TAG_HTTP_2_0) != nullptr) {
-    TSDebug(PLUGIN_NAME, "Skipping plugin execution for HTTP/2 requests");
+    Dbg(dbg_ctl, "Skipping plugin execution for HTTP/2 requests");
     return TSREMAP_NO_REMAP;
   }
 
@@ -212,7 +214,7 @@ TSRemapDoRemap(void *instance, TSHttpTxn txnp, TSRemapRequestInfo *rri)
   if ((res < 0)) {
     TSError("[fq_pacing] Error setting SO_MAX_PACING_RATE, errno=%d", errno);
   }
-  TSDebug(PLUGIN_NAME, "Setting SO_MAX_PACING_RATE for client_fd=%d to %lu Bps", client_fd, cfg->pacing_rate);
+  Dbg(dbg_ctl, "Setting SO_MAX_PACING_RATE for client_fd=%d to %lu Bps", client_fd, cfg->pacing_rate);
 #endif
 
   // Reset pacing at end of transaction in case session is
diff --git a/plugins/experimental/geoip_acl/acl.cc b/plugins/experimental/geoip_acl/acl.cc
index 7a20c2515d6..8dd5db021f2 100644
--- a/plugins/experimental/geoip_acl/acl.cc
+++ b/plugins/experimental/geoip_acl/acl.cc
@@ -24,6 +24,11 @@
 #include "acl.h"
 #include "lulu.h"
 
+namespace geoip_acl_ns
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 // Implementation of the ACL base class. This wraps the underlying Geo library
 // that we've found and used.
 GeoDBHandle Acl::_geoip;
@@ -34,13 +39,13 @@ GeoDBHandle Acl::_geoip6;
 bool
 Acl::init()
 {
-  TSDebug(PLUGIN_NAME, "initialized IPv4 GeoIP DB");
+  Dbg(dbg_ctl, "initialized IPv4 GeoIP DB");
   _geoip = GeoIP_new(GEOIP_MMAP_CACHE); // GEOIP_STANDARD seems to break threaded apps...
 
   // Setup IPv6 if possible
   if (GeoIP_db_avail(GEOIP_COUNTRY_EDITION_V6)) {
     _geoip6 = GeoIP_open_type(GEOIP_COUNTRY_EDITION_V6, GEOIP_MMAP_CACHE | GEOIP_MEMORY_CACHE);
-    TSDebug(PLUGIN_NAME, "initialized IPv6 GeoIP DB");
+    Dbg(dbg_ctl, "initialized IPv6 GeoIP DB");
   }
 
   return true;
@@ -74,7 +79,7 @@ Acl::country_id_by_addr(const sockaddr *addr) const
     break;
   }
 
-  TSDebug(PLUGIN_NAME, "eval(): Client IPv%d seems to come from ISO=%d", v, iso);
+  Dbg(dbg_ctl, "eval(): Client IPv%d seems to come from ISO=%d", v, iso);
   return iso;
 }
 #else  /* !HAVE_GEOIP_H */
@@ -83,7 +88,7 @@ Acl::country_id_by_addr(const sockaddr *addr) const
 bool
 Acl::init()
 {
-  TSDebug(PLUGIN_NAME, "No Geo library available!");
+  Dbg(dbg_ctl, "No Geo library available!");
   TSError("[%s] No Geo library available!", PLUGIN_NAME);
 
   return false;
@@ -112,7 +117,7 @@ Acl::read_html(const char *fn)
   if (f.is_open()) {
     _html.append(std::istreambuf_iterator<char>(f), std::istreambuf_iterator<char>());
     f.close();
-    TSDebug(PLUGIN_NAME, "Loaded HTML from %s", fn);
+    Dbg(dbg_ctl, "Loaded HTML from %s", fn);
   } else {
     TSError("[%s] Unable to open HTML file %s", PLUGIN_NAME, fn);
   }
@@ -158,7 +163,7 @@ RegexAcl::parse_line(const char *filename, const std::string &line, int lineno,
           ++tokens;
         }
         compile(regex, filename, lineno);
-        TSDebug(PLUGIN_NAME, "Added regex rule for /%s/", regex.c_str());
+        Dbg(dbg_ctl, "Added regex rule for /%s/", regex.c_str());
         return true;
       }
     }
@@ -215,7 +220,7 @@ CountryAcl::add_token(const std::string &str)
   iso = country_id_by_code(str.c_str());
   if (iso > 0 && iso < NUM_ISO_CODES) {
     _iso_country_codes[iso] = true;
-    TSDebug(PLUGIN_NAME, "Added %s(%d) to remap rule, ACL=%s", str.c_str(), iso, _allow ? "allow" : "deny");
+    Dbg(dbg_ctl, "Added %s(%d) to remap rule, ACL=%s", str.c_str(), iso, _allow ? "allow" : "deny");
   } else {
     TSError("[%s] Tried setting an ISO code (%d) outside the supported range", PLUGIN_NAME, iso);
   }
@@ -248,7 +253,7 @@ CountryAcl::read_regex(const char *fn, int &tokens)
     }
 
     f.close();
-    TSDebug(PLUGIN_NAME, "Loaded regex rules from %s", fn);
+    Dbg(dbg_ctl, "Loaded regex rules from %s", fn);
   } else {
     TSError("[%s] Unable to open regex file %s", PLUGIN_NAME, fn);
   }
@@ -259,7 +264,7 @@ CountryAcl::eval(TSRemapRequestInfo *rri, TSHttpTxn txnp) const
 {
   bool ret = _allow;
 
-  TSDebug(PLUGIN_NAME, "CountryAcl::eval() called, default ACL is %s", ret ? "allow" : "deny");
+  Dbg(dbg_ctl, "CountryAcl::eval() called, default ACL is %s", ret ? "allow" : "deny");
   // If there are regex rules, they take priority first. If a regex matches, we will
   // honor it's eval() rule. If no regexes matches, fall back on the default (which is
   // "allow" if nothing else is specified).
@@ -270,7 +275,7 @@ CountryAcl::eval(TSRemapRequestInfo *rri, TSHttpTxn txnp) const
 
     do {
       if (acl->match(path, path_len)) {
-        TSDebug(PLUGIN_NAME, "Path = %.*s matched /%s/", path_len, path, acl->get_regex().c_str());
+        Dbg(dbg_ctl, "Path = %.*s matched /%s/", path_len, path, acl->get_regex().c_str());
         return acl->eval(rri, txnp);
       }
     } while ((acl = acl->next()));
@@ -281,11 +286,11 @@ CountryAcl::eval(TSRemapRequestInfo *rri, TSHttpTxn txnp) const
   int iso = country_id_by_addr(TSHttpTxnClientAddrGet(txnp));
 
   if ((iso <= 0) || !_iso_country_codes[iso]) {
-    TSDebug(PLUGIN_NAME, "ISO not found in table, returning %d", !ret);
+    Dbg(dbg_ctl, "ISO not found in table, returning %d", !ret);
     return !ret;
   }
 
-  TSDebug(PLUGIN_NAME, "ISO was found in table, or -1, returning %d", ret);
+  Dbg(dbg_ctl, "ISO was found in table, or -1, returning %d", ret);
   return ret;
 }
 
diff --git a/plugins/experimental/geoip_acl/acl.h b/plugins/experimental/geoip_acl/acl.h
index a62341d50b4..1b4d1a39083 100644
--- a/plugins/experimental/geoip_acl/acl.h
+++ b/plugins/experimental/geoip_acl/acl.h
@@ -36,6 +36,12 @@
 #include <string>
 #include "lulu.h"
 
+namespace geoip_acl_ns
+{
+extern DbgCtl dbg_ctl;
+}
+using namespace geoip_acl_ns;
+
 #if HAVE_GEOIP_H
 #include <GeoIP.h>
 using GeoDBHandle = GeoIP *;
diff --git a/plugins/experimental/geoip_acl/geoip_acl.cc b/plugins/experimental/geoip_acl/geoip_acl.cc
index 5ccfe7ae853..a1d614f3ed4 100644
--- a/plugins/experimental/geoip_acl/geoip_acl.cc
+++ b/plugins/experimental/geoip_acl/geoip_acl.cc
@@ -37,7 +37,7 @@ TSRemapInit(TSRemapInterface *api_info, char *errbuf, int errbuf_size)
 {
   CHECK_REMAP_API_COMPATIBILITY(api_info, errbuf, errbuf_size);
   if (Acl::init()) {
-    TSDebug(PLUGIN_NAME, "remap plugin is successfully initialized");
+    Dbg(dbg_ctl, "remap plugin is successfully initialized");
     return TS_SUCCESS; /* success */
   } else {
     return TS_ERROR;
@@ -56,7 +56,7 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char * /* errbuf */, int /
     // ToDo: Should do better processing here, to make it easier to deal with
     // rules other then country codes.
     if (!strncmp(argv[2], "country", 11)) {
-      TSDebug(PLUGIN_NAME, "creating an ACL rule with ISO country codes");
+      Dbg(dbg_ctl, "creating an ACL rule with ISO country codes");
       a = new CountryAcl();
     }
 
@@ -91,12 +91,12 @@ TSRemapStatus
 TSRemapDoRemap(void *ih, TSHttpTxn rh, TSRemapRequestInfo *rri)
 {
   if (nullptr == ih) {
-    TSDebug(PLUGIN_NAME, "No ACLs configured, this is probably a plugin bug");
+    Dbg(dbg_ctl, "No ACLs configured, this is probably a plugin bug");
   } else {
     Acl *a = static_cast<Acl *>(ih);
 
     if (!a->eval(rri, rh)) {
-      TSDebug(PLUGIN_NAME, "denying request");
+      Dbg(dbg_ctl, "denying request");
       TSHttpTxnStatusSet(rh, static_cast<TSHttpStatus>(403));
       a->send_html(rh);
     }
diff --git a/plugins/experimental/header_freq/header_freq.cc b/plugins/experimental/header_freq/header_freq.cc
index e498b3769f9..53980193176 100644
--- a/plugins/experimental/header_freq/header_freq.cc
+++ b/plugins/experimental/header_freq/header_freq.cc
@@ -52,6 +52,12 @@ const char *ctl_tag              = PLUGIN_NAME;
 const char CONTROL_MSG_LOG[]     = "log"; // log all data
 const size_t CONTROL_MSG_LOG_LEN = sizeof(CONTROL_MSG_LOG) - 1;
 
+namespace
+{
+  DbgCtl dbg_ctl{DEBUG_TAG_HOOK};
+  DbgCtl dbg_ctl_init{DEBUG_TAG_INIT};
+} // namespace
+
 void
 Log_Data(std::ostream &ss)
 {
@@ -119,7 +125,7 @@ count_all_headers(TSMBuffer &bufp, TSMLoc &hdr_loc, std::map<std::string, unsign
   TSMLoc hdr, next_hdr;
   hdr           = TSMimeHdrFieldGet(bufp, hdr_loc, 0);
   int n_headers = TSMimeHdrFieldsCount(bufp, hdr_loc);
-  TSDebug(DEBUG_TAG_HOOK, "%d headers found", n_headers);
+  Dbg(dbg_ctl, "%d headers found", n_headers);
 
   // iterate through all headers
   for (int i = 0; i < n_headers && nullptr != hdr; ++i) {
@@ -157,7 +163,7 @@ handle_hook(TSCont contp, TSEvent event, void *edata)
   switch (event) {
   case TS_EVENT_HTTP_READ_REQUEST_HDR: // count client headers
   {
-    TSDebug(DEBUG_TAG_HOOK, "event TS_EVENT_HTTP_READ_REQUEST_HDR");
+    Dbg(dbg_ctl, "event TS_EVENT_HTTP_READ_REQUEST_HDR");
     txnp = reinterpret_cast<TSHttpTxn>(edata);
     // get the client request so we can loop through the headers
     if (TSHttpTxnClientReqGet(txnp, &bufp, &hdr_loc) != TS_SUCCESS) {
@@ -171,7 +177,7 @@ handle_hook(TSCont contp, TSEvent event, void *edata)
   } break;
   case TS_EVENT_HTTP_SEND_RESPONSE_HDR: // count origin headers
   {
-    TSDebug(DEBUG_TAG_HOOK, "event TS_EVENT_HTTP_SEND_RESPONSE_HDR");
+    Dbg(dbg_ctl, "event TS_EVENT_HTTP_SEND_RESPONSE_HDR");
     // get the response so we can loop through the headers
     txnp = reinterpret_cast<TSHttpTxn>(edata);
     if (TSHttpTxnClientRespGet(txnp, &bufp, &hdr_loc) != TS_SUCCESS) {
@@ -191,7 +197,7 @@ handle_hook(TSCont contp, TSEvent event, void *edata)
       // identify the command
       if (msgp->data_size >= CONTROL_MSG_LOG_LEN &&
           0 == strncasecmp(CONTROL_MSG_LOG, static_cast<const char *>(msgp->data), CONTROL_MSG_LOG_LEN)) {
-        TSDebug(DEBUG_TAG_HOOK, "Scheduled execution of '%s' command", CONTROL_MSG_LOG);
+        Dbg(dbg_ctl, "Scheduled execution of '%s' command", CONTROL_MSG_LOG);
         TSCont c = TSContCreate(CB_Command_Log, TSMutexCreate());
         TSContDataSet(c, new std::string(static_cast<const char *>(msgp->data), msgp->data_size));
         TSContScheduleOnPool(c, 0, TS_THREAD_POOL_TASK);
@@ -217,7 +223,7 @@ handle_hook(TSCont contp, TSEvent event, void *edata)
 void
 TSPluginInit(int argc, const char *argv[])
 {
-  TSDebug(DEBUG_TAG_INIT, "initializing plugin");
+  Dbg(dbg_ctl_init, "initializing plugin");
 
   TSPluginRegistrationInfo info = {PLUGIN_NAME, VENDOR_NAME, SUPPORT_EMAIL};
 
diff --git a/plugins/experimental/hook-trace/hook-trace.cc b/plugins/experimental/hook-trace/hook-trace.cc
index e7ef9628be0..c5026d7e266 100644
--- a/plugins/experimental/hook-trace/hook-trace.cc
+++ b/plugins/experimental/hook-trace/hook-trace.cc
@@ -25,6 +25,8 @@
 
 #define PLUGIN_NAME "hook-trace"
 
+static DbgCtl dbg_ctl{PLUGIN_NAME};
+
 template <typename T, unsigned N>
 static inline unsigned
 countof(const T (&)[N])
@@ -46,71 +48,71 @@ HttpHookTracer(TSCont contp, TSEvent event, void *edata)
 
   switch (event) {
   case TS_EVENT_HTTP_SSN_START:
-    TSDebug(PLUGIN_NAME, "Received SSN_START on session %p", ev.ssn);
+    Dbg(dbg_ctl, "Received SSN_START on session %p", ev.ssn);
     TSHttpSsnReenable(ev.ssn, TS_EVENT_HTTP_CONTINUE);
     break;
 
   case TS_EVENT_HTTP_SSN_CLOSE:
-    TSDebug(PLUGIN_NAME, "Received SSN_CLOSE on session %p", ev.ssn);
+    Dbg(dbg_ctl, "Received SSN_CLOSE on session %p", ev.ssn);
     TSHttpSsnReenable(ev.ssn, TS_EVENT_HTTP_CONTINUE);
     break;
 
   case TS_EVENT_HTTP_SELECT_ALT:
-    TSDebug(PLUGIN_NAME, "Received SELECT_ALT on altinfo %p", ev.alt);
+    Dbg(dbg_ctl, "Received SELECT_ALT on altinfo %p", ev.alt);
     break;
 
   case TS_EVENT_HTTP_READ_REQUEST_HDR:
-    TSDebug(PLUGIN_NAME, "Received READ_REQUEST_HDR on transaction %p", ev.txn);
+    Dbg(dbg_ctl, "Received READ_REQUEST_HDR on transaction %p", ev.txn);
     TSHttpTxnReenable(ev.txn, TS_EVENT_HTTP_CONTINUE);
     break;
 
   case TS_EVENT_HTTP_OS_DNS:
-    TSDebug(PLUGIN_NAME, "Received OS_DNS on transaction %p", ev.txn);
+    Dbg(dbg_ctl, "Received OS_DNS on transaction %p", ev.txn);
     TSHttpTxnReenable(ev.txn, TS_EVENT_HTTP_CONTINUE);
     break;
 
   case TS_EVENT_HTTP_SEND_REQUEST_HDR:
-    TSDebug(PLUGIN_NAME, "Received SEND_REQUEST_HDR on transaction %p", ev.txn);
+    Dbg(dbg_ctl, "Received SEND_REQUEST_HDR on transaction %p", ev.txn);
     TSHttpTxnReenable(ev.txn, TS_EVENT_HTTP_CONTINUE);
     break;
 
   case TS_EVENT_HTTP_READ_CACHE_HDR:
-    TSDebug(PLUGIN_NAME, "Received READ_CACHE_HDR on transaction %p", ev.txn);
+    Dbg(dbg_ctl, "Received READ_CACHE_HDR on transaction %p", ev.txn);
     TSHttpTxnReenable(ev.txn, TS_EVENT_HTTP_CONTINUE);
     break;
 
   case TS_EVENT_HTTP_READ_RESPONSE_HDR:
-    TSDebug(PLUGIN_NAME, "Received READ_RESPONSE_HDR on transaction %p", ev.txn);
+    Dbg(dbg_ctl, "Received READ_RESPONSE_HDR on transaction %p", ev.txn);
     TSHttpTxnReenable(ev.txn, TS_EVENT_HTTP_CONTINUE);
     break;
 
   case TS_EVENT_HTTP_SEND_RESPONSE_HDR:
-    TSDebug(PLUGIN_NAME, "Received SEND_RESPONSE_HDR on transaction %p", ev.txn);
+    Dbg(dbg_ctl, "Received SEND_RESPONSE_HDR on transaction %p", ev.txn);
     TSHttpTxnReenable(ev.txn, TS_EVENT_HTTP_CONTINUE);
     break;
 
   case TS_EVENT_HTTP_TXN_START:
-    TSDebug(PLUGIN_NAME, "Received TXN_START on transaction %p", ev.txn);
+    Dbg(dbg_ctl, "Received TXN_START on transaction %p", ev.txn);
     TSHttpTxnReenable(ev.txn, TS_EVENT_HTTP_CONTINUE);
     break;
 
   case TS_EVENT_HTTP_TXN_CLOSE:
-    TSDebug(PLUGIN_NAME, "Received TXN_CLOSE on transaction %p", ev.txn);
+    Dbg(dbg_ctl, "Received TXN_CLOSE on transaction %p", ev.txn);
     TSHttpTxnReenable(ev.txn, TS_EVENT_HTTP_CONTINUE);
     break;
 
   case TS_EVENT_HTTP_CACHE_LOOKUP_COMPLETE:
-    TSDebug(PLUGIN_NAME, "Received CACHE_LOOKUP_COMPLETE on transaction %p", ev.txn);
+    Dbg(dbg_ctl, "Received CACHE_LOOKUP_COMPLETE on transaction %p", ev.txn);
     TSHttpTxnReenable(ev.txn, TS_EVENT_HTTP_CONTINUE);
     break;
 
   case TS_EVENT_HTTP_PRE_REMAP:
-    TSDebug(PLUGIN_NAME, "Received PRE_REMAP on transaction %p", ev.txn);
+    Dbg(dbg_ctl, "Received PRE_REMAP on transaction %p", ev.txn);
     TSHttpTxnReenable(ev.txn, TS_EVENT_HTTP_CONTINUE);
     break;
 
   case TS_EVENT_HTTP_POST_REMAP:
-    TSDebug(PLUGIN_NAME, "Received POST_REMAP on transaction %p", ev.txn);
+    Dbg(dbg_ctl, "Received POST_REMAP on transaction %p", ev.txn);
     TSHttpTxnReenable(ev.txn, TS_EVENT_HTTP_CONTINUE);
     break;
 
@@ -126,31 +128,31 @@ LifecycleHookTracer(TSCont contp, TSEvent event, void *edata)
 {
   switch (event) {
   case TS_EVENT_LIFECYCLE_PORTS_INITIALIZED:
-    TSDebug(PLUGIN_NAME, "Received LIFECYCLE_PORTS_INITIALIZED data %p", edata);
+    Dbg(dbg_ctl, "Received LIFECYCLE_PORTS_INITIALIZED data %p", edata);
     break;
 
   case TS_EVENT_LIFECYCLE_PORTS_READY:
-    TSDebug(PLUGIN_NAME, "Received LIFECYCLE_PORTS_READY data %p", edata);
+    Dbg(dbg_ctl, "Received LIFECYCLE_PORTS_READY data %p", edata);
     break;
 
   case TS_EVENT_LIFECYCLE_CACHE_READY:
-    TSDebug(PLUGIN_NAME, "Received LIFECYCLE_CACHE_READY data %p", edata);
+    Dbg(dbg_ctl, "Received LIFECYCLE_CACHE_READY data %p", edata);
     break;
 
   case TS_EVENT_LIFECYCLE_SERVER_SSL_CTX_INITIALIZED:
-    TSDebug(PLUGIN_NAME, "Received LIFECYCLE_SERVER_SSL_INITIALIZED data %p", edata);
+    Dbg(dbg_ctl, "Received LIFECYCLE_SERVER_SSL_INITIALIZED data %p", edata);
     break;
 
   case TS_EVENT_LIFECYCLE_CLIENT_SSL_CTX_INITIALIZED:
-    TSDebug(PLUGIN_NAME, "Received LIFECYCLE_CLIENT_SSL_CTX_INITIALIZED data %p", edata);
+    Dbg(dbg_ctl, "Received LIFECYCLE_CLIENT_SSL_CTX_INITIALIZED data %p", edata);
     break;
 
   case TS_EVENT_LIFECYCLE_MSG:
-    TSDebug(PLUGIN_NAME, "Received LIFECYCLE_MSG data %p", edata);
+    Dbg(dbg_ctl, "Received LIFECYCLE_MSG data %p", edata);
     break;
 
   default:
-    TSDebug(PLUGIN_NAME, "Received unsupported lifecycle event %d data %p", event, edata);
+    Dbg(dbg_ctl, "Received unsupported lifecycle event %d data %p", event, edata);
     break;
   }
 
diff --git a/plugins/experimental/http_stats/http_stats.cc b/plugins/experimental/http_stats/http_stats.cc
index c453ea8320f..466320f15b0 100644
--- a/plugins/experimental/http_stats/http_stats.cc
+++ b/plugins/experimental/http_stats/http_stats.cc
@@ -43,10 +43,12 @@
 
 constexpr char PLUGIN[] = "http_stats";
 
-#define VDEBUG(fmt, ...) TSDebug(PLUGIN, fmt, ##__VA_ARGS__)
+static DbgCtl dbg_ctl{PLUGIN};
+
+#define VDEBUG(fmt, ...) Dbg(dbg_ctl, fmt, ##__VA_ARGS__)
 
 #if DEBUG
-#define VERROR(fmt, ...) TSDebug(PLUGIN, fmt, ##__VA_ARGS__)
+#define VERROR(fmt, ...) Dbg(dbg_ctl, fmt, ##__VA_ARGS__)
 #else
 #define VERROR(fmt, ...) TSError("[%s] %s: " fmt, PLUGIN, __FUNCTION__, ##__VA_ARGS__)
 #endif
@@ -720,7 +722,7 @@ json_out_stat(TSRecordType rec_type, void *edata, int registered, const char *na
     APPEND_STAT_JSON(fmtr, name, "%s", datum->rec_string);
     break;
   default:
-    TSDebug(PLUGIN, "unknown type for %s: %d", name, data_type);
+    Dbg(dbg_ctl, "unknown type for %s: %d", name, data_type);
     break;
   }
 }
@@ -744,7 +746,7 @@ csv_out_stat(TSRecordType rec_type, void *edata, int registered, const char *nam
     APPEND_STAT_CSV(fmtr, name, "%s", datum->rec_string);
     break;
   default:
-    TSDebug(PLUGIN, "unknown type for %s: %d", name, data_type);
+    Dbg(dbg_ctl, "unknown type for %s: %d", name, data_type);
     break;
   }
 }
diff --git a/plugins/experimental/icap/icap_plugin.cc b/plugins/experimental/icap/icap_plugin.cc
index fa6c90c6963..b1fee8dbf1b 100644
--- a/plugins/experimental/icap/icap_plugin.cc
+++ b/plugins/experimental/icap/icap_plugin.cc
@@ -111,6 +111,7 @@ static int icap_conn_failed;
 static int total_icap_invalid;
 static int icap_response_err;
 static int icap_write_failed;
+static DbgCtl dbg_ctl{PLUGIN_NAME};
 
 static int transform_handler(TSCont contp, TSEvent event, void *edata);
 static int transform_read_http_header_event(TSCont contp, TransformData *data, TSEvent event, void *edata);
@@ -220,7 +221,7 @@ handle_invalid_icap_behavior(TSCont contp, TransformData *data, const char *msg)
     data->icap_vio = nullptr;
   }
   TSStatIntIncrement(total_icap_invalid, 1);
-  TSDebug(PLUGIN_NAME, "\n%s\n", data->icap_header.c_str());
+  Dbg(dbg_ctl, "\n%s\n", data->icap_header.c_str());
   data->err_msg = std::string(msg);
   /* Signal the upstream vconn if still exists to stop sending data */
   TSVIO write_vio = TSVConnWriteVIOGet(contp);
@@ -271,7 +272,7 @@ handle_icap_headers(TSCont contp, TransformData *data)
   if (debug_enabled) {
     if (icap_status_line.find("506") != std::string::npos) {
       setup_icap_status_header(data, "@ICAP-Status", "ICAP server is too busy");
-      TSDebug(PLUGIN_NAME, "Sending OS response body.");
+      Dbg(dbg_ctl, "Sending OS response body.");
       return 1;
     }
   }
@@ -287,7 +288,7 @@ handle_icap_headers(TSCont contp, TransformData *data)
 static void
 handle_icap_http_header(TransformData *data)
 {
-  // TSDebug(PLUGIN_NAME, "Handling http header");
+  // Dbg(dbg_ctl, "Handling http header");
   int64_t pos = data->http_header.find("\r\n");
   std::string http_status_line =
     pos != static_cast<int64_t>(std::string::npos) ? data->http_header.substr(0, pos) : data->http_header;
@@ -415,7 +416,7 @@ transform_create(TSHttpTxn txnp)
   data  = new TransformData(txnp);
 
   TSContDataSet(contp, data);
-  // TSDebug(PLUGIN_NAME, "Initialization complete.");
+  // Dbg(dbg_ctl, "Initialization complete.");
   return contp;
 }
 
@@ -709,7 +710,7 @@ static int
 transform_buffer_os_resp(TSCont contp, TransformData *data)
 {
   data->state = State::BUFFER_OS_RESP;
-  TSDebug(PLUGIN_NAME, "Buffer os response.");
+  Dbg(dbg_ctl, "Buffer os response.");
   if (!data->os_resp_buf) {
     data->os_resp_buf = TSIOBufferCreate();
   }
@@ -833,7 +834,7 @@ transform_read_icap_header_event(TSCont contp, TransformData *data, TSEvent even
 
       /* Read in the icap header */
       data->icap_header += chunk;
-      // TSDebug(PLUGIN_NAME, "Headers: \n%s", icap_header.c_str());
+      // Dbg(dbg_ctl, "Headers: \n%s", icap_header.c_str());
       int64_t pos          = data->icap_header.find("\r\n\r\n");
       int64_t token_length = std::string("\r\n\r\n").size();
 
@@ -889,7 +890,7 @@ transform_read_http_header_event(TSCont contp, TransformData *data, TSEvent even
       std::string chunk   = std::string(buf, read_ndone);
 
       data->http_header += chunk;
-      // TSDebug(PLUGIN_NAME, "Headers: \n%s", icap_header.c_str());
+      // Dbg(dbg_ctl, "Headers: \n%s", icap_header.c_str());
       int64_t pos          = data->http_header.find("\r\n\r\n");
       int64_t token_length = std::string("\r\n").size();
 
@@ -1063,7 +1064,7 @@ transform_handler(TSCont contp, TSEvent event, void *edata)
 {
   /* Check to see if the transformation has been closed by a call to TSVConnClose. */
   if (TSVConnClosedGet(contp)) {
-    TSDebug(PLUGIN_NAME, "transformation closed");
+    Dbg(dbg_ctl, "transformation closed");
     transform_destroy(contp);
     return 0;
   } else {
@@ -1074,7 +1075,7 @@ transform_handler(TSCont contp, TSEvent event, void *edata)
       TSError("[%s] Didn't get Continuation's Data, ignoring event", PLUGIN_NAME);
       return 0;
     }
-    TSDebug(PLUGIN_NAME, "transform handler event [%d], data->state = [%d]", event, static_cast<int>(data->state));
+    Dbg(dbg_ctl, "transform handler event [%d], data->state = [%d]", event, static_cast<int>(data->state));
 
     switch (data->state) {
     case State::BEGIN:
diff --git a/plugins/experimental/inliner/ats-inliner.cc b/plugins/experimental/inliner/ats-inliner.cc
index a895bbf757f..d45e390235e 100644
--- a/plugins/experimental/inliner/ats-inliner.cc
+++ b/plugins/experimental/inliner/ats-inliner.cc
@@ -35,6 +35,12 @@
 #error Please define a PLUGIN_TAG before including this file.
 #endif
 
+namespace inliner_ns
+{
+DbgCtl dbg_ctl{PLUGIN_TAG};
+}
+using namespace inliner_ns;
+
 // disable timeout for now
 const size_t timeout = 0;
 
@@ -98,7 +104,7 @@ int
 inliner_transform(TSCont c, TSEvent e, void *)
 {
   if (TSVConnClosedGet(c)) {
-    TSDebug(PLUGIN_TAG, "connection closed");
+    Dbg(dbg_ctl, "connection closed");
     MyData *const data = static_cast<MyData *>(TSContDataGet(c));
     if (data != nullptr) {
       TSContDataSet(c, nullptr);
diff --git a/plugins/experimental/inliner/cache-handler.h b/plugins/experimental/inliner/cache-handler.h
index 2bde34e8a01..922ecd9f755 100644
--- a/plugins/experimental/inliner/cache-handler.h
+++ b/plugins/experimental/inliner/cache-handler.h
@@ -45,6 +45,12 @@
 
 #define VERSION "&version=1"
 
+namespace inliner_ns
+{
+extern DbgCtl dbg_ctl;
+}
+using namespace inliner_ns;
+
 namespace ats
 {
 bool
@@ -111,7 +117,7 @@ namespace inliner
         contentType_ = "image/png";
       } else {
         // TODO(dmorilha): check png signature code.
-        TSDebug(PLUGIN_TAG, "Invalid signature for: %s", url_.c_str());
+        Dbg(dbg_ctl, "Invalid signature for: %s", url_.c_str());
       }
 
       if (contentType_ != "image/gif" && contentType_ != "image/jpeg" && contentType_ != "image/jpg" &&
@@ -134,7 +140,7 @@ namespace inliner
           output.resize(size + s);
         }
 
-        TSDebug(PLUGIN_TAG, "%s (%s) %lu %lu", url_.c_str(), contentType_.c_str(), content_.size(), output.size());
+        Dbg(dbg_ctl, "%s (%s) %lu %lu", url_.c_str(), contentType_.c_str(), content_.size(), output.size());
 
         cache::write(url_ + VERSION, std::move(output));
       }
@@ -158,7 +164,7 @@ namespace inliner
           std::stringstream ss(contentLengthValue);
           uint32_t contentLength = 0;
           ss >> contentLength;
-          TSDebug(PLUGIN_TAG, "Content-Length: %i", contentLength);
+          Dbg(dbg_ctl, "Content-Length: %i", contentLength);
           content_.reserve(contentLength);
         }
       }
@@ -167,13 +173,13 @@ namespace inliner
     void
     timeout() const
     {
-      TSDebug(PLUGIN_TAG, "Fetch timeout");
+      Dbg(dbg_ctl, "Fetch timeout");
     }
 
     void
     error() const
     {
-      TSDebug(PLUGIN_TAG, "Fetch error");
+      Dbg(dbg_ctl, "Fetch error");
     }
   };
 
@@ -272,7 +278,7 @@ namespace inliner
     {
       assert(v != nullptr);
 
-      TSDebug(PLUGIN_TAG, "cache hit for %s (%" PRId64 " bytes)", src_.c_str(), TSVConnCacheObjectSizeGet(v));
+      Dbg(dbg_ctl, "cache hit for %s (%" PRId64 " bytes)", src_.c_str(), TSVConnCacheObjectSizeGet(v));
 
       assert(sink_);
 
@@ -328,7 +334,7 @@ namespace inliner
 
       auto io{std::make_unique<io::IO>()};
 
-      TSDebug(PLUGIN_TAG, "request:\n%s", request.c_str());
+      Dbg(dbg_ctl, "request:\n%s", request.c_str());
 
       auto size{io->copy(request)};
       ats::get(std::move(io), size, AnotherClass(src_));
diff --git a/plugins/experimental/inliner/cache.cc b/plugins/experimental/inliner/cache.cc
index f1375ee0b9e..36c7f916c06 100644
--- a/plugins/experimental/inliner/cache.cc
+++ b/plugins/experimental/inliner/cache.cc
@@ -26,6 +26,12 @@
 #error Please define a PLUGIN_TAG before including this file.
 #endif
 
+namespace inliner_ns
+{
+extern DbgCtl dbg_ctl;
+}
+using namespace inliner_ns;
+
 namespace ats
 {
 namespace cache
@@ -54,13 +60,13 @@ namespace cache
       self->out_ = io::IO::write(self->vconnection_, c, self->content_.size());
       break;
     case TS_EVENT_CACHE_OPEN_WRITE_FAILED:
-      TSDebug(PLUGIN_TAG, "write failed");
+      Dbg(dbg_ctl, "write failed");
       delete self;
       TSContDataSet(c, nullptr);
       TSContDestroy(c);
       break;
     case TS_EVENT_VCONN_WRITE_COMPLETE:
-      TSDebug(PLUGIN_TAG, "write completed");
+      Dbg(dbg_ctl, "write completed");
       assert(self->vconnection_ != nullptr);
       TSVConnClose(self->vconnection_);
       delete self;
diff --git a/plugins/experimental/inliner/fetcher.cc b/plugins/experimental/inliner/fetcher.cc
index ee08caf222f..c91257e1504 100644
--- a/plugins/experimental/inliner/fetcher.cc
+++ b/plugins/experimental/inliner/fetcher.cc
@@ -70,7 +70,7 @@ HttpParser::parse(io::IO &io)
     TSIOBufferReaderConsume(io.reader, iterator - begin);
 
     if (parsed_) {
-      TSDebug(PLUGIN_TAG, "HttpParser: response parsing is complete (%u response status code)", statusCode());
+      Dbg(dbg_ctl, "HttpParser: response parsing is complete (%u response status code)", statusCode());
       assert(parser_ != nullptr);
       destroyParser();
       return true;
diff --git a/plugins/experimental/inliner/fetcher.h b/plugins/experimental/inliner/fetcher.h
index df43fb73b4a..d5ef0349e54 100644
--- a/plugins/experimental/inliner/fetcher.h
+++ b/plugins/experimental/inliner/fetcher.h
@@ -62,6 +62,12 @@
 
 #define unlikely(x) __builtin_expect((x), 0)
 
+namespace inliner_ns
+{
+extern DbgCtl dbg_ctl;
+}
+using namespace inliner_ns;
+
 namespace ats
 {
 struct HttpParser {
@@ -198,22 +204,22 @@ template <class T> struct HttpTransaction {
     assert(self != nullptr);
     switch (e) {
     case TS_EVENT_ERROR:
-      TSDebug(PLUGIN_TAG, "HttpTransaction: ERROR");
+      Dbg(dbg_ctl, "HttpTransaction: ERROR");
       self->t_.error();
       self->abort();
       close(self);
       TSContDataSet(c, nullptr);
       break;
     case TS_EVENT_VCONN_EOS:
-      TSDebug(PLUGIN_TAG, "HttpTransaction: EOS");
+      Dbg(dbg_ctl, "HttpTransaction: EOS");
       goto here;
 
     case TS_EVENT_VCONN_READ_COMPLETE:
-      TSDebug(PLUGIN_TAG, "HttpTransaction: Read Complete");
+      Dbg(dbg_ctl, "HttpTransaction: Read Complete");
       goto here;
 
     case TS_EVENT_VCONN_READ_READY:
-      TSDebug(PLUGIN_TAG, "HttpTransaction: Read");
+      Dbg(dbg_ctl, "HttpTransaction: Read");
     here : {
       assert(self->in_ != nullptr);
       assert(self->in_->reader != nullptr);
@@ -261,7 +267,7 @@ template <class T> struct HttpTransaction {
       }
     } break;
     case TS_EVENT_VCONN_WRITE_COMPLETE:
-      TSDebug(PLUGIN_TAG, "HttpTransaction: Write Complete");
+      Dbg(dbg_ctl, "HttpTransaction: Write Complete");
       self->parsingHeaders_ = true;
       assert(self->in_ == nullptr);
       self->in_ = io::IO::read(self->vconnection_, c);
@@ -272,15 +278,15 @@ template <class T> struct HttpTransaction {
       self->out_.reset();
       break;
     case TS_EVENT_VCONN_WRITE_READY:
-      TSDebug(PLUGIN_TAG, "HttpTransaction: Write Ready (Done: %" PRId64 " Todo: %" PRId64 ")", TSVIONDoneGet(self->out_->vio),
-              TSVIONTodoGet(self->out_->vio));
+      Dbg(dbg_ctl, "HttpTransaction: Write Ready (Done: %" PRId64 " Todo: %" PRId64 ")", TSVIONDoneGet(self->out_->vio),
+          TSVIONTodoGet(self->out_->vio));
       assert(self->out_ != nullptr);
       TSVIOReenable(self->out_->vio);
       break;
     case 106:
     case TS_EVENT_TIMEOUT:
     case TS_EVENT_VCONN_INACTIVITY_TIMEOUT:
-      TSDebug(PLUGIN_TAG, "HttpTransaction: Timeout");
+      Dbg(dbg_ctl, "HttpTransaction: Timeout");
       self->t_.timeout();
       self->abort();
       close(self);
@@ -303,7 +309,7 @@ get(const std::string &a, std::unique_ptr<io::IO> i, const int64_t l, const T &t
   socket.sin_family = AF_INET;
   socket.sin_port   = 80;
   if (!inet_pton(AF_INET, a.c_str(), &socket.sin_addr)) {
-    TSDebug(PLUGIN_TAG, "ats::get Invalid address provided \"%s\".", a.c_str());
+    Dbg(dbg_ctl, "ats::get Invalid address provided \"%s\".", a.c_str());
     return false;
   }
   TSVConn vconn = TSHttpConnect(reinterpret_cast<sockaddr *>(&socket));
@@ -313,7 +319,7 @@ get(const std::string &a, std::unique_ptr<io::IO> i, const int64_t l, const T &t
   Transaction *transaction = new Transaction(vconn, contp, std::move(i), l, t);
   TSContDataSet(contp, transaction);
   if (ti > 0) {
-    TSDebug(PLUGIN_TAG, "ats::get Setting active timeout to: %" PRId64, ti);
+    Dbg(dbg_ctl, "ats::get Setting active timeout to: %" PRId64, ti);
     transaction->timeout(ti);
   }
   return true;
diff --git a/plugins/experimental/inliner/inliner-handler.cc b/plugins/experimental/inliner/inliner-handler.cc
index 0fa41009e5f..0477bd50895 100644
--- a/plugins/experimental/inliner/inliner-handler.cc
+++ b/plugins/experimental/inliner/inliner-handler.cc
@@ -61,7 +61,6 @@ namespace inliner
   {
     assert(s > 0);
     assert(sink2_);
-    // TSDebug(PLUGIN_TAG, "size: %lu, offset: %lu, sum: %lu", s, o, (s + o));
     *sink2_ << ats::io::ReaderSize(reader_, s, o);
     return s;
   }
diff --git a/plugins/experimental/inliner/ts.cc b/plugins/experimental/inliner/ts.cc
index 10abf3394ef..7b26275d7ab 100644
--- a/plugins/experimental/inliner/ts.cc
+++ b/plugins/experimental/inliner/ts.cc
@@ -26,6 +26,12 @@
 
 #include "ts.h"
 
+namespace inliner_ns
+{
+extern DbgCtl dbg_ctl;
+}
+using namespace inliner_ns;
+
 namespace ats
 {
 namespace io
@@ -82,7 +88,7 @@ namespace io
   {
     assert(mutex_ != nullptr);
     const Lock lock(mutex_);
-    TSDebug(PLUGIN_TAG, "~WriteOperation");
+    Dbg(dbg_ctl, "~WriteOperation");
 
     vio_ = nullptr;
 
@@ -151,7 +157,7 @@ namespace io
     WriteOperationPointer *const p = static_cast<WriteOperationPointer *>(TSContDataGet(c));
 
     if (TS_EVENT_VCONN_WRITE_COMPLETE == e) {
-      TSDebug(PLUGIN_TAG, "TS_EVENT_VCONN_WRITE_COMPLETE");
+      Dbg(dbg_ctl, "TS_EVENT_VCONN_WRITE_COMPLETE");
       if (p != nullptr) {
         TSContDataSet(c, nullptr);
         delete p;
@@ -278,7 +284,6 @@ namespace io
 
   IOSink::~IOSink()
   {
-    // TSDebug(PLUGIN_TAG, "~IOSink %p", this);
     const WriteOperationPointer operation = operation_.lock();
     if (operation) {
       operation_.reset();
@@ -380,7 +385,6 @@ namespace io
     const size_t copied    = TSIOBufferCopy(b, reader_, available, 0);
     assert(copied == available);
     TSIOBufferReaderConsume(reader_, copied);
-    // TSDebug(PLUGIN_TAG, "BufferNode::process %lu", copied);
     return Node::Result(copied, TSIOBufferReaderAvail(reader_) == 0);
   }
 
@@ -401,7 +405,6 @@ namespace io
       data_->first_ = true;
     }
     SinkPointer pointer(new Sink(data_));
-    // TSDebug(PLUGIN_TAG, "IOSink branch %p", pointer.get());
     return pointer;
   }
 
@@ -418,13 +421,11 @@ namespace io
       data->first_ = first;
     }
     SinkPointer pointer(new Sink(data));
-    // TSDebug(PLUGIN_TAG, "Sink branch %p", pointer.get());
     return pointer;
   }
 
   Sink::~Sink()
   {
-    // TSDebug(PLUGIN_TAG, "~Sink %p", this);
     assert(data_);
     assert(data_.use_count() >= 1);
     assert(data_->root_);
@@ -452,15 +453,11 @@ namespace io
       }
     }
 
-    // TSDebug(PLUGIN_TAG, "Data::process %li", length);
-
     if (begin != it) {
-      // TSDebug(PLUGIN_TAG, "Data::process::erase");
       nodes_.erase(begin, it);
       if (it != end) {
         Data *data = dynamic_cast<Data *>(it->get());
         while (data != nullptr) {
-          // TSDebug(PLUGIN_TAG, "new first");
           data->first_ = true;
           if (data->nodes_.empty()) {
             break;
diff --git a/plugins/experimental/inliner/ts.h b/plugins/experimental/inliner/ts.h
index 087fc8958f3..3da3682ceee 100644
--- a/plugins/experimental/inliner/ts.h
+++ b/plugins/experimental/inliner/ts.h
@@ -302,11 +302,9 @@ namespace io
         assert(data_->root_ != nullptr);
         const bool empty = data_->nodes_.empty();
         if (data_->first_ && empty) {
-          // TSDebug(PLUGIN_TAG, "flushing");
           assert(data_->root_);
           *data_->root_ << std::forward<T>(t);
         } else {
-          // TSDebug(PLUGIN_TAG, "buffering");
           BufferNode *buffer = nullptr;
           if (!empty) {
             buffer = dynamic_cast<BufferNode *>(data_->nodes_.back().get());
diff --git a/plugins/experimental/magick/magick.cc b/plugins/experimental/magick/magick.cc
index f7e89e20014..072924c6f80 100644
--- a/plugins/experimental/magick/magick.cc
+++ b/plugins/experimental/magick/magick.cc
@@ -66,7 +66,9 @@ using byte = unsigned char;
 namespace
 {
 GlobalPlugin *plugin;
-}
+
+DbgCtl dbg_ctl{PLUGIN_TAG};
+} // namespace
 
 struct ThreadPool {
   using Callback = std::function<void(void)>;
@@ -100,7 +102,7 @@ struct ThreadPool {
     for (size_t i = 0; i < size_; ++i) {
       TSThread thread = pool_[i];
       assert(nullptr != thread);
-      TSDebug(PLUGIN_TAG, "Destroying thread number %lu (%p)", i, thread);
+      Dbg(dbg_ctl, "Destroying thread number %lu (%p)", i, thread);
       TSThreadWait(thread);
       TSThreadDestroy(thread);
     }
@@ -141,7 +143,7 @@ struct ThreadPool {
         },
         this);
       assert(nullptr != pool_[i]);
-      TSDebug(PLUGIN_TAG, "Creating thread number %lu (%p)", i, pool_[i]);
+      Dbg(dbg_ctl, "Creating thread number %lu (%p)", i, pool_[i]);
     }
   }
 
@@ -464,20 +466,20 @@ struct ImageTransform : TransformationPlugin {
       argumentMap_(std::move(m)),
       threadPool_(p)
   {
-    TSDebug(PLUGIN_TAG, "ImageTransform");
+    Dbg(dbg_ctl, "ImageTransform");
   }
 
   void
   consume(const std::string_view s) override
   {
-    TSDebug(PLUGIN_TAG, "consume");
+    Dbg(dbg_ctl, "consume");
     blob_.insert(blob_.end(), s.begin(), s.end());
   }
 
   void
   handleInputComplete() override
   {
-    TSDebug(PLUGIN_TAG, "handleInputComplete");
+    Dbg(dbg_ctl, "handleInputComplete");
 
     threadPool_.emplace_back([this]() {
       magick::Image image;
@@ -498,12 +500,12 @@ struct ImageTransform : TransformationPlugin {
       const std::string_view output = wand.get();
       this->produce(output);
 
-      TSDebug(PLUGIN_TAG, "Background transformation is done, resuming continuation (%p)", this);
+      Dbg(dbg_ctl, "Background transformation is done, resuming continuation (%p)", this);
 
       this->setOutputComplete();
     });
 
-    TSDebug(PLUGIN_TAG, "Scheduling background transformation (%p)", this);
+    Dbg(dbg_ctl, "Scheduling background transformation (%p)", this);
   }
 
   CharVector arguments_;
@@ -529,7 +531,7 @@ struct GlobalHookPlugin : GlobalPlugin {
   {
     if (nullptr != f) {
       assert(0 < strlen(f));
-      TSDebug(PLUGIN_TAG, "public key file: %s", f);
+      Dbg(dbg_ctl, "public key file: %s", f);
       key_             = new magick::EVPKey();
       FILE *const file = fopen(f, "r");
       assert(nullptr != file);
@@ -573,7 +575,7 @@ struct GlobalHookPlugin : GlobalPlugin {
                                        "application/pdf" == contentType || "application/postscript" == contentType;
 
     if (compatibleContentType) {
-      TSDebug(PLUGIN_TAG, "Content-Type is compatible: %s", contentType.c_str());
+      Dbg(dbg_ctl, "Content-Type is compatible: %s", contentType.c_str());
       const QueryMap queryMap(t.getServerRequest().getUrl().getQuery());
       const auto &magickQueryParameter = queryMap["magick"];
       if (!magickQueryParameter.empty()) {
@@ -588,7 +590,7 @@ struct GlobalHookPlugin : GlobalPlugin {
             const auto &view2 = magickSigQueryParameter.front();
             CharVector magickSig(view2.data(), view2.data() + view2.size());
             magickSig.insert(magickSig.end(), '\0');
-            TSDebug(PLUGIN_TAG, "Magick Signature: %s", magickSig.data());
+            Dbg(dbg_ctl, "Magick Signature: %s", magickSig.data());
             QueryParameterToCharVector(magickSig);
             verified = magick::verify(reinterpret_cast<const byte *>(magick.data()), magick.size(),
                                       reinterpret_cast<const byte *>(magickSig.data()), magickSig.size(), key_->key);
@@ -598,11 +600,11 @@ struct GlobalHookPlugin : GlobalPlugin {
         if (verified) {
           magick.insert(magick.end(), '\0');
           QueryParameterToCharVector(magick);
-          TSDebug(PLUGIN_TAG, "ImageMagick's syntax: %s", magick.data());
+          Dbg(dbg_ctl, "ImageMagick's syntax: %s", magick.data());
           CharPointerVector argumentMap = QueryParameterToArguments(magick);
           t.addPlugin(new ImageTransform(t, std::move(magick), std::move(argumentMap), threadPool_));
         } else {
-          TSDebug(PLUGIN_TAG, "signature verification failed.");
+          Dbg(dbg_ctl, "signature verification failed.");
           TSError("[" PLUGIN_TAG "] signature verification failed.");
           t.setStatusCode(HTTP_STATUS_FORBIDDEN);
           t.error();
diff --git a/plugins/experimental/maxmind_acl/maxmind_acl.cc b/plugins/experimental/maxmind_acl/maxmind_acl.cc
index d6aaa476e7f..2bbb24680df 100644
--- a/plugins/experimental/maxmind_acl/maxmind_acl.cc
+++ b/plugins/experimental/maxmind_acl/maxmind_acl.cc
@@ -26,7 +26,7 @@ TSReturnCode
 TSRemapInit(TSRemapInterface *api_info, char *errbuf, int errbuf_size)
 {
   CHECK_REMAP_API_COMPATIBILITY(api_info, errbuf, errbuf_size);
-  TSDebug(PLUGIN_NAME, "remap plugin is successfully initialized");
+  Dbg(dbg_ctl, "remap plugin is successfully initialized");
   return TS_SUCCESS;
 }
 
@@ -45,7 +45,7 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char * /* errbuf */, int /
     return TS_ERROR;
   }
 
-  TSDebug(PLUGIN_NAME, "created remap instance with configuration %s", argv[2]);
+  Dbg(dbg_ctl, "created remap instance with configuration %s", argv[2]);
   return TS_SUCCESS;
 }
 
@@ -65,11 +65,11 @@ TSRemapStatus
 TSRemapDoRemap(void *ih, TSHttpTxn rh, TSRemapRequestInfo *rri)
 {
   if (nullptr == ih) {
-    TSDebug(PLUGIN_NAME, "No ACLs configured");
+    Dbg(dbg_ctl, "No ACLs configured");
   } else {
     Acl *a = static_cast<Acl *>(ih);
     if (!a->eval(rri, rh)) {
-      TSDebug(PLUGIN_NAME, "denying request");
+      Dbg(dbg_ctl, "denying request");
       TSHttpTxnStatusSet(rh, TS_HTTP_STATUS_FORBIDDEN);
       a->send_html(rh);
     }
diff --git a/plugins/experimental/maxmind_acl/mmdb.cc b/plugins/experimental/maxmind_acl/mmdb.cc
index 57b20de4e2c..501281d2c88 100644
--- a/plugins/experimental/maxmind_acl/mmdb.cc
+++ b/plugins/experimental/maxmind_acl/mmdb.cc
@@ -18,6 +18,11 @@
 
 #include "mmdb.h"
 
+namespace maxmind_acl_ns
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // Load the config file from param
 // check for basics
@@ -42,7 +47,7 @@ Acl::init(char const *filename)
   }
 
   if (stat(configloc.c_str(), &s) < 0) {
-    TSDebug(PLUGIN_NAME, "Could not stat %s", configloc.c_str());
+    Dbg(dbg_ctl, "Could not stat %s", configloc.c_str());
     return status;
   }
 
@@ -50,11 +55,11 @@ Acl::init(char const *filename)
     _config = YAML::LoadFile(configloc.c_str());
 
     if (_config.IsNull()) {
-      TSDebug(PLUGIN_NAME, "Config file not found or unreadable");
+      Dbg(dbg_ctl, "Config file not found or unreadable");
       return status;
     }
     if (!_config["maxmind"]) {
-      TSDebug(PLUGIN_NAME, "Config file not in maxmind namespace");
+      Dbg(dbg_ctl, "Config file not in maxmind namespace");
       return status;
     }
 
@@ -65,7 +70,7 @@ Acl::init(char const *filename)
     for (YAML::const_iterator it = maxmind.begin(); it != maxmind.end(); ++it) {
       const std::string &name    = it->first.as<std::string>();
       YAML::NodeType::value type = it->second.Type();
-      TSDebug(PLUGIN_NAME, "name: %s, value: %d", name.c_str(), type);
+      Dbg(dbg_ctl, "name: %s, value: %d", name.c_str(), type);
     }
 #endif
   } catch (const YAML::Exception &e) {
@@ -83,7 +88,7 @@ Acl::init(char const *filename)
   status = loaddb(maxmind["database"]);
 
   if (!status) {
-    TSDebug(PLUGIN_NAME, "Failed to load MaxMind Database");
+    Dbg(dbg_ctl, "Failed to load MaxMind Database");
     return status;
   }
 
@@ -105,7 +110,7 @@ Acl::init(char const *filename)
   _public_proxy       = false;
 
   if (loadallow(maxmind["allow"])) {
-    TSDebug(PLUGIN_NAME, "Loaded Allow ruleset");
+    Dbg(dbg_ctl, "Loaded Allow ruleset");
     status = true;
   } else {
     // We have no proper allow ruleset
@@ -114,7 +119,7 @@ Acl::init(char const *filename)
   }
 
   if (loaddeny(maxmind["deny"])) {
-    TSDebug(PLUGIN_NAME, "Loaded Deny ruleset");
+    Dbg(dbg_ctl, "Loaded Deny ruleset");
     status = true;
   }
 
@@ -123,7 +128,7 @@ Acl::init(char const *filename)
   _anonymous_blocking = loadanonymous(maxmind["anonymous"]);
 
   if (!status) {
-    TSDebug(PLUGIN_NAME, "Failed to load any rulesets, none specified");
+    Dbg(dbg_ctl, "Failed to load any rulesets, none specified");
     status = false;
   }
 
@@ -136,11 +141,11 @@ bool
 Acl::loadanonymous(const YAML::Node &anonNode)
 {
   if (!anonNode) {
-    TSDebug(PLUGIN_NAME, "No anonymous rules set");
+    Dbg(dbg_ctl, "No anonymous rules set");
     return false;
   }
   if (anonNode.IsNull()) {
-    TSDebug(PLUGIN_NAME, "Anonymous rules are NULL");
+    Dbg(dbg_ctl, "Anonymous rules are NULL");
     return false;
   }
 
@@ -149,43 +154,43 @@ Acl::loadanonymous(const YAML::Node &anonNode)
   for (YAML::const_iterator it = anonNode.begin(); it != anonNode.end(); ++it) {
     const std::string &name    = it->first.as<std::string>();
     YAML::NodeType::value type = it->second.Type();
-    TSDebug(PLUGIN_NAME, "name: %s, value: %d", name.c_str(), type);
+    Dbg(dbg_ctl, "name: %s, value: %d", name.c_str(), type);
   }
 #endif
 
   try {
     if (anonNode["ip"].as<bool>(false)) {
-      TSDebug(PLUGIN_NAME, "saw ip true");
+      Dbg(dbg_ctl, "saw ip true");
       _anonymous_ip = true;
     }
 
     if (anonNode["vpn"].as<bool>(false)) {
-      TSDebug(PLUGIN_NAME, "saw vpn true");
+      Dbg(dbg_ctl, "saw vpn true");
       _anonymous_vpn = true;
     }
 
     if (anonNode["hosting"].as<bool>(false)) {
-      TSDebug(PLUGIN_NAME, "saw hosting true");
+      Dbg(dbg_ctl, "saw hosting true");
       _hosting_provider = true;
     }
 
     if (anonNode["public"].as<bool>(false)) {
-      TSDebug(PLUGIN_NAME, "saw public proxy true");
+      Dbg(dbg_ctl, "saw public proxy true");
       _public_proxy = true;
     }
 
     if (anonNode["tor"].as<bool>(false)) {
-      TSDebug(PLUGIN_NAME, "saw tor exit node true");
+      Dbg(dbg_ctl, "saw tor exit node true");
       _tor_exit_node = true;
     }
 
     if (anonNode["residential"].as<bool>(false)) {
-      TSDebug(PLUGIN_NAME, "saw residential proxy true");
+      Dbg(dbg_ctl, "saw residential proxy true");
       _residential_proxy = true;
     }
 
   } catch (const YAML::Exception &e) {
-    TSDebug(PLUGIN_NAME, "YAML::Exception %s when parsing YAML config file anonymous list", e.what());
+    Dbg(dbg_ctl, "YAML::Exception %s when parsing YAML config file anonymous list", e.what());
     return false;
   }
 
@@ -198,11 +203,11 @@ bool
 Acl::loaddeny(const YAML::Node &denyNode)
 {
   if (!denyNode) {
-    TSDebug(PLUGIN_NAME, "No Deny rules set");
+    Dbg(dbg_ctl, "No Deny rules set");
     return false;
   }
   if (denyNode.IsNull()) {
-    TSDebug(PLUGIN_NAME, "Deny rules are NULL");
+    Dbg(dbg_ctl, "Deny rules are NULL");
     return false;
   }
 
@@ -211,7 +216,7 @@ Acl::loaddeny(const YAML::Node &denyNode)
   for (YAML::const_iterator it = denyNode.begin(); it != denyNode.end(); ++it) {
     const std::string &name    = it->first.as<std::string>();
     YAML::NodeType::value type = it->second.Type();
-    TSDebug(PLUGIN_NAME, "name: %s, value: %d", name.c_str(), type);
+    Dbg(dbg_ctl, "name: %s, value: %d", name.c_str(), type);
   }
 #endif
 
@@ -225,12 +230,12 @@ Acl::loaddeny(const YAML::Node &denyNode)
             allow_country.insert_or_assign(i.as<std::string>(), false);
           }
         } else {
-          TSDebug(PLUGIN_NAME, "Invalid country code allow list yaml");
+          Dbg(dbg_ctl, "Invalid country code allow list yaml");
         }
       }
     }
   } catch (const YAML::Exception &e) {
-    TSDebug(PLUGIN_NAME, "YAML::Exception %s when parsing YAML config file country code deny list for maxmind", e.what());
+    Dbg(dbg_ctl, "YAML::Exception %s when parsing YAML config file country code deny list for maxmind", e.what());
     return false;
   }
 
@@ -244,16 +249,16 @@ Acl::loaddeny(const YAML::Node &denyNode)
           for (auto &&i : ip) {
             if (swoc::IPRange r; r.load(i.Scalar())) {
               deny_ip_map.fill(r);
-              TSDebug(PLUGIN_NAME, "Denying ip fam %d ", r.family());
+              Dbg(dbg_ctl, "Denying ip fam %d ", r.family());
             }
           }
         } else {
-          TSDebug(PLUGIN_NAME, "Invalid IP deny list yaml");
+          Dbg(dbg_ctl, "Invalid IP deny list yaml");
         }
       }
     }
   } catch (const YAML::Exception &e) {
-    TSDebug(PLUGIN_NAME, "YAML::Exception %s when parsing YAML config file ip deny list for maxmind", e.what());
+    Dbg(dbg_ctl, "YAML::Exception %s when parsing YAML config file ip deny list for maxmind", e.what());
     return false;
   }
 
@@ -264,9 +269,9 @@ Acl::loaddeny(const YAML::Node &denyNode)
 
 #if 0
   std::unordered_map<std::string, bool>::iterator cursor;
-  TSDebug(PLUGIN_NAME, "Deny Country List:");
+  Dbg(dbg_ctl, "Deny Country List:");
   for (cursor = allow_country.begin(); cursor != allow_country.end(); cursor++) {
-    TSDebug(PLUGIN_NAME, "%s:%d", cursor->first.c_str(), cursor->second);
+    Dbg(dbg_ctl, "%s:%d", cursor->first.c_str(), cursor->second);
   }
 #endif
 
@@ -278,11 +283,11 @@ bool
 Acl::loadallow(const YAML::Node &allowNode)
 {
   if (!allowNode) {
-    TSDebug(PLUGIN_NAME, "No Allow rules set");
+    Dbg(dbg_ctl, "No Allow rules set");
     return false;
   }
   if (allowNode.IsNull()) {
-    TSDebug(PLUGIN_NAME, "Allow rules are NULL");
+    Dbg(dbg_ctl, "Allow rules are NULL");
     return false;
   }
 
@@ -291,7 +296,7 @@ Acl::loadallow(const YAML::Node &allowNode)
   for (YAML::const_iterator it = allowNode.begin(); it != allowNode.end(); ++it) {
     const std::string &name    = it->first.as<std::string>();
     YAML::NodeType::value type = it->second.Type();
-    TSDebug(PLUGIN_NAME, "name: %s, value: %d", name.c_str(), type);
+    Dbg(dbg_ctl, "name: %s, value: %d", name.c_str(), type);
   }
 #endif
 
@@ -306,12 +311,12 @@ Acl::loadallow(const YAML::Node &allowNode)
           }
 
         } else {
-          TSDebug(PLUGIN_NAME, "Invalid country code allow list yaml");
+          Dbg(dbg_ctl, "Invalid country code allow list yaml");
         }
       }
     }
   } catch (const YAML::Exception &e) {
-    TSDebug(PLUGIN_NAME, "YAML::Exception %s when parsing YAML config file country code allow list for maxmind", e.what());
+    Dbg(dbg_ctl, "YAML::Exception %s when parsing YAML config file country code allow list for maxmind", e.what());
     return false;
   }
 
@@ -325,16 +330,16 @@ Acl::loadallow(const YAML::Node &allowNode)
           for (auto &&i : ip) {
             if (swoc::IPRange r; r.load(i.Scalar())) {
               allow_ip_map.fill(r);
-              TSDebug(PLUGIN_NAME, "loading ip: valid: fam %d ", r.family());
+              Dbg(dbg_ctl, "loading ip: valid: fam %d ", r.family());
             }
           }
         } else {
-          TSDebug(PLUGIN_NAME, "Invalid IP allow list yaml");
+          Dbg(dbg_ctl, "Invalid IP allow list yaml");
         }
       }
     }
   } catch (const YAML::Exception &e) {
-    TSDebug(PLUGIN_NAME, "YAML::Exception %s when parsing YAML config file ip allow list for maxmind", e.what());
+    Dbg(dbg_ctl, "YAML::Exception %s when parsing YAML config file ip allow list for maxmind", e.what());
     return false;
   }
 
@@ -345,9 +350,9 @@ Acl::loadallow(const YAML::Node &allowNode)
 
 #if 0
   std::unordered_map<std::string, bool>::iterator cursor;
-  TSDebug(PLUGIN_NAME, "Allow Country List:");
+  Dbg(dbg_ctl, "Allow Country List:");
   for (cursor = allow_country.begin(); cursor != allow_country.end(); cursor++) {
-    TSDebug(PLUGIN_NAME, "%s:%d", cursor->first.c_str(), cursor->second);
+    Dbg(dbg_ctl, "%s:%d", cursor->first.c_str(), cursor->second);
   }
 #endif
 
@@ -382,7 +387,7 @@ Acl::parseregex(const YAML::Node &regex, bool allow)
           }
 
           for (std::size_t y = 0; y < temprule.size() - 1; y++) {
-            TSDebug(PLUGIN_NAME, "Adding regex: %s, for country: %s", temp._regex_s.c_str(), i[y].as<std::string>().c_str());
+            Dbg(dbg_ctl, "Adding regex: %s, for country: %s", temp._regex_s.c_str(), i[y].as<std::string>().c_str());
             if (allow) {
               allow_regex[i[y].as<std::string>()].push_back(temp);
             } else {
@@ -393,7 +398,7 @@ Acl::parseregex(const YAML::Node &regex, bool allow)
       }
     }
   } catch (const YAML::Exception &e) {
-    TSDebug(PLUGIN_NAME, "YAML::Exception %s when parsing YAML config file regex allow list for maxmind", e.what());
+    Dbg(dbg_ctl, "YAML::Exception %s when parsing YAML config file regex allow list for maxmind", e.what());
     return;
   }
 }
@@ -405,12 +410,12 @@ Acl::loadhtml(const YAML::Node &htmlNode)
   std::ifstream f;
 
   if (!htmlNode) {
-    TSDebug(PLUGIN_NAME, "No html field set");
+    Dbg(dbg_ctl, "No html field set");
     return;
   }
 
   if (htmlNode.IsNull()) {
-    TSDebug(PLUGIN_NAME, "Html field not set");
+    Dbg(dbg_ctl, "Html field not set");
     return;
   }
 
@@ -427,7 +432,7 @@ Acl::loadhtml(const YAML::Node &htmlNode)
   if (f.is_open()) {
     _html.append(std::istreambuf_iterator<char>(f), std::istreambuf_iterator<char>());
     f.close();
-    TSDebug(PLUGIN_NAME, "Loaded HTML from %s", htmlloc.c_str());
+    Dbg(dbg_ctl, "Loaded HTML from %s", htmlloc.c_str());
   } else {
     TSError("[%s] Unable to open HTML file %s", PLUGIN_NAME, htmlloc.c_str());
   }
@@ -440,11 +445,11 @@ Acl::loaddb(const YAML::Node &dbNode)
   std::string dbloc, dbname;
 
   if (!dbNode) {
-    TSDebug(PLUGIN_NAME, "No Database field set");
+    Dbg(dbg_ctl, "No Database field set");
     return false;
   }
   if (dbNode.IsNull()) {
-    TSDebug(PLUGIN_NAME, "Database file not set");
+    Dbg(dbg_ctl, "Database file not set");
     return false;
   }
   dbname = dbNode.as<std::string>();
@@ -463,12 +468,12 @@ Acl::loaddb(const YAML::Node &dbNode)
 
   int status = MMDB_open(dbloc.c_str(), MMDB_MODE_MMAP, &_mmdb);
   if (MMDB_SUCCESS != status) {
-    TSDebug(PLUGIN_NAME, "Can't open DB %s - %s", dbloc.c_str(), MMDB_strerror(status));
+    Dbg(dbg_ctl, "Can't open DB %s - %s", dbloc.c_str(), MMDB_strerror(status));
     return false;
   }
 
   db_loaded = true;
-  TSDebug(PLUGIN_NAME, "Initialized MMDB with %s", dbloc.c_str());
+  Dbg(dbg_ctl, "Initialized MMDB with %s", dbloc.c_str());
   return true;
 }
 
@@ -481,7 +486,7 @@ Acl::eval(TSRemapRequestInfo *rri, TSHttpTxn txnp)
   auto sockaddr = TSHttpTxnClientAddrGet(txnp);
 
   if (sockaddr == nullptr) {
-    TSDebug(PLUGIN_NAME, "Err during TsHttpClientAddrGet, nullptr returned");
+    Dbg(dbg_ctl, "Err during TsHttpClientAddrGet, nullptr returned");
     ret = false;
     return ret;
   }
@@ -489,7 +494,7 @@ Acl::eval(TSRemapRequestInfo *rri, TSHttpTxn txnp)
   MMDB_lookup_result_s result = MMDB_lookup_sockaddr(&_mmdb, sockaddr, &mmdb_error);
 
   if (MMDB_SUCCESS != mmdb_error) {
-    TSDebug(PLUGIN_NAME, "Error during sockaddr lookup: %s", MMDB_strerror(mmdb_error));
+    Dbg(dbg_ctl, "Error during sockaddr lookup: %s", MMDB_strerror(mmdb_error));
     ret = false;
     return ret;
   }
@@ -498,7 +503,7 @@ Acl::eval(TSRemapRequestInfo *rri, TSHttpTxn txnp)
   if (result.found_entry) {
     int status = MMDB_get_entry_data_list(&result.entry, &entry_data_list);
     if (MMDB_SUCCESS != status) {
-      TSDebug(PLUGIN_NAME, "Error looking up entry data: %s", MMDB_strerror(status));
+      Dbg(dbg_ctl, "Error looking up entry data: %s", MMDB_strerror(status));
       ret = false;
       return ret;
     }
@@ -513,7 +518,7 @@ Acl::eval(TSRemapRequestInfo *rri, TSHttpTxn txnp)
       FILE *temp = fmemopen(&buffer[0], 4096, "wb+");
       int status = MMDB_dump_entry_data_list(temp, entry_data_list, 0);
       fflush(temp);
-      TSDebug(PLUGIN_NAME, "Entry: %s, status: %s, type: %d", buffer, MMDB_strerror(status), entry_data_list->entry_data.type);
+      Dbg(dbg_ctl, "Entry: %s, status: %s, type: %d", buffer, MMDB_strerror(status), entry_data_list->entry_data.type);
 #endif
 
       MMDB_entry_data_s entry_data;
@@ -523,7 +528,7 @@ Acl::eval(TSRemapRequestInfo *rri, TSHttpTxn txnp)
         TSMLoc ul;
         TSReturnCode rc = TSHttpTxnPristineUrlGet(txnp, &mbuf, &ul);
         if (rc != TS_SUCCESS) {
-          TSDebug(PLUGIN_NAME, "Failed call to TSHttpTxnPristineUrlGet()");
+          Dbg(dbg_ctl, "Failed call to TSHttpTxnPristineUrlGet()");
           return false;
         }
         int host_len = 0, path_len = 0;
@@ -538,7 +543,7 @@ Acl::eval(TSRemapRequestInfo *rri, TSHttpTxn txnp)
       if (!allow_country.empty() || !allow_regex.empty() || !deny_regex.empty()) {
         status = MMDB_get_value(&result.entry, &entry_data, "country", "iso_code", NULL);
         if (MMDB_SUCCESS != status) {
-          TSDebug(PLUGIN_NAME, "err on get country code value: %s", MMDB_strerror(status));
+          Dbg(dbg_ctl, "err on get country code value: %s", MMDB_strerror(status));
           return false;
         }
         if (entry_data.has_data) {
@@ -553,31 +558,31 @@ Acl::eval(TSRemapRequestInfo *rri, TSHttpTxn txnp)
       // If blocked here, then block as well
       if (_anonymous_blocking) {
         if (!eval_anonymous(&result.entry)) {
-          TSDebug(PLUGIN_NAME, "Blocking Anonymous IP");
+          Dbg(dbg_ctl, "Blocking Anonymous IP");
           ret = false;
         }
       }
     }
   } else {
-    TSDebug(PLUGIN_NAME, "No Country Code entry for this IP was found");
+    Dbg(dbg_ctl, "No Country Code entry for this IP was found");
     ret = false;
   }
 
   // Test for allowable IPs based on our lists
   switch (eval_ip(TSHttpTxnClientAddrGet(txnp))) {
   case ALLOW_IP:
-    TSDebug(PLUGIN_NAME, "Saw explicit allow of this IP");
+    Dbg(dbg_ctl, "Saw explicit allow of this IP");
     ret = true;
     break;
   case DENY_IP:
-    TSDebug(PLUGIN_NAME, "Saw explicit deny of this IP");
+    Dbg(dbg_ctl, "Saw explicit deny of this IP");
     ret = false;
     break;
   case UNKNOWN_IP:
-    TSDebug(PLUGIN_NAME, "Unknown IP, following default from ruleset: %d", ret);
+    Dbg(dbg_ctl, "Unknown IP, following default from ruleset: %d", ret);
     break;
   default:
-    TSDebug(PLUGIN_NAME, "Unknown client addr ip state, should not get here");
+    Dbg(dbg_ctl, "Unknown client addr ip state, should not get here");
     ret = false;
     break;
   }
@@ -607,7 +612,7 @@ Acl::eval_anonymous(MMDB_entry_s *entry)
     if ((MMDB_SUCCESS == status) && (entry_data.has_data)) {
       if (entry_data.type == MMDB_DATA_TYPE_BOOLEAN) {
         if (entry_data.boolean == true) {
-          TSDebug(PLUGIN_NAME, "saw is_anonymous set to true bool");
+          Dbg(dbg_ctl, "saw is_anonymous set to true bool");
           return false;
         }
       }
@@ -619,7 +624,7 @@ Acl::eval_anonymous(MMDB_entry_s *entry)
     if ((MMDB_SUCCESS == status) && (entry_data.has_data)) {
       if (entry_data.type == MMDB_DATA_TYPE_BOOLEAN) {
         if (entry_data.boolean == true) {
-          TSDebug(PLUGIN_NAME, "saw is_anonymous vpn set to true bool");
+          Dbg(dbg_ctl, "saw is_anonymous vpn set to true bool");
           return false;
         }
       }
@@ -631,7 +636,7 @@ Acl::eval_anonymous(MMDB_entry_s *entry)
     if ((MMDB_SUCCESS == status) && (entry_data.has_data)) {
       if (entry_data.type == MMDB_DATA_TYPE_BOOLEAN) {
         if (entry_data.boolean == true) {
-          TSDebug(PLUGIN_NAME, "saw is_hosting set to true bool");
+          Dbg(dbg_ctl, "saw is_hosting set to true bool");
           return false;
         }
       }
@@ -643,7 +648,7 @@ Acl::eval_anonymous(MMDB_entry_s *entry)
     if ((MMDB_SUCCESS == status) && (entry_data.has_data)) {
       if (entry_data.type == MMDB_DATA_TYPE_BOOLEAN) {
         if (entry_data.boolean == true) {
-          TSDebug(PLUGIN_NAME, "saw public_proxy set to true bool");
+          Dbg(dbg_ctl, "saw public_proxy set to true bool");
           return false;
         }
       }
@@ -655,7 +660,7 @@ Acl::eval_anonymous(MMDB_entry_s *entry)
     if ((MMDB_SUCCESS == status) && (entry_data.has_data)) {
       if (entry_data.type == MMDB_DATA_TYPE_BOOLEAN) {
         if (entry_data.boolean == true) {
-          TSDebug(PLUGIN_NAME, "saw is_tor_exit_node set to true bool");
+          Dbg(dbg_ctl, "saw is_tor_exit_node set to true bool");
           return false;
         }
       }
@@ -667,7 +672,7 @@ Acl::eval_anonymous(MMDB_entry_s *entry)
     if ((MMDB_SUCCESS == status) && (entry_data.has_data)) {
       if (entry_data.type == MMDB_DATA_TYPE_BOOLEAN) {
         if (entry_data.boolean == true) {
-          TSDebug(PLUGIN_NAME, "saw is_residential set to true bool");
+          Dbg(dbg_ctl, "saw is_residential set to true bool");
           return false;
         }
       }
@@ -692,7 +697,7 @@ Acl::eval_country(MMDB_entry_data_s *entry_data, const std::string &url)
   output = static_cast<char *>(malloc((sizeof(char) * (entry_data->data_size + 1))));
   strncpy(output, entry_data->utf8_string, entry_data->data_size);
   output[entry_data->data_size] = '\0';
-  TSDebug(PLUGIN_NAME, "This IP Country Code: %s", output);
+  Dbg(dbg_ctl, "This IP Country Code: %s", output);
   auto exists = allow_country.count(output);
 
   // If the country exists in our map then set its allow value here
@@ -702,16 +707,16 @@ Acl::eval_country(MMDB_entry_data_s *entry_data, const std::string &url)
   }
 
   if (allow) {
-    TSDebug(PLUGIN_NAME, "Found country code of IP in allow list or allow by default");
+    Dbg(dbg_ctl, "Found country code of IP in allow list or allow by default");
     ret = true;
   }
 
   if (!url.empty()) {
-    TSDebug(PLUGIN_NAME, "saw url not empty: %s, %ld", url.c_str(), url.length());
+    Dbg(dbg_ctl, "saw url not empty: %s, %ld", url.c_str(), url.length());
     if (!allow_regex[output].empty()) {
       for (auto &i : allow_regex[output]) {
         if (PCRE_ERROR_NOMATCH != pcre_exec(i._rex, i._extra, url.c_str(), url.length(), 0, PCRE_NOTEMPTY, nullptr, 0)) {
-          TSDebug(PLUGIN_NAME, "Got a regex allow hit on regex: %s, country: %s", i._regex_s.c_str(), output);
+          Dbg(dbg_ctl, "Got a regex allow hit on regex: %s, country: %s", i._regex_s.c_str(), output);
           ret = true;
         }
       }
@@ -719,7 +724,7 @@ Acl::eval_country(MMDB_entry_data_s *entry_data, const std::string &url)
     if (!deny_regex[output].empty()) {
       for (auto &i : deny_regex[output]) {
         if (PCRE_ERROR_NOMATCH != pcre_exec(i._rex, i._extra, url.c_str(), url.length(), 0, PCRE_NOTEMPTY, nullptr, 0)) {
-          TSDebug(PLUGIN_NAME, "Got a regex deny hit on regex: %s, country: %s", i._regex_s.c_str(), output);
+          Dbg(dbg_ctl, "Got a regex deny hit on regex: %s, country: %s", i._regex_s.c_str(), output);
           ret = false;
         }
       }
@@ -742,9 +747,9 @@ Acl::eval_ip(const sockaddr *sock) const
 #if 0
   for (auto &spot : allow_ip_map) {
     char text[INET6_ADDRSTRLEN];
-    TSDebug(PLUGIN_NAME, "IP: %s", ats_ip_ntop(spot.min(), text, sizeof text));
+    Dbg(dbg_ctl, "IP: %s", ats_ip_ntop(spot.min(), text, sizeof text));
     if (0 != ats_ip_addr_cmp(spot.min(), spot.max())) {
-      TSDebug(PLUGIN_NAME, "stuff: %s", ats_ip_ntop(spot.max(), text, sizeof text));
+      Dbg(dbg_ctl, "stuff: %s", ats_ip_ntop(spot.max(), text, sizeof text));
     }
   }
 #endif
diff --git a/plugins/experimental/maxmind_acl/mmdb.h b/plugins/experimental/maxmind_acl/mmdb.h
index deae30ed164..f2801e30e7e 100644
--- a/plugins/experimental/maxmind_acl/mmdb.h
+++ b/plugins/experimental/maxmind_acl/mmdb.h
@@ -47,6 +47,12 @@
 #define PLUGIN_NAME  "maxmind_acl"
 #define CONFIG_TMOUT 60000
 
+namespace maxmind_acl_ns
+{
+extern DbgCtl dbg_ctl;
+}
+using namespace maxmind_acl_ns;
+
 typedef struct {
   std::string _regex_s;
   pcre *_rex;
diff --git a/plugins/experimental/memory_profile/memory_profile.cc b/plugins/experimental/memory_profile/memory_profile.cc
index 84f91230160..b9c49923a44 100644
--- a/plugins/experimental/memory_profile/memory_profile.cc
+++ b/plugins/experimental/memory_profile/memory_profile.cc
@@ -39,6 +39,11 @@
 
 #define PLUGIN_NAME "memory_profile"
 
+namespace
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 int
 CallbackHandler(TSCont cont, TSEvent id, void *data)
 {
@@ -46,7 +51,7 @@ CallbackHandler(TSCont cont, TSEvent id, void *data)
 
   if (id == TS_EVENT_LIFECYCLE_MSG) {
     TSPluginMsg *msg = static_cast<TSPluginMsg *>(data);
-    TSDebug(PLUGIN_NAME, "Message to '%s' - %zu bytes of data", msg->tag, msg->data_size);
+    Dbg(dbg_ctl, "Message to '%s' - %zu bytes of data", msg->tag, msg->data_size);
     if (strcmp(PLUGIN_NAME, msg->tag) == 0) { // Message is for us
 #if TS_HAS_JEMALLOC
       if (msg->data_size) {
@@ -55,27 +60,27 @@ CallbackHandler(TSCont cont, TSEvent id, void *data)
           if ((retval = mallctl("prof.dump", nullptr, nullptr, nullptr, 0)) != 0) {
             TSError("mallctl(prof.dump) failed retval=%d errno=%d", retval, errno);
           }
-          TSDebug(PLUGIN_NAME, "mallctl(prof.dump) retval=%d errno=%d", retval, errno);
+          Dbg(dbg_ctl, "mallctl(prof.dump) retval=%d errno=%d", retval, errno);
         } else if (strncmp(static_cast<const char *>(msg->data), "activate", msg->data_size) == 0) {
           bool active = true;
 
           if ((retval = mallctl("prof.active", nullptr, nullptr, &active, sizeof(active))) != 0) {
             TSError("mallctl(prof.active) on failed retval=%d errno=%d", retval, errno);
           }
-          TSDebug(PLUGIN_NAME, "mallctl(prof.active) on retval=%d errno=%d", retval, errno);
+          Dbg(dbg_ctl, "mallctl(prof.active) on retval=%d errno=%d", retval, errno);
         } else if (strncmp(static_cast<const char *>(msg->data), "deactivate", msg->data_size) == 0) {
           bool active = false;
 
           if ((retval = mallctl("prof.active", nullptr, nullptr, &active, sizeof(active))) != 0) {
             TSError("mallctl(prof.active) off failed retval=%d errno=%d", retval, errno);
           }
-          TSDebug(PLUGIN_NAME, "mallctl(prof.active) off retval=%d errno=%d", retval, errno);
+          Dbg(dbg_ctl, "mallctl(prof.active) off retval=%d errno=%d", retval, errno);
         } else if (strncmp(static_cast<const char *>(msg->data), "stats", msg->data_size) == 0) {
           malloc_stats_print(nullptr, nullptr, nullptr);
-          TSDebug(PLUGIN_NAME, "stats");
+          Dbg(dbg_ctl, "stats");
         } else {
           TSError("Unexpected msg %*.s", (int)msg->data_size, (char *)msg->data);
-          TSDebug(PLUGIN_NAME, "Unexpected msg %*.s", (int)msg->data_size, (char *)msg->data);
+          Dbg(dbg_ctl, "Unexpected msg %*.s", (int)msg->data_size, (char *)msg->data);
         }
       }
 #else
@@ -108,7 +113,7 @@ TSPluginInit(int argc, const char *argv[])
 
   TSLifecycleHookAdd(TS_LIFECYCLE_MSG_HOOK, cb);
 
-  TSDebug(PLUGIN_NAME, "online");
+  Dbg(dbg_ctl, "online");
 
   return;
 
diff --git a/plugins/experimental/money_trace/money_trace.cc b/plugins/experimental/money_trace/money_trace.cc
index 785fc7d3e81..d05ab900adb 100644
--- a/plugins/experimental/money_trace/money_trace.cc
+++ b/plugins/experimental/money_trace/money_trace.cc
@@ -539,6 +539,11 @@ global_request_header_hook(TSCont const contp, TSEvent const event, void *const
 
 } // namespace
 
+namespace money_trace_ns
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 /**
  * Remap initialization.
  */
diff --git a/plugins/experimental/money_trace/money_trace.h b/plugins/experimental/money_trace/money_trace.h
index f98e7eb2549..9c6f5af47f9 100644
--- a/plugins/experimental/money_trace/money_trace.h
+++ b/plugins/experimental/money_trace/money_trace.h
@@ -24,9 +24,15 @@
 
 #define PLUGIN_NAME "money_trace"
 
-#define LOG_DEBUG(fmt, ...)                                                                  \
-  do {                                                                                       \
-    TSDebug(PLUGIN_NAME, "[%s:%d] %s(): " fmt, __FILE__, __LINE__, __func__, ##__VA_ARGS__); \
+namespace money_trace_ns
+{
+extern DbgCtl dbg_ctl;
+}
+using namespace money_trace_ns;
+
+#define LOG_DEBUG(fmt, ...)                                                          \
+  do {                                                                               \
+    Dbg(dbg_ctl, "[%s:%d] %s(): " fmt, __FILE__, __LINE__, __func__, ##__VA_ARGS__); \
   } while (0)
 
 #define LOG_ERROR(fmt, ...)                                                     \
diff --git a/plugins/experimental/otel_tracer/otel_tracer.cc b/plugins/experimental/otel_tracer/otel_tracer.cc
index 02d2bf00c23..cdfa697676f 100644
--- a/plugins/experimental/otel_tracer/otel_tracer.cc
+++ b/plugins/experimental/otel_tracer/otel_tracer.cc
@@ -45,7 +45,7 @@ close_txn(TSCont contp, TSEvent event, void *edata)
   TSMBuffer buf;
   TSMLoc hdr_loc;
 
-  TSDebug(PLUGIN_NAME, "[%s] Retrieving status code to add to span attributes", __FUNCTION__);
+  Dbg(dbg_ctl, "[%s] Retrieving status code to add to span attributes", __FUNCTION__);
   auto req_data = static_cast<ExtraRequestData *>(TSContDataGet(contp));
 
   TSHttpTxn txnp = static_cast<TSHttpTxn>(edata);
@@ -68,7 +68,7 @@ close_txn(TSCont contp, TSEvent event, void *edata)
   retval = 1;
 
 lReturn:
-  TSDebug(PLUGIN_NAME, "[%s] Cleaning up after close hook handler", __FUNCTION__);
+  Dbg(dbg_ctl, "[%s] Cleaning up after close hook handler", __FUNCTION__);
   req_data->Destruct(req_data);
   delete req_data;
 
@@ -117,7 +117,7 @@ read_request(TSHttpTxn txnp, TSCont contp)
   TSMBuffer buf;
   TSMLoc hdr_loc;
 
-  TSDebug(PLUGIN_NAME, "[%s] Reading information from request", __FUNCTION__);
+  Dbg(dbg_ctl, "[%s] Reading information from request", __FUNCTION__);
   if (TSHttpTxnClientReqGet(txnp, &buf, &hdr_loc) != TS_SUCCESS) {
     TSError("[otel_tracer][%s] cannot retrieve client request", __FUNCTION__);
     TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
@@ -229,7 +229,7 @@ read_request(TSHttpTxn txnp, TSCont contp)
   // TODO: add remote ip, port to attributes
 
   // create parent context
-  TSDebug(PLUGIN_NAME, "[%s] Creating parent context from incoming request headers", __FUNCTION__);
+  Dbg(dbg_ctl, "[%s] Creating parent context from incoming request headers", __FUNCTION__);
   std::map<std::string, std::string> parent_headers;
   if (b3_len != 0) {
     parent_headers[std::string{b3_key}] = b3_str;
@@ -245,7 +245,7 @@ read_request(TSHttpTxn txnp, TSCont contp)
   }
 
   // create trace span and activate
-  TSDebug(PLUGIN_NAME, "[%s] Create span with a name, attributes, parent context and activate it", __FUNCTION__);
+  Dbg(dbg_ctl, "[%s] Create span with a name, attributes, parent context and activate it", __FUNCTION__);
   auto span = get_tracer("ats")->StartSpan(
     get_span_name(path_str), get_span_attributes(method_str, target_str, path_str, host_str, ua_str, port, scheme_str),
     get_span_options(parent_headers));
@@ -254,13 +254,13 @@ read_request(TSHttpTxn txnp, TSCont contp)
 
   std::map<std::string, std::string> trace_headers = get_trace_headers();
   // insert headers to request
-  TSDebug(PLUGIN_NAME, "[%s] Insert trace headers to upstream request", __FUNCTION__);
+  Dbg(dbg_ctl, "[%s] Insert trace headers to upstream request", __FUNCTION__);
   for (auto &p : trace_headers) {
     set_request_header(buf, hdr_loc, p.first.c_str(), p.first.size(), p.second.c_str(), p.second.size());
   }
 
   // pass the span
-  TSDebug(PLUGIN_NAME, "[%s] Add close hook to add status code to span attribute", __FUNCTION__);
+  Dbg(dbg_ctl, "[%s] Add close hook to add status code to span attribute", __FUNCTION__);
   TSCont close_txn_contp = TSContCreate(close_txn, nullptr);
   if (!close_txn_contp) {
     TSError("[otel_tracer][%s] Could not create continuation", __FUNCTION__);
@@ -272,7 +272,7 @@ read_request(TSHttpTxn txnp, TSCont contp)
   }
 
   // clean up
-  TSDebug(PLUGIN_NAME, "[%s] Cleanig up", __FUNCTION__);
+  Dbg(dbg_ctl, "[%s] Cleanig up", __FUNCTION__);
   if (target != nullptr) {
     TSfree(target);
   }
@@ -373,6 +373,6 @@ TSPluginInit(int argc, const char *argv[])
   TSError("[%s] Plugin not initialized", PLUGIN_NAME);
 
 done:
-  TSDebug(PLUGIN_NAME, "Plugin initialized");
+  Dbg(dbg_ctl, "Plugin initialized");
   return;
 }
diff --git a/plugins/experimental/rate_limit/limiter.h b/plugins/experimental/rate_limit/limiter.h
index 9c4f4b0cd08..89e65b74070 100644
--- a/plugins/experimental/rate_limit/limiter.h
+++ b/plugins/experimental/rate_limit/limiter.h
@@ -90,7 +90,7 @@ template <class T> class RateLimiter
     if (_active < limit) {
       ++_active;
       TSMutexUnlock(_active_lock); // Reduce the critical section, release early
-      TSDebug(PLUGIN_NAME, "Reserving a slot, active entities == %u", active());
+      Dbg(dbg_ctl, "Reserving a slot, active entities == %u", active());
       return true;
     } else {
       TSMutexUnlock(_active_lock);
@@ -104,7 +104,7 @@ template <class T> class RateLimiter
     TSMutexLock(_active_lock);
     --_active;
     TSMutexUnlock(_active_lock);
-    TSDebug(PLUGIN_NAME, "Releasing a slot, active entities == %u", active());
+    Dbg(dbg_ctl, "Releasing a slot, active entities == %u", active());
   }
 
   // Current size of the active_in connections
@@ -199,7 +199,7 @@ template <class T> class RateLimiter
       }
 
       if (_metrics[i] != TS_ERROR) {
-        TSDebug(PLUGIN_NAME, "established metric '%s' as ID %d", metric, _metrics[i]);
+        Dbg(dbg_ctl, "established metric '%s' as ID %d", metric, _metrics[i]);
       } else {
         TSError("failed to create metric '%s'", metric);
       }
diff --git a/plugins/experimental/rate_limit/rate_limit.cc b/plugins/experimental/rate_limit/rate_limit.cc
index cb759d77f81..3bee9558984 100644
--- a/plugins/experimental/rate_limit/rate_limit.cc
+++ b/plugins/experimental/rate_limit/rate_limit.cc
@@ -71,7 +71,7 @@ TSPluginInit(int argc, const char *argv[])
       ++argv;
 
       size_t num_sni = gSNISelector->factory(argv[0] + 4, argc, argv);
-      TSDebug(PLUGIN_NAME, "Finished loading %zu SNIs", num_sni);
+      Dbg(dbg_ctl, "Finished loading %zu SNIs", num_sni);
 
       gSNISelector->setupQueueCont(); // Start the queue processing continuation if needed
     } else if (!strncasecmp(argv[1], "HOST=", 5)) {
@@ -94,7 +94,7 @@ TSReturnCode
 TSRemapInit(TSRemapInterface *api_info, char *errbuf, int errbuf_size)
 {
   CHECK_REMAP_API_COMPATIBILITY(api_info, errbuf, errbuf_size);
-  TSDebug(PLUGIN_NAME, "plugin is successfully initialized");
+  Dbg(dbg_ctl, "plugin is successfully initialized");
   return TS_SUCCESS;
 }
 
@@ -121,8 +121,8 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char * /* errbuf ATS_UNUSE
   limiter->initialize(argc, const_cast<const char **>(argv));
   *ih = static_cast<void *>(limiter);
 
-  TSDebug(PLUGIN_NAME, "Added active_in limiter rule (limit=%u, queue=%u, max-age=%ldms, error=%u)", limiter->limit,
-          limiter->max_queue, static_cast<long>(limiter->max_age.count()), limiter->error);
+  Dbg(dbg_ctl, "Added active_in limiter rule (limit=%u, queue=%u, max-age=%ldms, error=%u)", limiter->limit, limiter->max_queue,
+      static_cast<long>(limiter->max_age.count()), limiter->error);
 
   return TS_SUCCESS;
 }
@@ -141,14 +141,14 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo *rri)
         // We are running at limit, and the queue has reached max capacity, give back an error and be done.
         TSHttpTxnStatusSet(txnp, static_cast<TSHttpStatus>(limiter->error));
         limiter->setupTxnCont(txnp, TS_HTTP_SEND_RESPONSE_HDR_HOOK);
-        TSDebug(PLUGIN_NAME, "Rejecting request, we're at capacity and queue is full");
+        Dbg(dbg_ctl, "Rejecting request, we're at capacity and queue is full");
       } else {
         limiter->setupTxnCont(txnp, TS_HTTP_POST_REMAP_HOOK);
-        TSDebug(PLUGIN_NAME, "Adding rate limiting hook, we are at capacity");
+        Dbg(dbg_ctl, "Adding rate limiting hook, we are at capacity");
       }
     } else {
       limiter->setupTxnCont(txnp, TS_HTTP_TXN_CLOSE_HOOK);
-      TSDebug(PLUGIN_NAME, "Adding txn-close hook, we're not at capacity");
+      Dbg(dbg_ctl, "Adding txn-close hook, we're not at capacity");
     }
   }
 
diff --git a/plugins/experimental/rate_limit/sni_limiter.cc b/plugins/experimental/rate_limit/sni_limiter.cc
index 6f0a9e717b6..4dc058c9193 100644
--- a/plugins/experimental/rate_limit/sni_limiter.cc
+++ b/plugins/experimental/rate_limit/sni_limiter.cc
@@ -51,16 +51,16 @@ sni_limit_cont(TSCont contp, TSEvent event, void *edata)
         const sockaddr *sock = TSNetVConnRemoteAddrGet(vc);
         int pressure         = limiter->pressure();
 
-        TSDebug(PLUGIN_NAME, "CLIENT_HELLO on %.*s, pressure=%d", static_cast<int>(sni_name.length()), sni_name.data(), pressure);
+        Dbg(dbg_ctl, "CLIENT_HELLO on %.*s, pressure=%d", static_cast<int>(sni_name.length()), sni_name.data(), pressure);
 
-        // TSDebug(PLUGIN_NAME, "IP Reputation: pressure is currently %d", pressure);
+        // Dbg(dbg_ctl, "IP Reputation: pressure is currently %d", pressure);
 
         if (pressure >= 0) { // When pressure is < 0, we're not yet at a level of pressure to be concerned about
           char client_ip[INET6_ADDRSTRLEN] = "[unknown]";
           auto [bucket, cur_cnt]           = limiter->iprep.increment(sock);
 
           // Get the client IP string if debug is enabled
-          if (TSIsDebugTagSet(PLUGIN_NAME)) {
+          if (dbg_ctl.on()) {
             if (sock->sa_family == AF_INET) {
               inet_ntop(AF_INET, &(((struct sockaddr_in *)sock)->sin_addr), client_ip, INET_ADDRSTRLEN);
             } else if (sock->sa_family == AF_INET6) {
@@ -70,13 +70,13 @@ sni_limit_cont(TSCont contp, TSEvent event, void *edata)
 
           if (cur_cnt > limiter->iprep_permablock_count &&
               bucket <= limiter->iprep_permablock_threshold) { // Mark for long-term blocking
-            TSDebug(PLUGIN_NAME, "Marking IP=%s for perma-blocking", client_ip);
+            Dbg(dbg_ctl, "Marking IP=%s for perma-blocking", client_ip);
             bucket = limiter->iprep.block(sock);
           }
 
           if (static_cast<uint32_t>(pressure) > bucket) { // Remember the perma-block bucket is always 0, and we are >=0 already
             // Block this IP from finishing the handshake
-            TSDebug(PLUGIN_NAME, "Rejecting connection from IP=%s, we're at pressure and IP was chosen to be blocked", client_ip);
+            Dbg(dbg_ctl, "Rejecting connection from IP=%s, we're at pressure and IP was chosen to be blocked", client_ip);
             TSUserArgSet(vc, gVCIdx, nullptr);
             TSVConnReenableEx(vc, TS_EVENT_ERROR);
 
@@ -84,14 +84,14 @@ sni_limit_cont(TSCont contp, TSEvent event, void *edata)
           }
         }
       } else {
-        TSDebug(PLUGIN_NAME, "CLIENT_HELLO on %.*s, no IP reputation", static_cast<int>(sni_name.length()), sni_name.data());
+        Dbg(dbg_ctl, "CLIENT_HELLO on %.*s, no IP reputation", static_cast<int>(sni_name.length()), sni_name.data());
       }
 
       // If we passed the IP reputation filter, continue rate limiting these connections
       if (!limiter->reserve()) {
         if (!limiter->max_queue || limiter->full()) {
           // We are running at limit, and the queue has reached max capacity, give back an error and be done.
-          TSDebug(PLUGIN_NAME, "Rejecting connection, we're at capacity and queue is full");
+          Dbg(dbg_ctl, "Rejecting connection, we're at capacity and queue is full");
           TSUserArgSet(vc, gVCIdx, nullptr);
           limiter->incrementMetric(RATE_LIMITER_METRIC_REJECTED);
           TSVConnReenableEx(vc, TS_EVENT_ERROR);
@@ -100,7 +100,7 @@ sni_limit_cont(TSCont contp, TSEvent event, void *edata)
         } else {
           TSUserArgSet(vc, gVCIdx, reinterpret_cast<void *>(limiter));
           limiter->push(vc, contp);
-          TSDebug(PLUGIN_NAME, "Queueing the VC, we are at capacity");
+          Dbg(dbg_ctl, "Queueing the VC, we are at capacity");
           limiter->incrementMetric(RATE_LIMITER_METRIC_QUEUED);
         }
       } else {
@@ -127,7 +127,7 @@ sni_limit_cont(TSCont contp, TSEvent event, void *edata)
   }
 
   default:
-    TSDebug(PLUGIN_NAME, "Unknown event %d", static_cast<int>(event));
+    Dbg(dbg_ctl, "Unknown event %d", static_cast<int>(event));
     TSError("Unknown event in %s", PLUGIN_NAME);
     break;
   }
@@ -159,7 +159,7 @@ SniRateLimiter::initialize(int argc, const char *argv[])
     {nullptr,                                         no_argument,       nullptr, '\0'},
   };
 
-  TSDebug(PLUGIN_NAME, "Initializing an SNI Rate Limiter");
+  Dbg(dbg_ctl, "Initializing an SNI Rate Limiter");
 
   while (true) {
     int opt = getopt_long(argc, const_cast<char *const *>(argv), "", longopt, nullptr);
@@ -213,11 +213,11 @@ SniRateLimiter::initialize(int argc, const char *argv[])
 
   // Enable and initialize the IP reputation if asked for
   if (this->_iprep_num_buckets > 0 && this->_iprep_size > 0) {
-    TSDebug(PLUGIN_NAME, "Calling and _initialized is %d\n", this->iprep.initialized());
+    Dbg(dbg_ctl, "Calling and _initialized is %d\n", this->iprep.initialized());
     this->iprep.initialize(this->_iprep_num_buckets, this->_iprep_size);
-    TSDebug(PLUGIN_NAME, "IP-reputation enabled with %u buckets, max size is 2^%u", this->_iprep_num_buckets, this->_iprep_size);
+    Dbg(dbg_ctl, "IP-reputation enabled with %u buckets, max size is 2^%u", this->_iprep_num_buckets, this->_iprep_size);
 
-    TSDebug(PLUGIN_NAME, "Called and _initialized is %d\n", this->iprep.initialized());
+    Dbg(dbg_ctl, "Called and _initialized is %d\n", this->iprep.initialized());
 
     // These settings are optional
     if (this->_iprep_max_age != std::chrono::seconds::zero()) {
diff --git a/plugins/experimental/rate_limit/sni_selector.cc b/plugins/experimental/rate_limit/sni_selector.cc
index d87ee8cebd5..bf81a8d87ad 100644
--- a/plugins/experimental/rate_limit/sni_selector.cc
+++ b/plugins/experimental/rate_limit/sni_selector.cc
@@ -39,7 +39,7 @@ sni_queue_cont(TSCont cont, TSEvent event, void *edata)
       std::chrono::milliseconds delay = std::chrono::duration_cast<std::chrono::milliseconds>(now - start_time);
 
       (void)contp; // Ugly, but silences some compilers.
-      TSDebug(PLUGIN_NAME, "SNI=%s: Enabling queued VC after %ldms", key.data(), static_cast<long>(delay.count()));
+      Dbg(dbg_ctl, "SNI=%s: Enabling queued VC after %ldms", key.data(), static_cast<long>(delay.count()));
       TSVConnReenable(vc);
       limiter->incrementMetric(RATE_LIMITER_METRIC_RESUMED);
     }
@@ -54,7 +54,7 @@ sni_queue_cont(TSCont cont, TSEvent event, void *edata)
         std::chrono::milliseconds age = std::chrono::duration_cast<std::chrono::milliseconds>(now - start_time);
 
         (void)contp;
-        TSDebug(PLUGIN_NAME, "Queued VC is too old (%ldms), erroring out", static_cast<long>(age.count()));
+        Dbg(dbg_ctl, "Queued VC is too old (%ldms), erroring out", static_cast<long>(age.count()));
         TSVConnReenableEx(vc, TS_EVENT_ERROR);
         limiter->incrementMetric(RATE_LIMITER_METRIC_EXPIRED);
       }
@@ -72,8 +72,8 @@ SniSelector::insert(std::string_view sni, SniRateLimiter *limiter)
 {
   if (_limiters.find(sni) == _limiters.end()) {
     _limiters[sni] = limiter;
-    TSDebug(PLUGIN_NAME, "Added global limiter for SNI=%s (limit=%u, queue=%u, max_age=%ldms)", sni.data(), limiter->limit,
-            limiter->max_queue, static_cast<long>(limiter->max_age.count()));
+    Dbg(dbg_ctl, "Added global limiter for SNI=%s (limit=%u, queue=%u, max_age=%ldms)", sni.data(), limiter->limit,
+        limiter->max_queue, static_cast<long>(limiter->max_age.count()));
 
     limiter->initializeMetrics(RATE_LIMITER_TYPE_SNI);
 
diff --git a/plugins/experimental/rate_limit/txn_limiter.cc b/plugins/experimental/rate_limit/txn_limiter.cc
index 335b419fa6e..906a1aa5a03 100644
--- a/plugins/experimental/rate_limit/txn_limiter.cc
+++ b/plugins/experimental/rate_limit/txn_limiter.cc
@@ -53,7 +53,7 @@ txn_limit_cont(TSCont cont, TSEvent event, void *edata)
     break;
 
   default:
-    TSDebug(PLUGIN_NAME, "Unknown event %d", static_cast<int>(event));
+    Dbg(dbg_ctl, "Unknown event %d", static_cast<int>(event));
     TSError("Unknown event in %s", PLUGIN_NAME);
     break;
   }
@@ -72,7 +72,7 @@ txn_queue_cont(TSCont cont, TSEvent event, void *edata)
     std::chrono::milliseconds delay = std::chrono::duration_cast<std::chrono::milliseconds>(now - start_time);
 
     delayHeader(txnp, limiter->header, delay);
-    TSDebug(PLUGIN_NAME, "Enabling queued txn after %ldms", static_cast<long>(delay.count()));
+    Dbg(dbg_ctl, "Enabling queued txn after %ldms", static_cast<long>(delay.count()));
     // Since this was a delayed transaction, we need to add the TXN_CLOSE hook to free the slot when done
     TSHttpTxnHookAdd(txnp, TS_HTTP_TXN_CLOSE_HOOK, contp);
     TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
@@ -89,7 +89,7 @@ txn_queue_cont(TSCont cont, TSEvent event, void *edata)
       std::chrono::milliseconds age  = std::chrono::duration_cast<std::chrono::milliseconds>(now - start_time);
 
       delayHeader(txnp, limiter->header, age);
-      TSDebug(PLUGIN_NAME, "Queued TXN is too old (%ldms), erroring out", static_cast<long>(age.count()));
+      Dbg(dbg_ctl, "Queued TXN is too old (%ldms), erroring out", static_cast<long>(age.count()));
       TSHttpTxnStatusSet(txnp, static_cast<TSHttpStatus>(limiter->error));
       TSHttpTxnHookAdd(txnp, TS_HTTP_SEND_RESPONSE_HDR_HOOK, contp);
       TSHttpTxnReenable(txnp, TS_EVENT_HTTP_ERROR);
diff --git a/plugins/experimental/rate_limit/utilities.cc b/plugins/experimental/rate_limit/utilities.cc
index 0838689c048..20ee4ff9b5d 100644
--- a/plugins/experimental/rate_limit/utilities.cc
+++ b/plugins/experimental/rate_limit/utilities.cc
@@ -21,6 +21,11 @@
 #include "ts/remap.h"
 #include "utilities.h"
 
+namespace rate_limit_ns
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // Add a header with the delay imposed on this transaction. This can be used
 // for logging, and other types of metrics.
@@ -36,7 +41,7 @@ delayHeader(TSHttpTxn txnp, std::string &header, std::chrono::milliseconds delay
     if (TS_SUCCESS == TSHttpTxnClientReqGet(txnp, &bufp, &hdr_loc)) {
       if (TS_SUCCESS == TSMimeHdrFieldCreateNamed(bufp, hdr_loc, header.c_str(), header.size(), &field_loc)) {
         if (TS_SUCCESS == TSMimeHdrFieldValueIntSet(bufp, hdr_loc, field_loc, -1, static_cast<int>(delay.count()))) {
-          TSDebug(PLUGIN_NAME, "Added client request header; %s: %d", header.c_str(), static_cast<int>(delay.count()));
+          Dbg(dbg_ctl, "Added client request header; %s: %d", header.c_str(), static_cast<int>(delay.count()));
           TSMimeHdrFieldAppend(bufp, hdr_loc, field_loc);
         }
         TSHandleMLocRelease(bufp, hdr_loc, field_loc);
@@ -61,7 +66,7 @@ retryAfter(TSHttpTxn txnp, unsigned retry)
     if (TS_SUCCESS == TSHttpTxnClientRespGet(txnp, &bufp, &hdr_loc)) {
       if (TS_SUCCESS == TSMimeHdrFieldCreateNamed(bufp, hdr_loc, "Retry-After", 11, &field_loc)) {
         if (TS_SUCCESS == TSMimeHdrFieldValueIntSet(bufp, hdr_loc, field_loc, -1, retry)) {
-          TSDebug(PLUGIN_NAME, "Added a Retry-After: %u", retry);
+          Dbg(dbg_ctl, "Added a Retry-After: %u", retry);
           TSMimeHdrFieldAppend(bufp, hdr_loc, field_loc);
         }
         TSHandleMLocRelease(bufp, hdr_loc, field_loc);
@@ -95,7 +100,7 @@ getDescriptionFromUrl(const char *url)
     const std::string hostname = std::string(h, host_len);
     const std::string scheme   = std::string(s, scheme_len);
 
-    TSDebug(PLUGIN_NAME, "scheme = %s, host = %s, port = %d", scheme.c_str(), hostname.c_str(), port);
+    Dbg(dbg_ctl, "scheme = %s, host = %s, port = %d", scheme.c_str(), hostname.c_str(), port);
 
     description = scheme;
     description.append(".");
diff --git a/plugins/experimental/rate_limit/utilities.h b/plugins/experimental/rate_limit/utilities.h
index e936912e61b..f88b3458e67 100644
--- a/plugins/experimental/rate_limit/utilities.h
+++ b/plugins/experimental/rate_limit/utilities.h
@@ -27,3 +27,9 @@ constexpr char const PLUGIN_NAME[] = "rate_limit";
 void delayHeader(TSHttpTxn txnp, std::string &header, std::chrono::milliseconds delay);
 void retryAfter(TSHttpTxn txnp, unsigned retry);
 std::string getDescriptionFromUrl(const char *url);
+
+namespace rate_limit_ns
+{
+extern DbgCtl dbg_ctl;
+}
+using namespace rate_limit_ns;
diff --git a/plugins/experimental/redo_cache_lookup/redo_cache_lookup.cc b/plugins/experimental/redo_cache_lookup/redo_cache_lookup.cc
index 94ec81b395c..6e917c700a0 100644
--- a/plugins/experimental/redo_cache_lookup/redo_cache_lookup.cc
+++ b/plugins/experimental/redo_cache_lookup/redo_cache_lookup.cc
@@ -39,14 +39,16 @@ using namespace atscppapi;
 namespace
 {
 GlobalPlugin *plugin;
-}
+
+DbgCtl dbg_ctl{PLUGIN_NAME};
+} // namespace
 
 class RedoCacheLookupPlugin : public GlobalPlugin
 {
 public:
   RedoCacheLookupPlugin(const char *fallback) : fallback(fallback)
   {
-    TSDebug(PLUGIN_NAME, "registering transaction hooks");
+    Dbg(dbg_ctl, "registering transaction hooks");
     RedoCacheLookupPlugin::registerHook(HOOK_CACHE_LOOKUP_COMPLETE);
   }
 
@@ -57,7 +59,7 @@ class RedoCacheLookupPlugin : public GlobalPlugin
 
     if (status == Transaction::CacheStatus::CACHE_LOOKUP_NONE || status == Transaction::CacheStatus::CACHE_LOOKUP_SKIPED ||
         status == Transaction::CacheStatus::CACHE_LOOKUP_MISS) {
-      TSDebug(PLUGIN_NAME, "rewinding to check for fallback url: %s", fallback);
+      Dbg(dbg_ctl, "rewinding to check for fallback url: %s", fallback);
       TSHttpTxn txnp = static_cast<TSHttpTxn>(transaction.getAtsHandle());
       TSHttpTxnRedoCacheLookup(txnp, fallback, strlen(fallback));
     }
@@ -72,7 +74,7 @@ class RedoCacheLookupPlugin : public GlobalPlugin
 void
 TSPluginInit(int argc, const char *argv[])
 {
-  TSDebug(PLUGIN_NAME, "Init");
+  Dbg(dbg_ctl, "Init");
   if (!RegisterGlobalPlugin("RedoCacheLookupPlugin", PLUGIN_NAME, "dev@trafficserver.apache.org")) {
     return;
   }
@@ -96,18 +98,18 @@ TSPluginInit(int argc, const char *argv[])
     case '?':
       break;
     default:
-      TSDebug(PLUGIN_NAME, "Unexpected option: %i", opt);
+      Dbg(dbg_ctl, "Unexpected option: %i", opt);
       TSError("[%s] Unexpected options error.", PLUGIN_NAME);
       return;
     }
   }
 
   if (nullptr == fallback) {
-    TSDebug(PLUGIN_NAME, "Missing fallback option.");
+    Dbg(dbg_ctl, "Missing fallback option.");
     TSError("[%s] Missing fallback option", PLUGIN_NAME);
     return;
   }
-  TSDebug(PLUGIN_NAME, "Initialized with fallback: %s", fallback);
+  Dbg(dbg_ctl, "Initialized with fallback: %s", fallback);
 
   plugin = new RedoCacheLookupPlugin(fallback);
 }
diff --git a/plugins/experimental/ssl_session_reuse/src/ats_ssl_plugin.cc b/plugins/experimental/ssl_session_reuse/src/ats_ssl_plugin.cc
index 70fe13bd53b..c7ce00ae327 100644
--- a/plugins/experimental/ssl_session_reuse/src/ats_ssl_plugin.cc
+++ b/plugins/experimental/ssl_session_reuse/src/ats_ssl_plugin.cc
@@ -62,7 +62,7 @@ TSPluginInit(int argc, const char *argv[])
   } else if (!init_ssl_params(argv[1])) {
     init_subscriber();
     TSCont cont = TSContCreate(SSL_session_callback, nullptr);
-    TSDebug(PLUGIN, "TSPluginInit adding TS_SSL_SESSION_HOOK.");
+    Dbg(dbg_ctl, "TSPluginInit adding TS_SSL_SESSION_HOOK.");
     TSHttpHookAdd(TS_SSL_SESSION_HOOK, cont);
   } else {
     TSError("init_ssl_params failed.");
diff --git a/plugins/experimental/ssl_session_reuse/src/common.cc b/plugins/experimental/ssl_session_reuse/src/common.cc
index 33b16dd0db3..29ae8ed7ac4 100644
--- a/plugins/experimental/ssl_session_reuse/src/common.cc
+++ b/plugins/experimental/ssl_session_reuse/src/common.cc
@@ -30,6 +30,11 @@
 
 #include "common.h"
 
+namespace ssl_session_reuse_ns
+{
+DbgCtl dbg_ctl{PLUGIN};
+}
+
 const unsigned char salt[]      = {115, 97, 108, 117, 0, 85, 137, 229};
 const unsigned char hex_chars[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
 
@@ -68,14 +73,14 @@ encrypt_encode64(const unsigned char *key, int key_length, const unsigned char *
 
   // generate key and iv
   if (EVP_BytesToKey(EVP_aes_256_cbc(), EVP_md5(), salt, key, key_length, 1, gen_key, iv) <= 0) {
-    TSDebug(PLUGIN, "Error generating key.");
+    Dbg(dbg_ctl, "Error generating key.");
     ret = -2;
     goto Cleanup;
   }
 
   // Set context AES128 with the generated key and iv
   if (1 != EVP_EncryptInit_ex(context, EVP_aes_256_cbc(), nullptr, gen_key, iv)) {
-    TSDebug(PLUGIN, "EVP_EncryptInit_ex failed.");
+    Dbg(dbg_ctl, "EVP_EncryptInit_ex failed.");
     ret = -3;
     goto Cleanup;
   }
@@ -86,13 +91,13 @@ encrypt_encode64(const unsigned char *key, int key_length, const unsigned char *
   cipher_block_size = EVP_CIPHER_CTX_block_size(context);
   encrypted         = new unsigned char[in_data_len + cipher_block_size * 2];
   if (1 != EVP_EncryptUpdate(context, encrypted, &encrypted_len, in_data, in_data_len)) {
-    TSDebug(PLUGIN, "EVP_EncryptUpdate failed.");
+    Dbg(dbg_ctl, "EVP_EncryptUpdate failed.");
     ret = -4;
     goto Cleanup;
   }
 
   if (1 != EVP_EncryptFinal_ex(context, encrypted + encrypted_len, &encrypted_len_extra)) {
-    TSDebug(PLUGIN, "EVP_EncryptFinal_ex failed.");
+    Dbg(dbg_ctl, "EVP_EncryptFinal_ex failed.");
     ret = -5;
     goto Cleanup;
   }
@@ -102,12 +107,12 @@ encrypt_encode64(const unsigned char *key, int key_length, const unsigned char *
   // the redis command needs to be formatted to a C string.
   if (TSBase64Encode(reinterpret_cast<char *>(encrypted), encrypted_len + encrypted_len_extra, out_data, out_data_size,
                      out_data_len) != 0) {
-    TSDebug(PLUGIN, "Base 64 encoding failed.");
+    Dbg(dbg_ctl, "Base 64 encoding failed.");
     ret = -6;
     goto Cleanup;
   }
 
-  TSDebug(PLUGIN, "Encrypted buffer of size %d to buffer of size %lu.", in_data_len, *out_data_len);
+  Dbg(dbg_ctl, "Encrypted buffer of size %d to buffer of size %lu.", in_data_len, *out_data_len);
   ret = 0;
 
 Cleanup:
@@ -146,20 +151,20 @@ decrypt_decode64(const unsigned char *key, int key_length, const char *in_data,
   // Decode base64
   std::memset(decoded, 0, decoded_size);
   if (TSBase64Decode(in_data, in_data_len, decoded, decoded_size, &decoded_len) != 0) {
-    TSDebug(PLUGIN, "Base 64 decoding failed.");
+    Dbg(dbg_ctl, "Base 64 decoding failed.");
     ret = -2;
     goto Cleanup;
   }
 
   // generate key and iv
   if (EVP_BytesToKey(EVP_aes_256_cbc(), EVP_md5(), salt, key, key_length, 1, gen_key, iv) <= 0) {
-    TSDebug(PLUGIN, "Error generating key.");
+    Dbg(dbg_ctl, "Error generating key.");
     ret = -3;
     goto Cleanup;
   }
   // set context with the generated key and iv
   if (1 != EVP_DecryptInit_ex(context, EVP_aes_256_cbc(), nullptr, gen_key, iv)) {
-    TSDebug(PLUGIN, "EVP_DecryptInit_ex failed.");
+    Dbg(dbg_ctl, "EVP_DecryptInit_ex failed.");
     ret = -4;
     goto Cleanup;
   }
@@ -167,20 +172,20 @@ decrypt_decode64(const unsigned char *key, int key_length, const char *in_data,
   // https://www.openssl.org/docs/manmaster/man3/EVP_DecryptUpdate.html
   // EVP_DecryptUpdate() and EVP_DecryptFinal_ex() have the exact same requirements as their encrypt counterparts.
   if (1 != EVP_DecryptUpdate(context, out_data, &decrypted_len, decoded, decoded_len)) {
-    TSDebug(PLUGIN, "EVP_DecryptUpdate failed.");
+    Dbg(dbg_ctl, "EVP_DecryptUpdate failed.");
     ret = -5;
     goto Cleanup;
   }
 
   if (1 != EVP_DecryptFinal_ex(context, out_data + decrypted_len, &decrypted_len_extra)) {
-    TSDebug(PLUGIN, "EVP_DecryptFinal_ex failed.");
+    Dbg(dbg_ctl, "EVP_DecryptFinal_ex failed.");
     ret = -6;
     goto Cleanup;
   }
 
   *out_data_len = decrypted_len + decrypted_len_extra;
 
-  TSDebug(PLUGIN, "Decrypted buffer of size %d to buffer of size %lu.", in_data_len, *out_data_len);
+  Dbg(dbg_ctl, "Decrypted buffer of size %d to buffer of size %lu.", in_data_len, *out_data_len);
   ret = 0;
 
 Cleanup:
diff --git a/plugins/experimental/ssl_session_reuse/src/common.h b/plugins/experimental/ssl_session_reuse/src/common.h
index 3d78c59ccdf..479cb854922 100644
--- a/plugins/experimental/ssl_session_reuse/src/common.h
+++ b/plugins/experimental/ssl_session_reuse/src/common.h
@@ -33,6 +33,12 @@
 
 #define PLUGIN "ssl_session_reuse"
 
+namespace ssl_session_reuse_ns
+{
+extern DbgCtl dbg_ctl;
+}
+using namespace ssl_session_reuse_ns;
+
 // Base 64 encoding takes 4*(ceil(n/3)) bytes
 #define ENCODED_LEN(len) (((int)ceil(1.34 * (len) + 5)) + 1)
 #define DECODED_LEN(len) (((int)ceil(0.75 * (len))) + 1)
diff --git a/plugins/experimental/ssl_session_reuse/src/config.cc b/plugins/experimental/ssl_session_reuse/src/config.cc
index 7d8c5cd9c88..b2a9814c7b0 100644
--- a/plugins/experimental/ssl_session_reuse/src/config.cc
+++ b/plugins/experimental/ssl_session_reuse/src/config.cc
@@ -76,7 +76,7 @@ Config::loadConfig(const std::string &filename)
       }
       line.ltrim_if(&isspace);
       swoc::TextView field = line.take_prefix_at('=');
-      TSDebug(PLUGIN, "%.*s=%.*s", static_cast<int>(field.size()), field.data(), static_cast<int>(line.size()), line.data());
+      Dbg(dbg_ctl, "%.*s=%.*s", static_cast<int>(field.size()), field.data(), static_cast<int>(line.size()), line.data());
       if (field.size() > 0) {
         m_config[std::string(field.data(), field.size())] = std::string(line.data(), line.size());
       }
diff --git a/plugins/experimental/ssl_session_reuse/src/openssl_utils.cc b/plugins/experimental/ssl_session_reuse/src/openssl_utils.cc
index da301527c9b..9da6d0949ff 100644
--- a/plugins/experimental/ssl_session_reuse/src/openssl_utils.cc
+++ b/plugins/experimental/ssl_session_reuse/src/openssl_utils.cc
@@ -56,7 +56,7 @@ ssl_new_session(TSSslSessionID &sid)
   char session_data[SSL_SESSION_MAX_DER];
   const auto buffer_length = TSSslSessionGetBuffer(&sid, session_data, &session_ret_len);
   if (buffer_length == 0) {
-    TSDebug(PLUGIN, "Failed to find a session buffer.");
+    Dbg(dbg_ctl, "Failed to find a session buffer.");
     return 0;
   } else if (buffer_length > session_ret_len) {
     TSError("Session data is too large. Its size is: %d but our max buffer size is: %d.", buffer_length, SSL_SESSION_MAX_DER);
@@ -72,8 +72,8 @@ ssl_new_session(TSSslSessionID &sid)
 
   ssl_param.pub->publish(redis_channel, encrypted_data);
 
-  TSDebug(PLUGIN, "Create new session id: %s encoded: %s channel: %s", encoded_id.c_str(), encrypted_data.c_str(),
-          redis_channel.c_str());
+  Dbg(dbg_ctl, "Create new session id: %s encoded: %s channel: %s", encoded_id.c_str(), encrypted_data.c_str(),
+      redis_channel.c_str());
 
   return 0;
 }
@@ -91,7 +91,7 @@ ssl_del_session(TSSslSessionID &sid)
 
   int ret = encode_id(sid.bytes, sid.len, encoded_id);
   if (!ret) {
-    TSDebug(PLUGIN, "Session is deleted. id: %s", encoded_id.c_str());
+    Dbg(dbg_ctl, "Session is deleted. id: %s", encoded_id.c_str());
   }
 
   return 0;
@@ -100,7 +100,7 @@ ssl_del_session(TSSslSessionID &sid)
 int
 SSL_session_callback(TSCont contp, TSEvent event, void *edata)
 {
-  TSDebug(PLUGIN, "SSL_session_callback event: %d", event);
+  Dbg(dbg_ctl, "SSL_session_callback event: %d", event);
   TSSslSessionID *sessionid = reinterpret_cast<TSSslSessionID *>(edata);
 
   switch (event) {
diff --git a/plugins/experimental/ssl_session_reuse/src/publish.cc b/plugins/experimental/ssl_session_reuse/src/publish.cc
index d5acd4b92a8..ca3a9ced7cc 100644
--- a/plugins/experimental/ssl_session_reuse/src/publish.cc
+++ b/plugins/experimental/ssl_session_reuse/src/publish.cc
@@ -88,18 +88,18 @@ RedisPublisher::RedisPublisher(const std::string &conf)
 
   addto_endpoint_vector(m_redisEndpoints, m_redisEndpointsStr);
 
-  TSDebug(PLUGIN, "RedisPublisher::RedisPublisher: NumWorkers: %d RedisConnectTimeout: %d", m_numWorkers, m_redisConnectTimeout);
-  TSDebug(PLUGIN,
-          "RedisPublisher::RedisPublisher: RedisPublishTries: %d RedisConnectTries: %d RedisRetryDelay: %d MaxQueuedMessages: %d",
-          m_redisPublishTries, m_redisConnectTries, m_redisRetryDelay, m_maxQueuedMessages);
+  Dbg(dbg_ctl, "RedisPublisher::RedisPublisher: NumWorkers: %d RedisConnectTimeout: %d", m_numWorkers, m_redisConnectTimeout);
+  Dbg(dbg_ctl,
+      "RedisPublisher::RedisPublisher: RedisPublishTries: %d RedisConnectTries: %d RedisRetryDelay: %d MaxQueuedMessages: %d",
+      m_redisPublishTries, m_redisConnectTries, m_redisRetryDelay, m_maxQueuedMessages);
 
-  TSDebug(PLUGIN, "RedisPublisher::RedisPublisher: Redis Publish endpoints are as follows:");
+  Dbg(dbg_ctl, "RedisPublisher::RedisPublisher: Redis Publish endpoints are as follows:");
   for (auto &m_redisEndpoint : m_redisEndpoints) {
     simple_pool *pool = simple_pool::create(m_redisEndpoint.m_hostname, m_redisEndpoint.m_port, m_poolRedisConnectTimeout);
     pools.push_back(pool);
   }
 
-  TSDebug(PLUGIN, "RedisPublisher::RedisPublisher: PoolRedisConnectTimeout: %d", m_poolRedisConnectTimeout);
+  Dbg(dbg_ctl, "RedisPublisher::RedisPublisher: PoolRedisConnectTimeout: %d", m_poolRedisConnectTimeout);
 
   ::sem_init(&m_workerSem, 0, 0);
 
@@ -125,9 +125,9 @@ ::redisContext *
 RedisPublisher::setup_connection(const RedisEndpoint &re)
 {
   uint64_t my_id = 0;
-  if (TSIsDebugTagSet(PLUGIN)) {
+  if (dbg_ctl.on()) {
     my_id = static_cast<uint64_t>(pthread_self());
-    TSDebug(PLUGIN, "RedisPublisher::setup_connection: Called by threadId: %" PRIx64, my_id);
+    Dbg(dbg_ctl, "RedisPublisher::setup_connection: Called by threadId: %" PRIx64, my_id);
   }
 
   RedisContextPtr my_context;
@@ -145,8 +145,7 @@ RedisPublisher::setup_connection(const RedisEndpoint &re)
               re.m_hostname.c_str(), re.m_port, i + 1, my_id);
       my_context.reset(nullptr);
     } else {
-      TSDebug(PLUGIN, "RedisPublisher::setup_connection: threadId: %" PRIx64 " Successfully connected to the redis instance.",
-              my_id);
+      Dbg(dbg_ctl, "RedisPublisher::setup_connection: threadId: %" PRIx64 " Successfully connected to the redis instance.", my_id);
 
       redisReply *reply = static_cast<redisReply *>(redisCommand(my_context.get(), "AUTH %s", redis_passwd.c_str()));
 
@@ -158,7 +157,7 @@ RedisPublisher::setup_connection(const RedisEndpoint &re)
         freeReplyObject(reply);
         my_context.reset(nullptr);
       } else {
-        TSDebug(PLUGIN, "RedisPublisher::setup_connection: Successfully AUTH redis server.");
+        Dbg(dbg_ctl, "RedisPublisher::setup_connection: Successfully AUTH redis server.");
         freeReplyObject(reply);
       }
       break;
@@ -175,9 +174,9 @@ ::redisReply *
 RedisPublisher::send_publish(RedisContextPtr &ctx, const RedisEndpoint &re, const Message &msg)
 {
   uint64_t my_id = 0;
-  if (TSIsDebugTagSet(PLUGIN)) {
+  if (dbg_ctl.on()) {
     my_id = static_cast<uint64_t>(pthread_self());
-    TSDebug(PLUGIN, "RedisPublisher::send_publish: Called by threadId: %" PRIx64, my_id);
+    Dbg(dbg_ctl, "RedisPublisher::send_publish: Called by threadId: %" PRIx64, my_id);
   }
 
   ::redisReply *current_reply(nullptr);
@@ -267,9 +266,9 @@ RedisPublisher::runWorker()
       ::sem_wait(&m_workerSem);
 
       if (current_message.cleanup) {
-        if (TSIsDebugTagSet(PLUGIN)) {
+        if (dbg_ctl.on()) {
           auto my_id = static_cast<uint64_t>(pthread_self());
-          TSDebug(PLUGIN, "RedisPublisher::runWorker: threadId: %" PRIx64 " received the cleanup message. Exiting!", my_id);
+          Dbg(dbg_ctl, "RedisPublisher::runWorker: threadId: %" PRIx64 " received the cleanup message. Exiting!", my_id);
         }
         break;
       }
@@ -297,7 +296,7 @@ RedisPublisher::runWorker()
       clear_reply(current_reply);
       current_reply = nullptr;
     } catch (...) {
-      TSDebug(PLUGIN, "RedisPublisher::runWorker exception");
+      Dbg(dbg_ctl, "RedisPublisher::runWorker exception");
       break;
     }
   }
@@ -310,8 +309,8 @@ RedisPublisher::runWorker()
 int
 RedisPublisher::publish(const std::string &channel, const std::string &data)
 {
-  TSDebug(PLUGIN, "RedisPublisher::publish: Publish request for channel: %s and message: \"%s\" received.", channel.c_str(),
-          hex_str(data).c_str());
+  Dbg(dbg_ctl, "RedisPublisher::publish: Publish request for channel: %s and message: \"%s\" received.", channel.c_str(),
+      hex_str(data).c_str());
 
   m_messageQueueMutex.lock();
 
@@ -334,7 +333,7 @@ RedisPublisher::publish(const std::string &channel, const std::string &data)
 int
 RedisPublisher::signal_cleanup()
 {
-  TSDebug(PLUGIN, "RedisPublisher::signal_cleanup: Called.");
+  Dbg(dbg_ctl, "RedisPublisher::signal_cleanup: Called.");
   Message cleanup_message("", "", true);
 
   m_messageQueueMutex.lock();
@@ -352,7 +351,7 @@ RedisPublisher::signal_cleanup()
 
 RedisPublisher::~RedisPublisher()
 {
-  TSDebug(PLUGIN, "RedisPublisher::~RedisPublisher: Called.");
+  Dbg(dbg_ctl, "RedisPublisher::~RedisPublisher: Called.");
   RedisPublisher::signal_cleanup();
 
   ::sem_destroy(&m_workerSem);
@@ -361,22 +360,22 @@ RedisPublisher::~RedisPublisher()
 std::string
 RedisPublisher::get_session(const std::string &channel)
 {
-  if (TSIsDebugTagSet(PLUGIN)) {
+  if (dbg_ctl.on()) {
     auto my_id = static_cast<uint64_t>(pthread_self());
-    TSDebug(PLUGIN, "RedisPublisher::get_session: Called by threadId: %" PRIx64, my_id);
+    Dbg(dbg_ctl, "RedisPublisher::get_session: Called by threadId: %" PRIx64, my_id);
   }
 
   std::string ret;
   uint32_t index    = get_hash_index(channel);
   redisReply *reply = nullptr;
-  TSDebug(PLUGIN, "RedisPublisher::get_session: Start to try to get session.");
+  Dbg(dbg_ctl, "RedisPublisher::get_session: Start to try to get session.");
   for (uint32_t i = 0; i < m_redisEndpoints.size(); i++) {
     connection *conn = pools[index]->get();
 
     if (conn) {
       reply = static_cast<redisReply *>(redisCommand(conn->c_ptr(), "GET %s", channel.c_str()));
       if (reply && reply->type == REDIS_REPLY_STRING) {
-        TSDebug(PLUGIN, "RedisPublisher::get_session: Success to GET a value from redis server index: %d", index);
+        Dbg(dbg_ctl, "RedisPublisher::get_session: Success to GET a value from redis server index: %d", index);
         pools[index]->put(conn);
         ret = reply->str;
         clear_reply(reply);
@@ -387,7 +386,7 @@ RedisPublisher::get_session(const std::string &channel)
     }
     TSError("RedisPublisher::get_session: Fail to GET a value from this redis server index: %d", index);
     index = get_next_index(index);
-    TSDebug(PLUGIN, "RedisPublisher::get_session: Will try the next redis server: %d", index);
+    Dbg(dbg_ctl, "RedisPublisher::get_session: Will try the next redis server: %d", index);
   }
 
   TSError("RedisPublisher::get_session: Fail to GET a value from all redis servers!");
@@ -397,9 +396,9 @@ RedisPublisher::get_session(const std::string &channel)
 redisReply *
 RedisPublisher::set_session(const Message &msg)
 {
-  if (TSIsDebugTagSet(PLUGIN)) {
+  if (dbg_ctl.on()) {
     auto my_id = static_cast<uint64_t>(pthread_self());
-    TSDebug(PLUGIN, "RedisPublisher::set_session: Called by threadId: %" PRIx64, my_id);
+    Dbg(dbg_ctl, "RedisPublisher::set_session: Called by threadId: %" PRIx64, my_id);
   }
 
   uint32_t index    = get_hash_index(msg.channel);
@@ -410,8 +409,8 @@ RedisPublisher::set_session(const Message &msg)
     if (conn) {
       reply = static_cast<redisReply *>(redisCommand(conn->c_ptr(), "SET %s %s", msg.channel.c_str(), msg.data.c_str()));
       if (reply && reply->type == REDIS_REPLY_STATUS && strcasecmp(reply->str, "OK") == 0) {
-        TSDebug(PLUGIN, "RedisPublisher::set_session: Success to SET a value to redis server: %s:%d",
-                m_redisEndpoints[index].m_hostname.c_str(), m_redisEndpoints[index].m_port);
+        Dbg(dbg_ctl, "RedisPublisher::set_session: Success to SET a value to redis server: %s:%d",
+            m_redisEndpoints[index].m_hostname.c_str(), m_redisEndpoints[index].m_port);
         pools[index]->put(conn);
         return reply;
       }
@@ -422,8 +421,8 @@ RedisPublisher::set_session(const Message &msg)
             m_redisEndpoints[index].m_hostname.c_str(), m_redisEndpoints[index].m_port);
 
     index = get_next_index(index);
-    TSDebug(PLUGIN, "RedisPublisher::set_session: Will try the next redis server: %s:%d",
-            m_redisEndpoints[index].m_hostname.c_str(), m_redisEndpoints[index].m_port);
+    Dbg(dbg_ctl, "RedisPublisher::set_session: Will try the next redis server: %s:%d", m_redisEndpoints[index].m_hostname.c_str(),
+        m_redisEndpoints[index].m_port);
   }
 
   TSError("RedisPublisher::set_session: Fail to SET a value to all redis servers!");
diff --git a/plugins/experimental/ssl_session_reuse/src/session_process.cc b/plugins/experimental/ssl_session_reuse/src/session_process.cc
index 38886241a84..f249c45bd5e 100644
--- a/plugins/experimental/ssl_session_reuse/src/session_process.cc
+++ b/plugins/experimental/ssl_session_reuse/src/session_process.cc
@@ -66,7 +66,7 @@ encrypt_session(const char *session_data, int32_t session_data_len, const unsign
   if (ret == 0) {
     encrypted_data.assign(encrypted, encrypted_len);
   } else {
-    TSDebug(PLUGIN, "encrypt_session calling encrypt_encode64 failed, error: %d", ret);
+    Dbg(dbg_ctl, "encrypt_session calling encrypt_encode64 failed, error: %d", ret);
   }
 
   delete[] data;
@@ -99,7 +99,7 @@ decrypt_session(const std::string &encrypted_data, const unsigned char *key, int
   std::memset(decrypted, 0, decrypted_size);
   if ((ret = decrypt_decode64(key, key_length, encrypted_data.c_str(), encrypted_data.length(), decrypted, decrypted_size,
                               &decrypted_len)) != 0) {
-    TSDebug(PLUGIN, "decrypt_session calling decrypt_decode64 failed, error: %d", ret);
+    Dbg(dbg_ctl, "decrypt_session calling decrypt_decode64 failed, error: %d", ret);
     goto Cleanup;
   }
 
@@ -117,7 +117,7 @@ decrypt_session(const std::string &encrypted_data, const unsigned char *key, int
 
     len_all = ret + sizeof(int64_t) + sizeof(int32_t);
     if (decrypted_len < len_all) {
-      TSDebug(PLUGIN, "Session data length mismatch, got %lu, should be %lu.", decrypted_len, len_all);
+      Dbg(dbg_ctl, "Session data length mismatch, got %lu, should be %lu.", decrypted_len, len_all);
       ret = -1;
       goto Cleanup;
     }
@@ -177,18 +177,18 @@ int
 add_session(char *session_id, int session_id_len, const std::string &encrypted_session)
 {
   std::string session(session_id, session_id_len);
-  TSDebug(PLUGIN, "add_session session_id: %s", hex_str(session).c_str());
+  Dbg(dbg_ctl, "add_session session_id: %s", hex_str(session).c_str());
   char session_data[SSL_SESSION_MAX_DER];
   int32_t session_data_len = SSL_SESSION_MAX_DER;
   int ret = decrypt_session(encrypted_session, (unsigned char *)get_key_ptr(), get_key_length(), session_data, session_data_len);
   if (ret < 0) {
-    TSDebug(PLUGIN, "Failed to decrypt session %.*s, error: %d", session_id_len, hex_str(session).c_str(), ret);
+    Dbg(dbg_ctl, "Failed to decrypt session %.*s, error: %d", session_id_len, hex_str(session).c_str(), ret);
     return ret;
   }
   const unsigned char *loc = reinterpret_cast<const unsigned char *>(session_data);
   SSL_SESSION *sess        = d2i_SSL_SESSION(nullptr, &loc, session_data_len);
   if (nullptr == sess) {
-    TSDebug(PLUGIN, "Failed to transform session buffer %.*s", session_id_len, hex_str(session).c_str());
+    Dbg(dbg_ctl, "Failed to transform session buffer %.*s", session_id_len, hex_str(session).c_str());
     return -1;
   }
   TSSslSessionID sid;
diff --git a/plugins/experimental/ssl_session_reuse/src/ssl_init.cc b/plugins/experimental/ssl_session_reuse/src/ssl_init.cc
index afc88fffeb0..961a017cfbc 100644
--- a/plugins/experimental/ssl_session_reuse/src/ssl_init.cc
+++ b/plugins/experimental/ssl_session_reuse/src/ssl_init.cc
@@ -61,14 +61,13 @@ init_ssl_params(const std::string &conf)
 
   if (ssl_param.key_update_interval > STEK_MAX_LIFETIME) {
     ssl_param.key_update_interval = STEK_MAX_LIFETIME;
-    TSDebug(PLUGIN, "KeyUpdateInterval too high, resetting session ticket key rotation to %d seconds.",
-            ssl_param.key_update_interval);
+    Dbg(dbg_ctl, "KeyUpdateInterval too high, resetting session ticket key rotation to %d seconds.", ssl_param.key_update_interval);
   }
 
-  TSDebug(PLUGIN, "init_ssl_params: I %s been configured to initially be stek_master.",
-          ((ssl_param.stek_master) ? "HAVE" : "HAVE NOT"));
-  TSDebug(PLUGIN, "init_ssl_params: Rotation interval (ssl_param.key_update_interval) set to %d", ssl_param.key_update_interval);
-  TSDebug(PLUGIN, "init_ssl_params: cluster_name set to %s", ssl_param.cluster_name.c_str());
+  Dbg(dbg_ctl, "init_ssl_params: I %s been configured to initially be stek_master.",
+      ((ssl_param.stek_master) ? "HAVE" : "HAVE NOT"));
+  Dbg(dbg_ctl, "init_ssl_params: Rotation interval (ssl_param.key_update_interval) set to %d", ssl_param.key_update_interval);
+  Dbg(dbg_ctl, "init_ssl_params: cluster_name set to %s", ssl_param.cluster_name.c_str());
 
   ssl_param.pub = new RedisPublisher(conf);
   if ((!ssl_param.pub) || (!ssl_param.pub->is_good())) {
diff --git a/plugins/experimental/ssl_session_reuse/src/ssl_key_utils.cc b/plugins/experimental/ssl_session_reuse/src/ssl_key_utils.cc
index f413a27eecb..28ad22c697b 100644
--- a/plugins/experimental/ssl_session_reuse/src/ssl_key_utils.cc
+++ b/plugins/experimental/ssl_session_reuse/src/ssl_key_utils.cc
@@ -171,7 +171,7 @@ STEK_encrypt(struct ssl_ticket_key_t *stek, const char *key, int key_length, cha
                               stek_len, ret_encrypted, encrypted_size, &encrypted_len)) == 0) {
     *ret_len = encrypted_len;
   } else {
-    TSDebug(PLUGIN, "STEK_encrypt calling encrypt_encode64 failed, error: %d", ret);
+    Dbg(dbg_ctl, "STEK_encrypt calling encrypt_encode64 failed, error: %d", ret);
   }
   return ret;
 }
@@ -183,7 +183,7 @@ STEK_decrypt(const std::string &encrypted_data, const char *key, int key_length,
     return -1;
   }
 
-  TSDebug(PLUGIN, "STEK_decrypt: requested to decrypt %lu bytes", encrypted_data.length());
+  Dbg(dbg_ctl, "STEK_decrypt: requested to decrypt %lu bytes", encrypted_data.length());
 
   int ret                  = -1;
   size_t decrypted_size    = DECODED_LEN(encrypted_data.length()) + EVP_MAX_BLOCK_LENGTH * 2;
@@ -193,7 +193,7 @@ STEK_decrypt(const std::string &encrypted_data, const char *key, int key_length,
   std::memset(decrypted, 0, decrypted_size);
   if ((ret = decrypt_decode64(reinterpret_cast<const unsigned char *>(key), key_length, encrypted_data.c_str(),
                               encrypted_data.length(), decrypted, decrypted_size, &decrypted_len)) != 0) {
-    TSDebug(PLUGIN, "STEK_decrypt calling decrypt_decode64 failed, error: %d", ret);
+    Dbg(dbg_ctl, "STEK_decrypt calling decrypt_decode64 failed, error: %d", ret);
     goto Cleanup;
   }
 
@@ -262,12 +262,12 @@ STEK_Update_Setter_Thread(void *arg)
 
   if (stek_master_setter_running) {
     /* Sanity check triggered.  Already running...don't do another. */
-    TSDebug(PLUGIN, "Faulty STEK-master launch. Internal error. Moving on...");
+    Dbg(dbg_ctl, "Faulty STEK-master launch. Internal error. Moving on...");
     return nullptr;
   }
 
   stek_master_setter_running = true;
-  TSDebug(PLUGIN, "Will now act as the STEK rotator for POD.");
+  Dbg(dbg_ctl, "Will now act as the STEK rotator for POD.");
 
   while (!plugin_threads.shutdown) {
     try {
@@ -281,7 +281,7 @@ STEK_Update_Setter_Thread(void *arg)
       } else {
         //  Everything good. will sleep for normal rotation time period and then repeat
         startProblem = 0;
-        TSDebug(PLUGIN, "New POD STEK created and sent to network.");
+        Dbg(dbg_ctl, "New POD STEK created and sent to network.");
 
         sleepInterval = ssl_param.key_update_interval;
       }
@@ -301,13 +301,13 @@ STEK_Update_Setter_Thread(void *arg)
         goto done_master_setter;
       }
     } catch (...) {
-      TSDebug(PLUGIN, "STEK_Update_Setter_Thread exception");
+      Dbg(dbg_ctl, "STEK_Update_Setter_Thread exception");
       goto done_master_setter;
     }
   } // while(forever)
 
 done_master_setter:
-  TSDebug(PLUGIN, "Yielding STEK-Master rotation responsibility to another node in POD.");
+  Dbg(dbg_ctl, "Yielding STEK-Master rotation responsibility to another node in POD.");
   memset(&newKey, 0, sizeof(struct ssl_ticket_key_t));
   stek_master_setter_running = false;
   return nullptr;
@@ -351,7 +351,7 @@ STEK_Update_Checker_Thread(void *arg)
    * that something is up with our STEK master, and nominate a new STEK master.
    */
 
-  TSDebug(PLUGIN, "Starting STEK_Update_Checker_Thread.");
+  Dbg(dbg_ctl, "Starting STEK_Update_Checker_Thread.");
 
   lastChangeTime = lastWarningTime = time(&currentTime); // init to current to suppress a startup warning.
   int check_count                  = 0;                  // Keep track of how many times we've checked whether we got a new STEK.
@@ -362,7 +362,7 @@ STEK_Update_Checker_Thread(void *arg)
         // Launch a request for the master to resend you the ticket key
         std::string redis_channel = ssl_param.cluster_name + "." + STEK_ID_RESEND;
         ssl_param.pub->publish(redis_channel, ""); // send it
-        TSDebug(PLUGIN, "Request for ticket.");
+        Dbg(dbg_ctl, "Request for ticket.");
       }
       time(&currentTime);
       time_t sleepUntil;
@@ -402,12 +402,12 @@ STEK_Update_Checker_Thread(void *arg)
 
         /* Time to nominate a new stek master for pod key rotation... */
         if (!stek_master_setter_running) {
-          TSDebug(PLUGIN, "Will nominate a new STEK-master thread now for pod key rotation.");
+          Dbg(dbg_ctl, "Will nominate a new STEK-master thread now for pod key rotation.");
           TSThreadCreate(STEK_Update_Setter_Thread, nullptr);
         }
       }
     } catch (...) {
-      TSDebug(PLUGIN, "STEK_Update_Checker_Thread exception");
+      Dbg(dbg_ctl, "STEK_Update_Checker_Thread exception");
       break;
     }
   } // while(forever)
diff --git a/plugins/experimental/ssl_session_reuse/src/subscriber.cc b/plugins/experimental/ssl_session_reuse/src/subscriber.cc
index c21cf0fa85d..9dcf3f9ca42 100644
--- a/plugins/experimental/ssl_session_reuse/src/subscriber.cc
+++ b/plugins/experimental/ssl_session_reuse/src/subscriber.cc
@@ -76,8 +76,8 @@ RedisSubscriber::RedisSubscriber(const std::string &conf)
 
   m_channel_prefix = m_channel.substr(0, m_channel.find('*'));
 
-  TSDebug(PLUGIN, "RedisSubscriber::RedisSubscriber: SubscriberChannel: %s SubscriberChannelPrefix: %s", m_channel.c_str(),
-          m_channel_prefix.c_str());
+  Dbg(dbg_ctl, "RedisSubscriber::RedisSubscriber: SubscriberChannel: %s SubscriberChannelPrefix: %s", m_channel.c_str(),
+      m_channel_prefix.c_str());
 
   addto_endpoint_vector(m_redisEndpoints, redisEndpointsStr);
   m_redisEndpointsIndex = 0;
@@ -102,8 +102,8 @@ RedisSubscriber::get_endpoint_index()
 ::redisContext *
 RedisSubscriber::setup_connection(int index)
 {
-  TSDebug(PLUGIN, "RedisSubscriber::setup_connection: Called for host: %s port: %d", m_redisEndpoints[index].m_hostname.c_str(),
-          m_redisEndpoints[index].m_port);
+  Dbg(dbg_ctl, "RedisSubscriber::setup_connection: Called for host: %s port: %d", m_redisEndpoints[index].m_hostname.c_str(),
+      m_redisEndpoints[index].m_port);
 
   ::redisContext *my_context(nullptr);
   struct ::timeval timeout_connect;
@@ -120,8 +120,8 @@ RedisSubscriber::setup_connection(int index)
       TSError("RedisSubscriber::setup_connection: Connect to host: %s port: %d failed.", m_redisEndpoints[index].m_hostname.c_str(),
               m_redisEndpoints[index].m_port);
     } else {
-      TSDebug(PLUGIN, "RedisSubscriber::setup_connection: Successfully connected to the redis host: %s port: %d",
-              m_redisEndpoints[index].m_hostname.c_str(), m_redisEndpoints[index].m_port);
+      Dbg(dbg_ctl, "RedisSubscriber::setup_connection: Successfully connected to the redis host: %s port: %d",
+          m_redisEndpoints[index].m_hostname.c_str(), m_redisEndpoints[index].m_port);
 
       redisReply *reply = static_cast<redisReply *>(redisCommand(my_context, "AUTH %s", redis_passwd.c_str()));
 
@@ -131,7 +131,7 @@ RedisSubscriber::setup_connection(int index)
         TSError("RedisSubscriber::setup_connection: Cannot AUTH redis server, error reply.");
         freeReplyObject(reply);
       } else {
-        TSDebug(PLUGIN, "RedisSubscriber::setup_connection: Successfully AUTH redis server.");
+        Dbg(dbg_ctl, "RedisSubscriber::setup_connection: Successfully AUTH redis server.");
         freeReplyObject(reply);
       }
 
@@ -149,7 +149,7 @@ RedisSubscriber::setup_connection(int index)
 void
 RedisSubscriber::run()
 {
-  TSDebug(PLUGIN, "RedisSubscriber::run: Called.");
+  Dbg(dbg_ctl, "RedisSubscriber::run: Called.");
   int my_endpoint_index = get_endpoint_index();
   ::redisContext *my_context(setup_connection(my_endpoint_index));
   ::redisReply *current_reply(nullptr);
@@ -161,7 +161,7 @@ RedisSubscriber::run()
         my_context = setup_connection(my_endpoint_index);
       }
 
-      TSDebug(PLUGIN, "RedisSubscriber::run: Issuing command: PSUBSCRIBE %s", m_channel.c_str());
+      Dbg(dbg_ctl, "RedisSubscriber::run: Issuing command: PSUBSCRIBE %s", m_channel.c_str());
       current_reply = static_cast<redisReply *>(::redisCommand(my_context, "PSUBSCRIBE %s", m_channel.c_str()));
 
       if (!current_reply || (REDIS_REPLY_ERROR == current_reply->type)) {
@@ -169,8 +169,8 @@ RedisSubscriber::run()
         ::usleep(1000 * 1000);
         continue;
       } else {
-        TSDebug(PLUGIN, "RedisSubscriber::run: Successfully subscribed to channel: %s", m_channel.c_str());
-        TSDebug(PLUGIN, "RedisSubscriber::run: Waiting for messages to appear on the channel!");
+        Dbg(dbg_ctl, "RedisSubscriber::run: Successfully subscribed to channel: %s", m_channel.c_str());
+        Dbg(dbg_ctl, "RedisSubscriber::run: Waiting for messages to appear on the channel!");
         ::freeReplyObject(current_reply);
       }
 
@@ -179,7 +179,7 @@ RedisSubscriber::run()
         // Process Message
         std::string channel(current_reply->element[2]->str, current_reply->element[2]->len);
         std::string data(current_reply->element[3]->str, current_reply->element[3]->len);
-        TSDebug(PLUGIN, "RedisSubscriber::run: Redis request channel: %s message: %s", channel.c_str(), hex_str(data).c_str());
+        Dbg(dbg_ctl, "RedisSubscriber::run: Redis request channel: %s message: %s", channel.c_str(), hex_str(data).c_str());
 
         std::string key = "";
         // Strip the channel name to get the key
@@ -193,27 +193,27 @@ RedisSubscriber::run()
           // Requesting last ticket to be resent
         } else if (strncmp(key.c_str(), STEK_ID_RESEND, strlen(STEK_ID_RESEND)) == 0) {
           if (isSTEKMaster()) {
-            TSDebug(PLUGIN, "RedisSubscriber::run: Resend ticket.");
+            Dbg(dbg_ctl, "RedisSubscriber::run: Resend ticket.");
             STEK_Send_To_Network(ssl_param.ticket_keys);
           }
         } else { // Otherwise this is a new session.  Let ATS core know about it
           char session_id[SSL_MAX_SSL_SESSION_ID_LENGTH * 2];
           int session_id_len = sizeof(session_id);
           if (decode_id(key, session_id, session_id_len) == 0) { // Decrypt the data
-            TSDebug(PLUGIN, "RedisSubscriber::run: Add session encoded_id: %s decoded_id: %.*s %d", key.c_str(), session_id_len,
-                    hex_str(std::string(session_id, session_id_len)).c_str(), session_id_len);
+            Dbg(dbg_ctl, "RedisSubscriber::run: Add session encoded_id: %s decoded_id: %.*s %d", key.c_str(), session_id_len,
+                hex_str(std::string(session_id, session_id_len)).c_str(), session_id_len);
             add_session(session_id, session_id_len, data);
           } else {
-            TSDebug(PLUGIN, "RedisSubscriber::run: Failed to decode key: %s", key.c_str());
+            Dbg(dbg_ctl, "RedisSubscriber::run: Failed to decode key: %s", key.c_str());
           }
         }
 
         ::freeReplyObject(current_reply);
 
-        TSDebug(PLUGIN, "RedisSubscriber::run: Got message: %s channel: %s", hex_str(data).c_str(), channel.c_str());
+        Dbg(dbg_ctl, "RedisSubscriber::run: Got message: %s channel: %s", hex_str(data).c_str(), channel.c_str());
       }
     } catch (...) {
-      TSDebug(PLUGIN, "RedisSubscriber::run exception");
+      Dbg(dbg_ctl, "RedisSubscriber::run exception");
       break;
     }
   }
@@ -221,5 +221,5 @@ RedisSubscriber::run()
 
 RedisSubscriber::~RedisSubscriber()
 {
-  TSDebug(PLUGIN, "RedisSubscriber::~RedisSubscriber: Called for endpoint.");
+  Dbg(dbg_ctl, "RedisSubscriber::~RedisSubscriber: Called for endpoint.");
 }
diff --git a/plugins/experimental/sslheaders/sslheaders.cc b/plugins/experimental/sslheaders/sslheaders.cc
index 994b81e34ff..0b2c07c2138 100644
--- a/plugins/experimental/sslheaders/sslheaders.cc
+++ b/plugins/experimental/sslheaders/sslheaders.cc
@@ -23,6 +23,11 @@
 #include <openssl/ssl.h>
 #include <openssl/x509.h>
 
+namespace sslheaders_ns
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 static void SslHdrExpand(SSL *, const SslHdrInstance::expansion_list &, TSMBuffer, TSMLoc);
 
 static int
diff --git a/plugins/experimental/sslheaders/sslheaders.h b/plugins/experimental/sslheaders/sslheaders.h
index ba8fd5ad32a..edb40ef1cd5 100644
--- a/plugins/experimental/sslheaders/sslheaders.h
+++ b/plugins/experimental/sslheaders/sslheaders.h
@@ -29,7 +29,12 @@ using BIO  = struct bio_st;
 
 #define PLUGIN_NAME "sslheaders"
 
-#define SslHdrDebug(fmt, ...) TSDebug(PLUGIN_NAME, "%s: " fmt, __func__, ##__VA_ARGS__)
+namespace sslheaders_ns
+{
+extern DbgCtl dbg_ctl;
+}
+
+#define SslHdrDebug(fmt, ...) Dbg(sslheaders_ns::dbg_ctl, "%s: " fmt, __func__, ##__VA_ARGS__)
 #define SslHdrError(fmt, ...)  \
   TSError("[" PLUGIN_NAME "] " \
           ": %s: " fmt,        \
diff --git a/plugins/experimental/sslheaders/unit_tests/test_sslheaders.cc b/plugins/experimental/sslheaders/unit_tests/test_sslheaders.cc
index 6ff8fed6167..9f5288377a8 100644
--- a/plugins/experimental/sslheaders/unit_tests/test_sslheaders.cc
+++ b/plugins/experimental/sslheaders/unit_tests/test_sslheaders.cc
@@ -17,6 +17,7 @@
  */
 
 #include "../sslheaders.h"
+#include <ts/ts.h>
 #include <cstdio>
 #include <cstdarg>
 #include <openssl/ssl.h>
@@ -28,7 +29,7 @@
 // Mock TS API functions.
 
 void
-TSDebug(const char *tag, const char *fmt, ...)
+DbgCtl::print(const char *tag, char const * /* file */, char const * /* function */, int /* line */, const char *fmt, ...)
 {
   va_list args;
 
diff --git a/plugins/experimental/stek_share/state_machine.h b/plugins/experimental/stek_share/state_machine.h
index a096f6c8a39..e6ecf58bebd 100644
--- a/plugins/experimental/stek_share/state_machine.h
+++ b/plugins/experimental/stek_share/state_machine.h
@@ -50,7 +50,7 @@ class STEKShareSM : public nuraft::state_machine
     size_t len = 0;
     nuraft::buffer_serializer bs_data(data);
     void *byte_array = bs_data.get_bytes(len);
-    // TSDebug(PLUGIN_NAME, "commit %lu: %s", log_idx, hex_str(std::string(reinterpret_cast<char *>(byte_array), len)).c_str());
+    // Dbg(dbg_ctl, "commit %lu: %s", log_idx, hex_str(std::string(reinterpret_cast<char *>(byte_array), len)).c_str());
 
     assert(len == SSL_TICKET_KEY_SIZE);
 
@@ -105,7 +105,7 @@ class STEKShareSM : public nuraft::state_machine
   read_logical_snp_obj(nuraft::snapshot &s, void *&user_snp_ctx, uint64_t obj_id, nuraft::ptr<nuraft::buffer> &data_out,
                        bool &is_last_obj) override
   {
-    // TSDebug(PLUGIN_NAME, "read snapshot %lu term %lu object ID %lu", s.get_last_log_idx(), s.get_last_log_term(), obj_id);
+    // Dbg(dbg_ctl, "read snapshot %lu term %lu object ID %lu", s.get_last_log_idx(), s.get_last_log_term(), obj_id);
 
     is_last_obj = true;
 
@@ -126,7 +126,7 @@ class STEKShareSM : public nuraft::state_machine
   void
   save_logical_snp_obj(nuraft::snapshot &s, uint64_t &obj_id, nuraft::buffer &data, bool is_first_obj, bool is_last_obj) override
   {
-    // TSDebug(PLUGIN_NAME, "save snapshot %lu term %lu object ID %lu", s.get_last_log_idx(), s.get_last_log_term(), obj_id);
+    // Dbg(dbg_ctl, "save snapshot %lu term %lu object ID %lu", s.get_last_log_idx(), s.get_last_log_term(), obj_id);
 
     size_t len = 0;
     nuraft::buffer_serializer bs_data(data);
@@ -152,7 +152,7 @@ class STEKShareSM : public nuraft::state_machine
   bool
   apply_snapshot(nuraft::snapshot &s) override
   {
-    // TSDebug(PLUGIN_NAME, "apply snapshot %lu term %lu", s.get_last_log_idx(), s.get_last_log_term());
+    // Dbg(dbg_ctl, "apply snapshot %lu term %lu", s.get_last_log_idx(), s.get_last_log_term());
 
     {
       std::lock_guard<std::mutex> l(snapshot_lock_);
@@ -192,7 +192,7 @@ class STEKShareSM : public nuraft::state_machine
   void
   create_snapshot(nuraft::snapshot &s, nuraft::async_result<bool>::handler_type &when_done) override
   {
-    // TSDebug(PLUGIN_NAME, "create snapshot %lu term %lu", s.get_last_log_idx(), s.get_last_log_term());
+    // Dbg(dbg_ctl, "create snapshot %lu term %lu", s.get_last_log_idx(), s.get_last_log_term());
 
     ssl_ticket_key_t local_stek;
     {
diff --git a/plugins/experimental/stek_share/stek_share.cc b/plugins/experimental/stek_share/stek_share.cc
index 2a26697e513..99270eaa98d 100644
--- a/plugins/experimental/stek_share/stek_share.cc
+++ b/plugins/experimental/stek_share/stek_share.cc
@@ -102,13 +102,13 @@ message_handler(TSCont contp, TSEvent event, void *edata)
 {
   if (event == TS_EVENT_LIFECYCLE_MSG) {
     TSPluginMsg *msg = static_cast<TSPluginMsg *>(edata);
-    TSDebug(PLUGIN_NAME, "Message to '%s' - %zu bytes of data", msg->tag, msg->data_size);
+    Dbg(dbg_ctl, "Message to '%s' - %zu bytes of data", msg->tag, msg->data_size);
     if (strcmp(PLUGIN_NAME, msg->tag) == 0) { // Message is for us
       if (msg->data_size) {
         if (strncmp(reinterpret_cast<char *>(const_cast<void *>(msg->data)), "reload", msg->data_size) == 0) {
           // TODO: If in the middle of generating a new STEK, maybe block until new STEK has been generated?
           //       Not a big problem since new STEK is only generated once every few hours.
-          TSDebug(PLUGIN_NAME, "Reloading configurations...");
+          Dbg(dbg_ctl, "Reloading configurations...");
           if (load_config_from_file() == 0) {
             stek_share_server.config_reloading = true;
             stek_share_server.raft_launcher.shutdown();
@@ -116,13 +116,13 @@ message_handler(TSCont contp, TSEvent event, void *edata)
             auto config = get_scoped_config();
             if (init_raft(nuraft::cs_new<STEKShareSM>(), config) == 0) {
               backup_config(config);
-              TSDebug(PLUGIN_NAME, "Server ID: %d, Endpoint: %s", config->server_id, config->endpoint.c_str());
+              Dbg(dbg_ctl, "Server ID: %d, Endpoint: %s", config->server_id, config->endpoint.c_str());
             } else {
               TSError("[%s] Raft initialization failed with new config, retrying with old config.", PLUGIN_NAME);
               auto config_old = get_scoped_config(true);
               restore_config(config_old);
               if (init_raft(nuraft::cs_new<STEKShareSM>(), config_old) == 0) {
-                TSDebug(PLUGIN_NAME, "Server ID: %d, Endpoint: %s", config->server_id, config->endpoint.c_str());
+                Dbg(dbg_ctl, "Server ID: %d, Endpoint: %s", config->server_id, config->endpoint.c_str());
               } else {
                 TSEmergency("[%s] Raft initialization failed with old config.", PLUGIN_NAME);
               }
@@ -147,7 +147,7 @@ cert_verification(const std::string &sn)
 {
   auto config = get_scoped_config();
   if (!config->cert_verify_str.empty() && sn.compare(config->cert_verify_str) != 0) {
-    TSDebug(PLUGIN_NAME, "Cert incorrect, expecting: %s, got: %s", config->cert_verify_str.c_str(), sn.c_str());
+    Dbg(dbg_ctl, "Cert incorrect, expecting: %s, got: %s", config->cert_verify_str.c_str(), sn.c_str());
     return false;
   }
   return true;
@@ -198,7 +198,7 @@ init_raft(nuraft::ptr<nuraft::state_machine> sm_instance, std::shared_ptr<Plugin
 
   std::shared_lock lock(stek_share_server.raft_mutex);
   if (!stek_share_server.raft_instance) {
-    TSDebug(PLUGIN_NAME, "Failed to initialize launcher.");
+    Dbg(dbg_ctl, "Failed to initialize launcher.");
     return -1;
   }
 
@@ -214,10 +214,10 @@ load_config_from_file()
   try {
     server_conf = YAML::LoadFile(conf_file_path);
   } catch (YAML::BadFile &e) {
-    TSDebug(PLUGIN_NAME, "Cannot load configuration file: %s.", e.what());
+    Dbg(dbg_ctl, "Cannot load configuration file: %s.", e.what());
     return -1;
   } catch (std::exception &e) {
-    TSDebug(PLUGIN_NAME, "Unknown error while loading configuration file: %s.", e.what());
+    Dbg(dbg_ctl, "Unknown error while loading configuration file: %s.", e.what());
     return -1;
   }
 
@@ -225,11 +225,11 @@ load_config_from_file()
   if (server_conf["server_id"]) {
     new_config->server_id = server_conf["server_id"].as<int>();
     if (new_config->server_id < 1) {
-      TSDebug(PLUGIN_NAME, "Wrong server id (must be >= 1): %d", new_config->server_id);
+      Dbg(dbg_ctl, "Wrong server id (must be >= 1): %d", new_config->server_id);
       return -1;
     }
   } else {
-    TSDebug(PLUGIN_NAME, "Must specify server id in the configuration file.");
+    Dbg(dbg_ctl, "Must specify server id in the configuration file.");
     return -1;
   }
 
@@ -237,14 +237,14 @@ load_config_from_file()
   if (server_conf["address"]) {
     new_config->address = server_conf["address"].as<std::string>();
   } else {
-    TSDebug(PLUGIN_NAME, "Must specify server address in the configuration file.");
+    Dbg(dbg_ctl, "Must specify server address in the configuration file.");
     return -1;
   }
 
   if (server_conf["port"]) {
     new_config->port = server_conf["port"].as<int>();
   } else {
-    TSDebug(PLUGIN_NAME, "Must specify server port in the configuration file.");
+    Dbg(dbg_ctl, "Must specify server port in the configuration file.");
     return -1;
   }
 
@@ -281,7 +281,7 @@ load_config_from_file()
   if (server_conf["key_update_interval"]) {
     new_config->key_update_interval = std::chrono::seconds(server_conf["key_update_interval"].as<int>());
   } else {
-    TSDebug(PLUGIN_NAME, "Must specify server key update interval in the configuration file.");
+    Dbg(dbg_ctl, "Must specify server key update interval in the configuration file.");
     return -1;
   }
 
@@ -290,10 +290,10 @@ load_config_from_file()
     try {
       server_list = YAML::LoadFile(server_conf["server_list_file"].as<std::string>());
     } catch (YAML::BadFile &e) {
-      TSDebug(PLUGIN_NAME, "Cannot load server list file: %s.", e.what());
+      Dbg(dbg_ctl, "Cannot load server list file: %s.", e.what());
       return -1;
     } catch (std::exception &e) {
-      TSDebug(PLUGIN_NAME, "Unknown error while loading server list file: %s.", e.what());
+      Dbg(dbg_ctl, "Unknown error while loading server list file: %s.", e.what());
       return -1;
     }
 
@@ -309,13 +309,13 @@ load_config_from_file()
         new_config->server_list[server_id]  = endpoint;
         cluster_list_str                   += "\n  " + std::to_string(server_id) + ", " + endpoint;
       } else {
-        TSDebug(PLUGIN_NAME, "Wrong server list format.");
+        Dbg(dbg_ctl, "Wrong server list format.");
         return -1;
       }
     }
-    TSDebug(PLUGIN_NAME, "%s", cluster_list_str.c_str());
+    Dbg(dbg_ctl, "%s", cluster_list_str.c_str());
   } else {
-    TSDebug(PLUGIN_NAME, "Must specify server list file in the configuration file.");
+    Dbg(dbg_ctl, "Must specify server list file in the configuration file.");
     return -1;
   }
 
@@ -323,21 +323,21 @@ load_config_from_file()
   if (server_conf["root_cert_file"]) {
     new_config->root_cert_file = server_conf["root_cert_file"].as<std::string>();
   } else {
-    TSDebug(PLUGIN_NAME, "Must specify root ca file in the configuration file.");
+    Dbg(dbg_ctl, "Must specify root ca file in the configuration file.");
     return -1;
   }
 
   if (server_conf["server_cert_file"]) {
     new_config->server_cert_file = server_conf["server_cert_file"].as<std::string>();
   } else {
-    TSDebug(PLUGIN_NAME, "Must specify server cert file in the configuration file.");
+    Dbg(dbg_ctl, "Must specify server cert file in the configuration file.");
     return -1;
   }
 
   if (server_conf["server_key_file"]) {
     new_config->server_key_file = server_conf["server_key_file"].as<std::string>();
   } else {
-    TSDebug(PLUGIN_NAME, "Must specify server key file in the configuration file.");
+    Dbg(dbg_ctl, "Must specify server key file in the configuration file.");
     return -1;
   }
 
@@ -357,10 +357,10 @@ handle_result(raft_result &result, nuraft::ptr<std::exception> &err)
   if (result.get_result_code() != nuraft::cmd_result_code::OK) {
     // Something went wrong.
     // This means committing this log failed, but the log itself is still in the log store.
-    TSDebug(PLUGIN_NAME, "Replication failed: %d", result.get_result_code());
+    Dbg(dbg_ctl, "Replication failed: %d", result.get_result_code());
     return;
   }
-  TSDebug(PLUGIN_NAME, "Replication succeeded.");
+  Dbg(dbg_ctl, "Replication succeeded.");
 }
 
 void
@@ -377,7 +377,7 @@ append_log(const void *data, int data_len)
 
   if (!ret->get_accepted()) {
     // Log append rejected, usually because this node is not a leader.
-    TSDebug(PLUGIN_NAME, "Replication failed: %d", ret->get_result_code());
+    Dbg(dbg_ctl, "Replication failed: %d", ret->get_result_code());
     return;
   }
 
@@ -410,7 +410,7 @@ print_status()
   status_str                        += "\n  Leader ID: " + std::to_string(stek_share_server.raft_instance->get_leader());
   status_str += "\n  Raft log range: " + std::to_string(ls->start_index()) + " - " + std::to_string((ls->next_slot() - 1));
   status_str += "\n  Last committed index: " + std::to_string(stek_share_server.raft_instance->get_committed_log_idx());
-  TSDebug(PLUGIN_NAME, "%s", status_str.c_str());
+  Dbg(dbg_ctl, "%s", status_str.c_str());
 }
 
 static void *
@@ -420,25 +420,25 @@ stek_updater(void *arg)
   ::pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, nullptr);
   ::pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, nullptr);
 
-  TSDebug(PLUGIN_NAME, "Starting STEK updater thread: %lu", ::pthread_self());
+  Dbg(dbg_ctl, "Starting STEK updater thread: %lu", ::pthread_self());
 
   while (!plugin_threads.is_shut_down()) {
     ssl_ticket_key_t curr_stek;
     std::chrono::time_point<std::chrono::system_clock> init_key_time;
 
     // Initial key to use before syncing up.
-    TSDebug(PLUGIN_NAME, "Generating initial STEK...");
+    Dbg(dbg_ctl, "Generating initial STEK...");
     if (generate_new_stek(&curr_stek, 0 /* fast start */) == 0) {
-      TSDebug(PLUGIN_NAME, "Generate initial STEK succeeded: %s",
-              hex_str(std::string(reinterpret_cast<char *>(&curr_stek), SSL_TICKET_KEY_SIZE)).c_str());
+      Dbg(dbg_ctl, "Generate initial STEK succeeded: %s",
+          hex_str(std::string(reinterpret_cast<char *>(&curr_stek), SSL_TICKET_KEY_SIZE)).c_str());
 
       std::memcpy(&stek_share_server.ticket_keys[0], &curr_stek, SSL_TICKET_KEY_SIZE);
 
-      TSDebug(PLUGIN_NAME, "Updating SSL Ticket Key...");
+      Dbg(dbg_ctl, "Updating SSL Ticket Key...");
       if (TSSslTicketKeyUpdate(reinterpret_cast<char *>(stek_share_server.ticket_keys), SSL_TICKET_KEY_SIZE) == TS_ERROR) {
-        TSDebug(PLUGIN_NAME, "Update SSL Ticket Key failed.");
+        Dbg(dbg_ctl, "Update SSL Ticket Key failed.");
       } else {
-        TSDebug(PLUGIN_NAME, "Update SSL Ticket Key succeeded.");
+        Dbg(dbg_ctl, "Update SSL Ticket Key succeeded.");
         init_key_time = std::chrono::system_clock::now();
       }
     } else {
@@ -465,30 +465,30 @@ stek_updater(void *arg)
             std::chrono::system_clock::now() - init_key_time < config->key_update_interval) {
           // If we got here after starting up, that means the initial key is still valid and we can send it to everyone else.
           stek_share_server.last_updated = init_key_time;
-          TSDebug(PLUGIN_NAME, "Using initial STEK: %s",
-                  hex_str(std::string(reinterpret_cast<char *>(&curr_stek), SSL_TICKET_KEY_SIZE)).c_str());
+          Dbg(dbg_ctl, "Using initial STEK: %s",
+              hex_str(std::string(reinterpret_cast<char *>(&curr_stek), SSL_TICKET_KEY_SIZE)).c_str());
           append_log(reinterpret_cast<const void *>(&curr_stek), SSL_TICKET_KEY_SIZE);
 
         } else if (std::chrono::system_clock::now() - stek_share_server.last_updated >= config->key_update_interval) {
           // Generate a new key as the last one has expired.
           // Move the old key from ticket_keys_[0] to ticket_keys_[1], then put the new key in ticket_keys_[0].
-          TSDebug(PLUGIN_NAME, "Generating new STEK...");
+          Dbg(dbg_ctl, "Generating new STEK...");
           if (generate_new_stek(&curr_stek, 1) == 0) {
-            TSDebug(PLUGIN_NAME, "Generate new STEK succeeded: %s",
-                    hex_str(std::string(reinterpret_cast<char *>(&curr_stek), SSL_TICKET_KEY_SIZE)).c_str());
+            Dbg(dbg_ctl, "Generate new STEK succeeded: %s",
+                hex_str(std::string(reinterpret_cast<char *>(&curr_stek), SSL_TICKET_KEY_SIZE)).c_str());
 
             std::memcpy(&stek_share_server.ticket_keys[1], &stek_share_server.ticket_keys[0], SSL_TICKET_KEY_SIZE);
             std::memcpy(&stek_share_server.ticket_keys[0], &curr_stek, SSL_TICKET_KEY_SIZE);
 
-            TSDebug(PLUGIN_NAME, "Updating SSL Ticket Key...");
+            Dbg(dbg_ctl, "Updating SSL Ticket Key...");
             if (TSSslTicketKeyUpdate(reinterpret_cast<char *>(stek_share_server.ticket_keys), SSL_TICKET_KEY_SIZE * 2) ==
                 TS_ERROR) {
-              TSDebug(PLUGIN_NAME, "Update SSL Ticket Key failed.");
+              Dbg(dbg_ctl, "Update SSL Ticket Key failed.");
             } else {
               stek_share_server.last_updated = std::chrono::system_clock::now();
-              TSDebug(PLUGIN_NAME, "Update SSL Ticket Key succeeded.");
-              TSDebug(PLUGIN_NAME, "Using new STEK: %s",
-                      hex_str(std::string(reinterpret_cast<char *>(&curr_stek), SSL_TICKET_KEY_SIZE)).c_str());
+              Dbg(dbg_ctl, "Update SSL Ticket Key succeeded.");
+              Dbg(dbg_ctl, "Using new STEK: %s",
+                  hex_str(std::string(reinterpret_cast<char *>(&curr_stek), SSL_TICKET_KEY_SIZE)).c_str());
               append_log(reinterpret_cast<const void *>(&curr_stek), SSL_TICKET_KEY_SIZE);
             }
           } else {
@@ -506,19 +506,19 @@ stek_updater(void *arg)
         // Check whether we received a new key.
         // TODO: retry updating STEK when failed
         if (sm->received_stek(&curr_stek)) {
-          TSDebug(PLUGIN_NAME, "Received new STEK: %s",
-                  hex_str(std::string(reinterpret_cast<char *>(&curr_stek), SSL_TICKET_KEY_SIZE)).c_str());
+          Dbg(dbg_ctl, "Received new STEK: %s",
+              hex_str(std::string(reinterpret_cast<char *>(&curr_stek), SSL_TICKET_KEY_SIZE)).c_str());
 
           // Move the old key from ticket_keys_[0] to ticket_keys_[1], then put the new key in ticket_keys_[0].
           std::memcpy(&stek_share_server.ticket_keys[1], &stek_share_server.ticket_keys[0], SSL_TICKET_KEY_SIZE);
           std::memcpy(&stek_share_server.ticket_keys[0], &curr_stek, SSL_TICKET_KEY_SIZE);
 
-          TSDebug(PLUGIN_NAME, "Updating SSL Ticket Key...");
+          Dbg(dbg_ctl, "Updating SSL Ticket Key...");
           if (TSSslTicketKeyUpdate(reinterpret_cast<char *>(stek_share_server.ticket_keys), SSL_TICKET_KEY_SIZE * 2) == TS_ERROR) {
-            TSDebug(PLUGIN_NAME, "Update SSL Ticket Key failed.");
+            Dbg(dbg_ctl, "Update SSL Ticket Key failed.");
           } else {
             stek_share_server.last_updated = std::chrono::system_clock::now();
-            TSDebug(PLUGIN_NAME, "Update SSL Ticket Key succeeded.");
+            Dbg(dbg_ctl, "Update SSL Ticket Key succeeded.");
           }
         }
       }
@@ -536,7 +536,7 @@ stek_updater(void *arg)
     stek_share_server.config_reloading = false;
   }
 
-  TSDebug(PLUGIN_NAME, "Stopping STEK updater thread: %lu", ::pthread_self());
+  Dbg(dbg_ctl, "Stopping STEK updater thread: %lu", ::pthread_self());
 
   return nullptr;
 }
@@ -567,7 +567,7 @@ TSPluginInit(int argc, const char *argv[])
       auto config = get_scoped_config();
       if (init_raft(nuraft::cs_new<STEKShareSM>(), config) == 0) {
         backup_config(config);
-        TSDebug(PLUGIN_NAME, "Server ID: %d, Endpoint: %s", config->server_id, config->endpoint.c_str());
+        Dbg(dbg_ctl, "Server ID: %d, Endpoint: %s", config->server_id, config->endpoint.c_str());
         TSThreadCreate(stek_updater, nullptr);
       } else {
         TSError("[%s] Raft initialization failed.", PLUGIN_NAME);
diff --git a/plugins/experimental/stream_editor/stream_editor.cc b/plugins/experimental/stream_editor/stream_editor.cc
index cba92518093..a5f1533c6ec 100644
--- a/plugins/experimental/stream_editor/stream_editor.cc
+++ b/plugins/experimental/stream_editor/stream_editor.cc
@@ -105,6 +105,12 @@ struct edit_t;
 using editset_t = std::set<edit_t>;
 using edit_p    = editset_t::const_iterator;
 
+namespace
+{
+DbgCtl dbg_ctl{"[stream-editor]"};
+DbgCtl dbg_ctl_no_brackets{"stream-editor"};
+} // namespace
+
 struct edit_t {
   const size_t start;
   const size_t bytes;
@@ -142,8 +148,8 @@ struct edit_t {
         edits.insert(*this);
         return true;
       } catch (const edit_t &conflicted) {
-        TSDebug("stream-editor", "Conflicting edits [%ld-%ld] vs [%ld-%ld]", start, start + bytes, conflicted.start,
-                conflicted.start + conflicted.bytes);
+        Dbg(dbg_ctl_no_brackets, "Conflicting edits [%ld-%ld] vs [%ld-%ld]", start, start + bytes, conflicted.start,
+            conflicted.start + conflicted.bytes);
         if (priority < conflicted.priority) {
           /* we win conflict and oust our enemy */
           edits.erase(conflicted);
@@ -850,7 +856,7 @@ TSPluginInit(int argc, const char *argv[])
   }
 
   if (rewrites_in != nullptr) {
-    TSDebug("[stream-editor]", "initializing input filtering");
+    Dbg(dbg_ctl, "initializing input filtering");
     inputcont = TSContCreate(streamedit_setup, nullptr);
     if (inputcont == nullptr) {
       TSError("[stream-editor] failed to initialize input filtering!");
@@ -859,11 +865,11 @@ TSPluginInit(int argc, const char *argv[])
       TSHttpHookAdd(TS_HTTP_READ_REQUEST_HDR_HOOK, inputcont);
     }
   } else {
-    TSDebug("[stream-editor]", "no input filter rules, skipping filter");
+    Dbg(dbg_ctl, "no input filter rules, skipping filter");
   }
 
   if (rewrites_out != nullptr) {
-    TSDebug("[stream-editor]", "initializing output filtering");
+    Dbg(dbg_ctl, "initializing output filtering");
     outputcont = TSContCreate(streamedit_setup, nullptr);
     if (outputcont == nullptr) {
       TSError("[stream-editor] failed to initialize output filtering!");
@@ -872,6 +878,6 @@ TSPluginInit(int argc, const char *argv[])
       TSHttpHookAdd(TS_HTTP_READ_RESPONSE_HDR_HOOK, outputcont);
     }
   } else {
-    TSDebug("[stream-editor]", "no output filter rules, skipping filter");
+    Dbg(dbg_ctl, "no output filter rules, skipping filter");
   }
 }
diff --git a/plugins/experimental/system_stats/system_stats.cc b/plugins/experimental/system_stats/system_stats.cc
index e9073f6cf96..2eba7dffa94 100644
--- a/plugins/experimental/system_stats/system_stats.cc
+++ b/plugins/experimental/system_stats/system_stats.cc
@@ -93,6 +93,11 @@
 // port information we may want such as the up/down streams port state
 #define BONDING_SLAVE_DIR "bonding_slave"
 
+namespace
+{
+DbgCtl dbg_ctl{DEBUG_TAG};
+}
+
 static int
 statAdd(const char *name, TSRecordDataType record_type, TSMutex create_mutex)
 {
@@ -103,9 +108,9 @@ statAdd(const char *name, TSRecordDataType record_type, TSMutex create_mutex)
   if (TS_ERROR == TSStatFindName(name, &stat_id)) {
     stat_id = TSStatCreate(name, record_type, TS_STAT_NON_PERSISTENT, TS_STAT_SYNC_SUM);
     if (stat_id == TS_ERROR) {
-      TSDebug(DEBUG_TAG, "Error creating stat_name: %s", name);
+      Dbg(dbg_ctl, "Error creating stat_name: %s", name);
     } else {
-      TSDebug(DEBUG_TAG, "Created stat_name: %s stat_id: %d", name, stat_id);
+      Dbg(dbg_ctl, "Created stat_name: %s stat_id: %d", name, stat_id);
     }
   }
 
@@ -176,7 +181,7 @@ setNetStat(TSMutex stat_creation_mutex, const char *interface, const char *entry
   }
 
   if (getFile(&sysfs_name[0], &data[0], sizeof(data)) < 0) {
-    TSDebug(DEBUG_TAG, "Error reading file %s", sysfs_name);
+    Dbg(dbg_ctl, "Error reading file %s", sysfs_name);
   } else {
     statSet(stat_name, atol(data), stat_creation_mutex);
   }
@@ -295,13 +300,13 @@ systemStatsContCB(TSCont cont, TSEvent event ATS_UNUSED, void *edata)
 {
   TSMutex stat_creation_mutex;
 
-  TSDebug(DEBUG_TAG, "entered %s", __FUNCTION__);
+  Dbg(dbg_ctl, "entered %s", __FUNCTION__);
 
   stat_creation_mutex = TSContMutexGet(cont);
   getStats(stat_creation_mutex);
 
   TSContScheduleOnPool(cont, SYSTEM_STATS_TIMEOUT, TS_THREAD_POOL_TASK);
-  TSDebug(DEBUG_TAG, "finished %s", __FUNCTION__);
+  Dbg(dbg_ctl, "finished %s", __FUNCTION__);
 
   return 0;
 }
@@ -320,7 +325,7 @@ TSPluginInit(int argc, const char *argv[])
     TSError("[%s] Plugin registration failed", DEBUG_TAG);
     return;
   } else {
-    TSDebug(DEBUG_TAG, "Plugin registration succeeded");
+    Dbg(dbg_ctl, "Plugin registration succeeded");
   }
 
   stats_cont = TSContCreate(systemStatsContCB, TSMutexCreate());
@@ -331,5 +336,5 @@ TSPluginInit(int argc, const char *argv[])
   // 5 seconds.
   TSContScheduleOnPool(stats_cont, 0, TS_THREAD_POOL_TASK);
 
-  TSDebug(DEBUG_TAG, "Init complete");
+  Dbg(dbg_ctl, "Init complete");
 }
diff --git a/plugins/experimental/tls_bridge/tls_bridge.cc b/plugins/experimental/tls_bridge/tls_bridge.cc
index 527f0f26987..fd1dff05e81 100644
--- a/plugins/experimental/tls_bridge/tls_bridge.cc
+++ b/plugins/experimental/tls_bridge/tls_bridge.cc
@@ -38,6 +38,8 @@ const TextView METHOD_CONNECT{TS_HTTP_METHOD_CONNECT, TS_HTTP_LEN_CONNECT};
 constexpr TextView CONFIG_FILE_ARG{"--file"};
 const std::string TS_CONFIG_DIR{TSConfigDirGet()};
 
+DbgCtl dbg_ctl{PLUGIN_TAG};
+
 }; // namespace
 
 /* ------------------------------------------------------------------------------------ */
@@ -306,7 +308,7 @@ Bridge::net_accept(TSVConn vc)
   char buff[1024];
   int64_t n = snprintf(buff, sizeof(buff), CONNECT_FORMAT, int(_peer.size()), _peer.data());
 
-  TSDebug(PLUGIN_TAG, "Received UA VConn, connecting to peer %.*s", int(_peer.size()), _peer.data());
+  Dbg(dbg_ctl, "Received UA VConn, connecting to peer %.*s", int(_peer.size()), _peer.data());
   // UA side intercepted.
   _ua.init(vc);
   _ua.do_read(_self_cont, INT64_MAX);
@@ -327,7 +329,7 @@ Bridge::read_ready(TSVIO vio)
 {
   using swoc::TextView;
 
-  TSDebug(PLUGIN_TAG, "READ READY");
+  Dbg(dbg_ctl, "READ READY");
   if (vio == _out._read._vio) {
     switch (_out_resp_state) {
     case PRE:
@@ -392,7 +394,7 @@ Bridge::check_outbound_OK()
         _out_response_code = c ? c : static_cast<TSHttpStatus>(519);
         _out.consume(block.data() - raw.data());
         zret = true;
-        TSDebug(PLUGIN_TAG, "Outbound status %d", c);
+        Dbg(dbg_ctl, "Outbound status %d", c);
       }
     }
   }
@@ -423,7 +425,7 @@ Bridge::check_outbound_terminal()
           _out_terminal_pos = 4;
           _out_resp_state   = READY;
           zret              = true;
-          TSDebug(PLUGIN_TAG, "Outbound ready");
+          Dbg(dbg_ctl, "Outbound ready");
         } else if (_out_terminal_pos == 1) {
           _out_terminal_pos = 2;
         } else {
@@ -450,7 +452,7 @@ Bridge::flow_to_ua()
     TSAssert(n == avail);
 
     _out.consume(n);
-    TSDebug(PLUGIN_TAG, "Wrote %" PRId64 " bytes to UA", n);
+    Dbg(dbg_ctl, "Wrote %" PRId64 " bytes to UA", n);
     TSVIOReenable(_ua._write._vio);
     TSVIOReenable(_out._read._vio);
   }
@@ -466,7 +468,7 @@ Bridge::flow_to_outbound()
     TSAssert(n == avail);
 
     _ua.consume(n);
-    TSDebug(PLUGIN_TAG, "Wrote %" PRId64 " bytes to upstream", n);
+    Dbg(dbg_ctl, "Wrote %" PRId64 " bytes to upstream", n);
     TSVIOReenable(_out._write._vio);
     TSVIOReenable(_ua._read._vio);
   }
@@ -478,11 +480,11 @@ Bridge::eos(TSVIO vio)
   if (nullptr == vio) {
     // Generic close for some non-EOS reason.
   } else if (vio == _out._write._vio || vio == _out._read._vio) {
-    TSDebug(PLUGIN_TAG, "EOS upstream");
+    Dbg(dbg_ctl, "EOS upstream");
   } else if (vio == _ua._write._vio || vio == _ua._read._vio) {
-    TSDebug(PLUGIN_TAG, "EOS user agent");
+    Dbg(dbg_ctl, "EOS user agent");
   } else {
-    TSDebug(PLUGIN_TAG, "EOS from unknown VIO [%p]", vio);
+    Dbg(dbg_ctl, "EOS from unknown VIO [%p]", vio);
   }
   _out.do_close();
   _ua.do_close();
@@ -522,7 +524,7 @@ Bridge::update_ua_response()
     Hdr_Remove_Field(mbuf, hdr_loc, {TS_MIME_FIELD_PROXY_CONNECTION, TS_MIME_LEN_PROXY_CONNECTION});
     TSHandleMLocRelease(mbuf, TS_NULL_MLOC, hdr_loc);
   } else {
-    TSDebug(PLUGIN_TAG, "Failed to retrieve client response");
+    Dbg(dbg_ctl, "Failed to retrieve client response");
   }
 }
 
@@ -627,18 +629,18 @@ CB_Exec(TSCont contp, TSEvent ev_idx, void *data)
     ctx->eos(static_cast<TSVIO>(data));
     break;
   case TS_EVENT_HTTP_SEND_RESPONSE_HDR:
-    TSDebug(PLUGIN_TAG, "SEND_RESPONSE_HDR");
+    Dbg(dbg_ctl, "SEND_RESPONSE_HDR");
     ctx->send_response_cb();
     break;
   case TS_EVENT_HTTP_TXN_CLOSE:
-    TSDebug(PLUGIN_TAG, "TXN_CLOSE: cleanup");
+    Dbg(dbg_ctl, "TXN_CLOSE: cleanup");
     ctx->eos(nullptr); // no specific VIO, close up everything.
     delete ctx;
     TSContDataSet(contp, nullptr); // Not sure if necessary, it's cheap, let's be safe.
     TSContDestroy(contp);
     break;
   default:
-    TSDebug(PLUGIN_TAG, "Event %d", ev_idx);
+    Dbg(dbg_ctl, "Event %d", ev_idx);
     break;
   }
   return TS_EVENT_CONTINUE;
@@ -665,8 +667,8 @@ CB_Read_Request_Hdr(TSCont contp, TSEvent ev_idx, void *data)
           auto actor = TSContCreate(CB_Exec, TSContMutexGet(reinterpret_cast<TSCont>(txn)));
           auto ctx   = new Bridge(actor, txn, peer);
 
-          TSDebug(PLUGIN_TAG, "Intercepting transaction %" PRIu64 " to '%.*s' via '%.*s'", TSHttpTxnIdGet(txn), host_len, host_name,
-                  static_cast<int>(peer.size()), peer.data());
+          Dbg(dbg_ctl, "Intercepting transaction %" PRIu64 " to '%.*s' via '%.*s'", TSHttpTxnIdGet(txn), host_len, host_name,
+              static_cast<int>(peer.size()), peer.data());
 
           TSContDataSet(actor, ctx);
           // Need to play games with the response, delaying it until upstream connection is done.
diff --git a/plugins/experimental/uri_signing/common.cc b/plugins/experimental/uri_signing/common.cc
index bae8b6d911a..04dce66dc2d 100644
--- a/plugins/experimental/uri_signing/common.cc
+++ b/plugins/experimental/uri_signing/common.cc
@@ -29,4 +29,11 @@ PrintToStdErr(const char *fmt, ...)
   va_end(args);
 }
 
+#else
+
+namespace uri_signing_ns
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 #endif
diff --git a/plugins/experimental/uri_signing/common.h b/plugins/experimental/uri_signing/common.h
index abc87f7fbde..e4d474c0cf6 100644
--- a/plugins/experimental/uri_signing/common.h
+++ b/plugins/experimental/uri_signing/common.h
@@ -32,9 +32,16 @@ void PrintToStdErr(const char *fmt, ...);
 
 #else
 
-#include "ts/ts.h"
+#include <ts/ts.h>
+
+namespace uri_signing_ns
+{
+extern DbgCtl dbg_ctl;
+}
+using namespace uri_signing_ns;
+
 #define __FILENAME__          (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
-#define PluginDebug(fmt, ...) TSDebug(PLUGIN_NAME, "[%s:% 4d] %s(): " fmt, __FILENAME__, __LINE__, __func__, ##__VA_ARGS__);
+#define PluginDebug(fmt, ...) Dbg(dbg_ctl, "[%s:% 4d] %s(): " fmt, __FILENAME__, __LINE__, __func__, ##__VA_ARGS__);
 #define PluginError(fmt, ...)      \
   PluginDebug(fmt, ##__VA_ARGS__); \
   TSError("[%s:% 4d] %s(): " fmt, __FILENAME__, __LINE__, __func__, ##__VA_ARGS__);
diff --git a/plugins/experimental/uri_signing/uri_signing.cc b/plugins/experimental/uri_signing/uri_signing.cc
index d1280245ca9..6f1096c6d0a 100644
--- a/plugins/experimental/uri_signing/uri_signing.cc
+++ b/plugins/experimental/uri_signing/uri_signing.cc
@@ -50,7 +50,7 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char *errbuf, int errbuf_s
     return TS_ERROR;
   }
 
-  TSDebug(PLUGIN_NAME, "Initializing remap function of %s -> %s with config from %s", argv[0], argv[1], argv[2]);
+  Dbg(dbg_ctl, "Initializing remap function of %s -> %s with config from %s", argv[0], argv[1], argv[2]);
 
   char const *const fname = argv[2];
 
@@ -69,7 +69,7 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char *errbuf, int errbuf_s
     static_cast<void>(snprintf(config_file, config_file_ct + 1, "%s/%s", config_dir, fname));
   }
 
-  TSDebug(PLUGIN_NAME, "config file name: %s", config_file);
+  Dbg(dbg_ctl, "config file name: %s", config_file);
   struct config *cfg = read_config_from_path(config_file);
   if (!cfg) {
     snprintf(errbuf, errbuf_size, "Unable to open config file: \"%s\"", config_file);
diff --git a/plugins/experimental/url_sig/url_sig.cc b/plugins/experimental/url_sig/url_sig.cc
index 6d29442da03..d81c7ab4fb3 100644
--- a/plugins/experimental/url_sig/url_sig.cc
+++ b/plugins/experimental/url_sig/url_sig.cc
@@ -53,6 +53,8 @@
 
 static const char PLUGIN_NAME[] = "url_sig";
 
+static DbgCtl dbg_ctl{PLUGIN_NAME};
+
 struct config {
   TSHttpStatus err_status;
   char *err_url;
@@ -67,7 +69,7 @@ struct config {
 static void
 free_cfg(struct config *cfg)
 {
-  TSDebug(PLUGIN_NAME, "Cleaning up");
+  Dbg(dbg_ctl, "Cleaning up");
   TSfree(cfg->err_url);
   TSfree(cfg->sig_anchor);
 
@@ -90,7 +92,7 @@ TSReturnCode
 TSRemapInit(TSRemapInterface *api_info, char *errbuf, int errbuf_size)
 {
   CHECK_REMAP_API_COMPATIBILITY(api_info, errbuf, errbuf_size);
-  TSDebug(PLUGIN_NAME, "plugin is successfully initialized");
+  Dbg(dbg_ctl, "plugin is successfully initialized");
   return TS_SUCCESS;
 }
 
@@ -108,7 +110,7 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char *errbuf, int errbuf_s
              argc);
     return TS_ERROR;
   }
-  TSDebug(PLUGIN_NAME, "Initializing remap function of %s -> %s with config from %s", argv[0], argv[1], argv[2]);
+  Dbg(dbg_ctl, "Initializing remap function of %s -> %s with config from %s", argv[0], argv[1], argv[2]);
 
   if (argv[2][0] == '/') {
     config_file = argv[2];
@@ -116,7 +118,7 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char *errbuf, int errbuf_s
     snprintf(config_filepath_buf, sizeof(config_filepath_buf), "%s/%s", TSConfigDirGet(), argv[2]);
     config_file = config_filepath_buf;
   }
-  TSDebug(PLUGIN_NAME, "config file name: %s", config_file);
+  Dbg(dbg_ctl, "config file name: %s", config_file);
   FILE *file = fopen(config_file, "r");
   if (file == nullptr) {
     snprintf(errbuf, errbuf_size, "[TSRemapNewInstance] - Error opening file %s", config_file);
@@ -132,7 +134,7 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char *errbuf, int errbuf_s
   memset(cfg, 0, sizeof(struct config));
 
   while (fgets(line, sizeof(line), file) != nullptr) {
-    TSDebug(PLUGIN_NAME, "LINE: %s (%d)", line, (int)strlen(line));
+    Dbg(dbg_ctl, "LINE: %s (%d)", line, (int)strlen(line));
     line_no++;
 
     if (eat_comment) {
@@ -173,13 +175,13 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char *errbuf, int errbuf_s
       if (strncmp(line + 3, "0", 1) == 0) {
         keynum = 0;
       } else {
-        TSDebug(PLUGIN_NAME, ">>> %s <<<", line + 3);
+        Dbg(dbg_ctl, ">>> %s <<<", line + 3);
         keynum = atoi(line + 3);
         if (keynum == 0) {
           keynum = -1; // Not a Number
         }
       }
-      TSDebug(PLUGIN_NAME, "key number %d == %s", keynum, value);
+      Dbg(dbg_ctl, "key number %d == %s", keynum, value);
       if (keynum >= MAX_KEY_NUM || keynum < 0) {
         snprintf(errbuf, errbuf_size, "[TSRemapNewInstance] - Key number (%d) >= MAX_KEY_NUM (%d) or NaN", keynum, MAX_KEY_NUM);
         fclose(file);
@@ -208,13 +210,13 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char *errbuf, int errbuf_s
       int erroffset, options = 0;
 
       if (cfg->regex) {
-        TSDebug(PLUGIN_NAME, "Skipping duplicate excl_regex");
+        Dbg(dbg_ctl, "Skipping duplicate excl_regex");
         continue;
       }
 
       cfg->regex = pcre_compile(value, options, &errptr, &erroffset, nullptr);
       if (cfg->regex == nullptr) {
-        TSDebug(PLUGIN_NAME, "Regex compilation failed with error (%s) at character %d", errptr, erroffset);
+        Dbg(dbg_ctl, "Regex compilation failed with error (%s) at character %d", errptr, erroffset);
       } else {
 #ifdef PCRE_STUDY_JIT_COMPILE
         options = PCRE_STUDY_JIT_COMPILE;
@@ -230,7 +232,7 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char *errbuf, int errbuf_s
     } else if (strncmp(line, "url_type", 8) == 0) {
       if (strncmp(value, "pristine", 8) == 0) {
         cfg->pristine_url_flag = 1;
-        TSDebug(PLUGIN_NAME, "Pristine URLs (from config) will be used");
+        Dbg(dbg_ctl, "Pristine URLs (from config) will be used");
       }
     } else {
       TSError("[url_sig] Error parsing line %d of file %s (%s)", line_no, config_file, line);
@@ -242,7 +244,7 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char *errbuf, int errbuf_s
   if (argc > 3) {
     if (strcasecmp(argv[3], "pristineurl") == 0) {
       cfg->pristine_url_flag = 1;
-      TSDebug(PLUGIN_NAME, "Pristine URLs (from args) will be used");
+      Dbg(dbg_ctl, "Pristine URLs (from args) will be used");
 
     } else {
       snprintf(errbuf, errbuf_size, "[TSRemapNewInstance] - second pparam (if present) must be pristineurl");
@@ -286,7 +288,7 @@ static void
 err_log(const char *url, const char *msg)
 {
   if (msg && url) {
-    TSDebug(PLUGIN_NAME, "[URL=%s]: %s", url, msg);
+    Dbg(dbg_ctl, "[URL=%s]: %s", url, msg);
     TSError("[url_sig] [URL=%s]: %s", url, msg); // This goes to error.log
   } else {
     TSError("[url_sig] Invalid err_log request");
@@ -303,14 +305,14 @@ getAppQueryString(const char *query_string, int query_length)
   char buf[MAX_QUERY_LEN + 1];
 
   if (query_length > MAX_QUERY_LEN) {
-    TSDebug(PLUGIN_NAME, "Cannot process the query string as the length exceeds %d bytes", MAX_QUERY_LEN);
+    Dbg(dbg_ctl, "Cannot process the query string as the length exceeds %d bytes", MAX_QUERY_LEN);
     return nullptr;
   }
   memset(buf, 0, sizeof(buf));
   memcpy(buf, query_string, query_length);
   p = buf;
 
-  TSDebug(PLUGIN_NAME, "query_string: %s, query_length: %d", query_string, query_length);
+  Dbg(dbg_ctl, "query_string: %s, query_length: %d", query_string, query_length);
 
   do {
     switch (*p) {
@@ -394,7 +396,7 @@ urlParse(char const *const url_in, char *anchor, char *new_path_seg, int new_pat
     TSError("insufficient space to copy schema into new_path_seg buffer.");
     return nullptr;
   }
-  TSDebug(PLUGIN_NAME, "%s:%d - new_url: %.*s\n", __FILE__, __LINE__, (int)(new_url_end - new_url), new_url);
+  Dbg(dbg_ctl, "%s:%d - new_url: %.*s\n", __FILE__, __LINE__, (int)(new_url_end - new_url), new_url);
 
   // parse the url.
   if ((p = strtok_r(skip, "/", &saveptr)) != nullptr) {
@@ -447,7 +449,7 @@ urlParse(char const *const url_in, char *anchor, char *new_path_seg, int new_pat
     }
   }
   *new_path_seg_end = '\0';
-  TSDebug(PLUGIN_NAME, "new_path_seg: %s", new_path_seg);
+  Dbg(dbg_ctl, "new_path_seg: %s", new_path_seg);
 
   // save the encoded signing parameter data
   if (sig_anchor != nullptr) { // a signature anchor string was found.
@@ -464,21 +466,21 @@ urlParse(char const *const url_in, char *anchor, char *new_path_seg, int new_pat
       return nullptr;
     }
   }
-  TSDebug(PLUGIN_NAME, "signed_seg: %s", signed_seg);
+  Dbg(dbg_ctl, "signed_seg: %s", signed_seg);
 
   // no signature anchor was found so decode and save the signing parameters assumed
   // to be in the last path segment.
   if (sig_anchor == nullptr) {
     if (TSBase64Decode(segment[numtoks - 2], strlen(segment[numtoks - 2]), decoded_string, sizeof(decoded_string), &decoded_len) !=
         TS_SUCCESS) {
-      TSDebug(PLUGIN_NAME, "Unable to decode the  path parameter string.");
+      Dbg(dbg_ctl, "Unable to decode the  path parameter string.");
     }
   } else {
     if (TSBase64Decode(sig_anchor, strlen(sig_anchor), decoded_string, sizeof(decoded_string), &decoded_len) != TS_SUCCESS) {
-      TSDebug(PLUGIN_NAME, "Unable to decode the  path parameter string.");
+      Dbg(dbg_ctl, "Unable to decode the  path parameter string.");
     }
   }
-  TSDebug(PLUGIN_NAME, "decoded_string: %s", decoded_string);
+  Dbg(dbg_ctl, "decoded_string: %s", decoded_string);
 
   {
     int oob = 0; /* Out Of Buffer */
@@ -579,7 +581,7 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo *rri)
     url_len = current_url_len;
   }
 
-  TSDebug(PLUGIN_NAME, "%s", url);
+  Dbg(dbg_ctl, "%s", url);
 
   if (cfg->regex) {
     const int offset = 0, options = 0;
@@ -629,7 +631,7 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo *rri)
     if (!has_path_params) {
       query++; /* get rid of the ? */
     }
-    TSDebug(PLUGIN_NAME, "Query string is:%s", query);
+    Dbg(dbg_ctl, "Query string is:%s", query);
 
     // Block needed due to goto.
     {
@@ -645,7 +647,7 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo *rri)
         } else {
           switch (ip->sa_family) {
           case AF_INET:
-            TSDebug(PLUGIN_NAME, "ip->sa_family: AF_INET");
+            Dbg(dbg_ctl, "ip->sa_family: AF_INET");
             has_path_params == false ? (pp = strstr(cp, "&")) : (pp = strstr(cp, ";"));
             if ((pp - cp) > INET_ADDRSTRLEN - 1 || (pp - cp) < 4) {
               err_log(url, "IP address string too long or short.");
@@ -653,16 +655,16 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo *rri)
             }
             strncpy(client_ip, cp, (pp - cp));
             client_ip[pp - cp] = '\0';
-            TSDebug(PLUGIN_NAME, "CIP: -%s-", client_ip);
+            Dbg(dbg_ctl, "CIP: -%s-", client_ip);
             inet_ntop(AF_INET, &(((struct sockaddr_in *)ip)->sin_addr), ipstr, sizeof ipstr);
-            TSDebug(PLUGIN_NAME, "Peer address: -%s-", ipstr);
+            Dbg(dbg_ctl, "Peer address: -%s-", ipstr);
             if (strcmp(ipstr, client_ip) != 0) {
               err_log(url, "Client IP doesn't match signature.");
               goto deny;
             }
             break;
           case AF_INET6:
-            TSDebug(PLUGIN_NAME, "ip->sa_family: AF_INET6");
+            Dbg(dbg_ctl, "ip->sa_family: AF_INET6");
             has_path_params == false ? (pp = strstr(cp, "&")) : (pp = strstr(cp, ";"));
             if ((pp - cp) > INET6_ADDRSTRLEN - 1 || (pp - cp) < 4) {
               err_log(url, "IP address string too long or short.");
@@ -670,9 +672,9 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo *rri)
             }
             strncpy(client_ip, cp, (pp - cp));
             client_ip[pp - cp] = '\0';
-            TSDebug(PLUGIN_NAME, "CIP: -%s-", client_ip);
+            Dbg(dbg_ctl, "CIP: -%s-", client_ip);
             inet_ntop(AF_INET6, &(((struct sockaddr_in6 *)ip)->sin6_addr), ipstr, sizeof ipstr);
-            TSDebug(PLUGIN_NAME, "Peer address: -%s-", ipstr);
+            Dbg(dbg_ctl, "Peer address: -%s-", ipstr);
             if (strcmp(ipstr, client_ip) != 0) {
               err_log(url, "Client IP doesn't match signature.");
               goto deny;
@@ -695,7 +697,7 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo *rri)
             err_log(url, "Invalid expiration, or expired");
             goto deny;
           }
-          TSDebug(PLUGIN_NAME, "Exp: %" PRIu64, expiration);
+          Dbg(dbg_ctl, "Exp: %" PRIu64, expiration);
         } else {
           err_log(url, "Expiration query string not found");
           goto deny;
@@ -707,7 +709,7 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo *rri)
         cp        += strlen(ALG_QSTRING) + 1;
         algorithm  = atoi(cp);
         // The check for a valid algorithm is later.
-        TSDebug(PLUGIN_NAME, "Algorithm: %d", algorithm);
+        Dbg(dbg_ctl, "Algorithm: %d", algorithm);
       } else {
         err_log(url, "Algorithm query string not found");
         goto deny;
@@ -721,7 +723,7 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo *rri)
           err_log(url, "Invalid key index");
           goto deny;
         }
-        TSDebug(PLUGIN_NAME, "Key Index: %d", keyindex);
+        Dbg(dbg_ctl, "Key Index: %d", keyindex);
       } else {
         err_log(url, "KeyIndex query string not found");
         goto deny;
@@ -736,9 +738,9 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo *rri)
           parts  = cp; // NOTE parts is not null terminated it is terminated by "&" of next param
           has_path_params == false ? (cp = strstr(parts, "&")) : (cp = strstr(parts, ";"));
           if (cp) {
-            TSDebug(PLUGIN_NAME, "Parts: %.*s", (int)(cp - parts), parts);
+            Dbg(dbg_ctl, "Parts: %.*s", (int)(cp - parts), parts);
           } else {
-            TSDebug(PLUGIN_NAME, "Parts: %s", parts);
+            Dbg(dbg_ctl, "Parts: %s", parts);
           }
         } else {
           err_log(url, "PartsSigned query string not found");
@@ -764,8 +766,8 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo *rri)
           }
 
           /* have the query string, and parameters passed initial checks */
-          TSDebug(PLUGIN_NAME, "Found all needed parameters: C=%s E=%" PRIu64 " A=%d K=%d P=%s S=%s", client_ip, expiration,
-                  algorithm, keyindex, parts, signature);
+          Dbg(dbg_ctl, "Found all needed parameters: C=%s E=%" PRIu64 " A=%d K=%d P=%s S=%s", client_ip, expiration, algorithm,
+              keyindex, parts, signature);
 
           /* find the string that was signed - cycle through the parts letters, adding the part of the fqdn/path if it is 1 */
           has_path_params == false ? (cp = strchr(url, '?')) : (cp = strchr(url, ';'));
@@ -796,10 +798,10 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo *rri)
             // chop off the last /, replace with '?' or ';' as appropriate.
             has_path_params == false ? (signed_part[strlen(signed_part) - 1] = '?') : (signed_part[strlen(signed_part) - 1] = '\0');
             cp = strstr(query, SIG_QSTRING "=");
-            TSDebug(PLUGIN_NAME, "cp: %s, query: %s, signed_part: %s", cp, query, signed_part);
+            Dbg(dbg_ctl, "cp: %s, query: %s, signed_part: %s", cp, query, signed_part);
             strncat(signed_part, query, (cp - query) + strlen(SIG_QSTRING) + 1);
 
-            TSDebug(PLUGIN_NAME, "Signed string=\"%s\"", signed_part);
+            Dbg(dbg_ctl, "Signed string=\"%s\"", signed_part);
 
             /* calculate the expected the signature with the right algorithm */
             switch (algorithm) {
@@ -807,7 +809,7 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo *rri)
               HMAC(EVP_sha1(), (const unsigned char *)cfg->keys[keyindex], strlen(cfg->keys[keyindex]),
                    (const unsigned char *)signed_part, strlen(signed_part), sig, &sig_len);
               if (sig_len != SHA1_SIG_SIZE) {
-                TSDebug(PLUGIN_NAME, "sig_len: %d", sig_len);
+                Dbg(dbg_ctl, "sig_len: %d", sig_len);
                 err_log(url, "Calculated sig len !=  SHA1_SIG_SIZE !");
                 goto deny;
               }
@@ -817,7 +819,7 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo *rri)
               HMAC(EVP_md5(), (const unsigned char *)cfg->keys[keyindex], strlen(cfg->keys[keyindex]),
                    (const unsigned char *)signed_part, strlen(signed_part), sig, &sig_len);
               if (sig_len != MD5_SIG_SIZE) {
-                TSDebug(PLUGIN_NAME, "sig_len: %d", sig_len);
+                Dbg(dbg_ctl, "sig_len: %d", sig_len);
                 err_log(url, "Calculated sig len !=  MD5_SIG_SIZE !");
                 goto deny;
               }
@@ -831,7 +833,7 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo *rri)
               snprintf(&(sig_string[i * 2]), sizeof(sig_string) - (i * 2), "%02x", sig[i]);
             }
 
-            TSDebug(PLUGIN_NAME, "Expected signature: %s", sig_string);
+            Dbg(dbg_ctl, "Expected signature: %s", sig_string);
 
             /* and compare to signature that was sent */
             cmp_res = strncmp(sig_string, signature, sig_len * 2);
@@ -839,7 +841,7 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo *rri)
               err_log(url, "Signature check failed");
               goto deny;
             } else {
-              TSDebug(PLUGIN_NAME, "Signature check passed");
+              Dbg(dbg_ctl, "Signature check passed");
               goto allow;
             }
           }
@@ -857,7 +859,7 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo *rri)
 
   switch (cfg->err_status) {
   case TS_HTTP_STATUS_MOVED_TEMPORARILY:
-    TSDebug(PLUGIN_NAME, "Redirecting to %s", cfg->err_url);
+    Dbg(dbg_ctl, "Redirecting to %s", cfg->err_url);
     char *start, *end;
     start = cfg->err_url;
     end   = start + strlen(cfg->err_url);
@@ -887,7 +889,7 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo *rri)
     current_query++;
     app_qry = getAppQueryString(current_query, strlen(current_query));
   }
-  TSDebug(PLUGIN_NAME, "has_path_params: %d", has_path_params);
+  Dbg(dbg_ctl, "has_path_params: %d", has_path_params);
   if (has_path_params) {
     if (*new_path) {
       TSUrlPathSet(rri->requestBufp, rri->requestUrl, new_path, strlen(new_path));
diff --git a/plugins/experimental/wasm/ats_context.cc b/plugins/experimental/wasm/ats_context.cc
index 63a44e0f7cd..1478a4da733 100644
--- a/plugins/experimental/wasm/ats_context.cc
+++ b/plugins/experimental/wasm/ats_context.cc
@@ -34,6 +34,8 @@
 namespace ats_wasm
 {
 
+DbgCtl dbg_ctl{WASM_DEBUG_TAG};
+
 static int
 async_handler(TSCont cont, TSEvent event, void *edata)
 {
@@ -68,8 +70,7 @@ async_handler(TSCont cont, TSEvent event, void *edata)
         header_size         = TSMimeHdrFieldsCount(hdr_buf, hdr_loc);
         body                = data_start; // data_start will now be pointing to body
         body_size           = data_end - data_start;
-        TSDebug(WASM_DEBUG_TAG, "[%s] Fetch result had a status code of %d with a body length of %ld", __FUNCTION__, status,
-                body_size);
+        Dbg(dbg_ctl, "[%s] Fetch result had a status code of %d with a body length of %ld", __FUNCTION__, status, body_size);
       } else {
         TSError("[wasm][%s] Unable to parse call response", __FUNCTION__);
         event = static_cast<TSEvent>(FETCH_EVENT_ID_BASE + 1);
@@ -83,11 +84,11 @@ async_handler(TSCont cont, TSEvent event, void *edata)
   }
 
   // callback function
-  TSDebug(WASM_DEBUG_TAG, "[%s] setting root context call result", __FUNCTION__);
+  Dbg(dbg_ctl, "[%s] setting root context call result", __FUNCTION__);
   root_context->setHttpCallResult(hdr_buf, hdr_loc, body, body_size, result);
-  TSDebug(WASM_DEBUG_TAG, "[%s] trigger root context function, token:  %d", __FUNCTION__, token);
+  Dbg(dbg_ctl, "[%s] trigger root context function, token:  %d", __FUNCTION__, token);
   root_context->onHttpCallResponse(token, header_size, body_size, 0);
-  TSDebug(WASM_DEBUG_TAG, "[%s] resetting root context call result", __FUNCTION__);
+  Dbg(dbg_ctl, "[%s] resetting root context call result", __FUNCTION__);
   root_context->resetHttpCallResult();
 
   // cleaning up
@@ -101,7 +102,7 @@ async_handler(TSCont cont, TSEvent event, void *edata)
 
   TSMutexUnlock(wasm->mutex());
 
-  TSDebug(WASM_DEBUG_TAG, "[%s] delete async info and continuation", __FUNCTION__);
+  Dbg(dbg_ctl, "[%s] delete async info and continuation", __FUNCTION__);
   // delete the Async Info
   delete ai;
   // delete continuation
@@ -126,7 +127,7 @@ print_address(struct sockaddr const *ip, std::string *result)
       inet_ntop(AF_INET6, &s_sockaddr_in6->sin6_addr, cip, sizeof(cip));
       port = s_sockaddr_in6->sin6_port;
     }
-    TSDebug(WASM_DEBUG_TAG, "[%s] property retrieval - address: %.*s", __FUNCTION__, static_cast<int>(sizeof(cip)), cip);
+    Dbg(dbg_ctl, "[%s] property retrieval - address: %.*s", __FUNCTION__, static_cast<int>(sizeof(cip)), cip);
     std::string cip_str(cip);
     result->assign(cip_str + ":" + std::to_string(port));
   } else {
@@ -146,7 +147,7 @@ print_port(struct sockaddr const *ip, std::string *result)
       const auto *s_sockaddr_in6 = reinterpret_cast<const struct sockaddr_in6 *>(ip);
       port                       = s_sockaddr_in6->sin6_port;
     }
-    TSDebug(WASM_DEBUG_TAG, "[%s] looking for source port: %d", __FUNCTION__, static_cast<int>(port));
+    Dbg(dbg_ctl, "[%s] looking for source port: %d", __FUNCTION__, static_cast<int>(port));
     result->assign(reinterpret_cast<const char *>(&port), sizeof(int64_t));
   } else {
     *result = pv_empty;
@@ -172,7 +173,7 @@ print_certificate(std::string *result, X509_NAME *name)
     char *ptr   = nullptr;
     len         = BIO_get_mem_data(bio, &ptr);
     result->assign(ptr, len);
-    TSDebug(WASM_DEBUG_TAG, "print SSL certificate %.*s", static_cast<int>(len), ptr);
+    Dbg(dbg_ctl, "print SSL certificate %.*s", static_cast<int>(len), ptr);
   }
 
   BIO_free(bio);
@@ -443,28 +444,22 @@ Context::log(uint32_t level, std::string_view message)
   auto l = static_cast<LogLevel>(level);
   switch (l) {
   case LogLevel::trace:
-    TSDebug(WASM_DEBUG_TAG, "wasm trace log%s: %.*s", std::string(log_prefix()).c_str(), static_cast<int>(message.size()),
-            message.data());
+    Dbg(dbg_ctl, "wasm trace log%s: %.*s", std::string(log_prefix()).c_str(), static_cast<int>(message.size()), message.data());
     return WasmResult::Ok;
   case LogLevel::debug:
-    TSDebug(WASM_DEBUG_TAG, "wasm debug log%s: %.*s", std::string(log_prefix()).c_str(), static_cast<int>(message.size()),
-            message.data());
+    Dbg(dbg_ctl, "wasm debug log%s: %.*s", std::string(log_prefix()).c_str(), static_cast<int>(message.size()), message.data());
     return WasmResult::Ok;
   case LogLevel::info:
-    TSDebug(WASM_DEBUG_TAG, "wasm info log%s: %.*s", std::string(log_prefix()).c_str(), static_cast<int>(message.size()),
-            message.data());
+    Dbg(dbg_ctl, "wasm info log%s: %.*s", std::string(log_prefix()).c_str(), static_cast<int>(message.size()), message.data());
     return WasmResult::Ok;
   case LogLevel::warn:
-    TSDebug(WASM_DEBUG_TAG, "wasm warn log%s: %.*s", std::string(log_prefix()).c_str(), static_cast<int>(message.size()),
-            message.data());
+    Dbg(dbg_ctl, "wasm warn log%s: %.*s", std::string(log_prefix()).c_str(), static_cast<int>(message.size()), message.data());
     return WasmResult::Ok;
   case LogLevel::error:
-    TSDebug(WASM_DEBUG_TAG, "wasm error log%s: %.*s", std::string(log_prefix()).c_str(), static_cast<int>(message.size()),
-            message.data());
+    Dbg(dbg_ctl, "wasm error log%s: %.*s", std::string(log_prefix()).c_str(), static_cast<int>(message.size()), message.data());
     return WasmResult::Ok;
   case LogLevel::critical:
-    TSDebug(WASM_DEBUG_TAG, "wasm critical log%s: %.*s", std::string(log_prefix()).c_str(), static_cast<int>(message.size()),
-            message.data());
+    Dbg(dbg_ctl, "wasm critical log%s: %.*s", std::string(log_prefix()).c_str(), static_cast<int>(message.size()), message.data());
     return WasmResult::Ok;
   default: // e.g. off
     return unimplemented();
@@ -497,10 +492,10 @@ Context::setTimerPeriod(std::chrono::milliseconds period, uint32_t *timer_token_
   Context *root_context = this->root_context();
   TSMutexLock(wasm->mutex());
   if (!wasm->existsTimerPeriod(root_context->id())) {
-    TSDebug(WASM_DEBUG_TAG, "[%s] no previous timer period set", __FUNCTION__);
+    Dbg(dbg_ctl, "[%s] no previous timer period set", __FUNCTION__);
     TSCont contp = root_context->scheduler_cont();
     if (contp != nullptr) {
-      TSDebug(WASM_DEBUG_TAG, "[%s] scheduling continuation for timer", __FUNCTION__);
+      Dbg(dbg_ctl, "[%s] scheduling continuation for timer", __FUNCTION__);
       TSContDataSet(contp, root_context);
       TSContScheduleOnPool(contp, static_cast<TSHRTime>(period.count()), TS_THREAD_POOL_NET);
     }
@@ -620,7 +615,7 @@ Context::defineMetric(uint32_t metric_type, std::string_view name, uint32_t *met
 
   if (TSStatFindName(name.data(), &idp) == TS_ERROR) {
     idp = TSStatCreate(name.data(), TS_RECORDDATATYPE_INT, TS_STAT_PERSISTENT, ats_metric_type);
-    TSDebug(WASM_DEBUG_TAG, "[%s] creating stat: %.*s", __FUNCTION__, static_cast<int>(name.size()), name.data());
+    Dbg(dbg_ctl, "[%s] creating stat: %.*s", __FUNCTION__, static_cast<int>(name.size()), name.data());
     *metric_id_ptr = idp;
   } else {
     TSError("[wasm][%s] Metric already exists", __FUNCTION__);
@@ -657,22 +652,19 @@ Context::getProperty(std::string_view path, std::string *result)
 {
   if (path.substr(0, p_plugin_root_id.size()) == p_plugin_root_id) {
     *result = this->plugin_->root_id_;
-    TSDebug(WASM_DEBUG_TAG, "[%s] looking for plugin_root_id: %.*s", __FUNCTION__, static_cast<int>((*result).size()),
-            (*result).data());
+    Dbg(dbg_ctl, "[%s] looking for plugin_root_id: %.*s", __FUNCTION__, static_cast<int>((*result).size()), (*result).data());
     return WasmResult::Ok;
   } else if (path.substr(0, p_plugin_name.size()) == p_plugin_name) {
     *result = this->plugin_->name_;
-    TSDebug(WASM_DEBUG_TAG, "[%s] looking for plugin_name: %.*s", __FUNCTION__, static_cast<int>((*result).size()),
-            (*result).data());
+    Dbg(dbg_ctl, "[%s] looking for plugin_name: %.*s", __FUNCTION__, static_cast<int>((*result).size()), (*result).data());
     return WasmResult::Ok;
   } else if (path.substr(0, p_plugin_vm_id.size()) == p_plugin_vm_id) {
     *result = this->plugin_->vm_id_;
-    TSDebug(WASM_DEBUG_TAG, "[%s] looking for plugin_vm_id: %.*s", __FUNCTION__, static_cast<int>((*result).size()),
-            (*result).data());
+    Dbg(dbg_ctl, "[%s] looking for plugin_vm_id: %.*s", __FUNCTION__, static_cast<int>((*result).size()), (*result).data());
     return WasmResult::Ok;
   } else if (path.substr(0, p_node.size()) == p_node) {
     *result = pv_empty;
-    TSDebug(WASM_DEBUG_TAG, "[%s] looking for node property: empty string for now", __FUNCTION__);
+    Dbg(dbg_ctl, "[%s] looking for node property: empty string for now", __FUNCTION__);
     return WasmResult::Ok;
   } else if (path.substr(0, p_source_address.size()) == p_source_address) {
     if (txnp_ == nullptr) {
@@ -1122,7 +1114,7 @@ Context::getProperty(std::string_view path, std::string *result)
             }
           }
         }
-        TSDebug(WASM_DEBUG_TAG, "[%s] request host value(%d): %.*s", __FUNCTION__, host_len, host_len, host);
+        Dbg(dbg_ctl, "[%s] request host value(%d): %.*s", __FUNCTION__, host_len, host_len, host);
         result->assign(host, host_len);
         TSHandleMLocRelease(bufp, hdr_loc, url_loc);
       } else {
@@ -1327,7 +1319,7 @@ Context::getProperty(std::string_view path, std::string *result)
     return WasmResult::Ok;
   } else {
     *result = pv_empty;
-    TSDebug(WASM_DEBUG_TAG, "[%s] looking for unknown property: empty string", __FUNCTION__);
+    Dbg(dbg_ctl, "[%s] looking for unknown property: empty string", __FUNCTION__);
     return WasmResult::Ok;
   }
 }
@@ -1460,7 +1452,7 @@ Context::continueStream(WasmStreamType /* stream_type */)
     TSError("[wasm][%s] Can't continue stream without a transaction", __FUNCTION__);
     return WasmResult::InternalFailure;
   } else {
-    TSDebug(WASM_DEBUG_TAG, "[%s] continuing txn for context %d", __FUNCTION__, id());
+    Dbg(dbg_ctl, "[%s] continuing txn for context %d", __FUNCTION__, id());
     reenable_txn_ = true;
     TSHttpTxnReenable(txnp_, TS_EVENT_HTTP_CONTINUE);
     return WasmResult::Ok;
@@ -1479,7 +1471,7 @@ Context::closeStream(WasmStreamType /* stream_type */)
     TSError("[wasm][%s] Can't continue stream without a transaction", __FUNCTION__);
     return WasmResult::InternalFailure;
   } else {
-    TSDebug(WASM_DEBUG_TAG, "[%s] continue txn for context %d with error", __FUNCTION__, id());
+    Dbg(dbg_ctl, "[%s] continue txn for context %d with error", __FUNCTION__, id());
     reenable_txn_ = true;
     TSHttpTxnReenable(txnp_, TS_EVENT_HTTP_ERROR);
     return WasmResult::Ok;
diff --git a/plugins/experimental/wasm/ats_context.h b/plugins/experimental/wasm/ats_context.h
index 96a8a7b9c5e..811e1e17f13 100644
--- a/plugins/experimental/wasm/ats_context.h
+++ b/plugins/experimental/wasm/ats_context.h
@@ -117,6 +117,8 @@ constexpr std::string_view pv_http10 = {"HTTP/1.0", 8};
 constexpr std::string_view pv_http11 = {"HTTP/1.1", 8};
 constexpr std::string_view pv_empty  = {"", 0};
 
+extern DbgCtl dbg_ctl;
+
 // local struct representing the transaction header
 struct HeaderMap {
   TSMBuffer bufp{nullptr};
diff --git a/plugins/experimental/wasm/ats_wasm.cc b/plugins/experimental/wasm/ats_wasm.cc
index 9cd277f22e5..2188f3e79c8 100644
--- a/plugins/experimental/wasm/ats_wasm.cc
+++ b/plugins/experimental/wasm/ats_wasm.cc
@@ -26,7 +26,7 @@ namespace ats_wasm
 proxy_wasm::LogLevel
 ATSWasmVmIntegration::getLogLevel()
 {
-  if (TSIsDebugTagSet(WASM_DEBUG_TAG)) {
+  if (dbg_ctl.on()) {
     return proxy_wasm::LogLevel::debug;
   } else {
     return proxy_wasm::LogLevel::error;
@@ -42,7 +42,7 @@ ATSWasmVmIntegration::error(std::string_view message)
 void
 ATSWasmVmIntegration::trace(std::string_view message)
 {
-  TSDebug(WASM_DEBUG_TAG, "%.*s", static_cast<int>(message.size()), message.data());
+  Dbg(dbg_ctl, "%.*s", static_cast<int>(message.size()), message.data());
 }
 
 bool
@@ -83,7 +83,7 @@ Wasm::createVmContext()
 ContextBase *
 Wasm::createRootContext(const std::shared_ptr<PluginBase> &plugin)
 {
-  TSDebug(WASM_DEBUG_TAG, "Create root context for ats plugin");
+  Dbg(dbg_ctl, "Create root context for ats plugin");
   return new Context(this, plugin);
 }
 
diff --git a/plugins/experimental/wasm/wasm_main.cc b/plugins/experimental/wasm/wasm_main.cc
index ddcba2b7bb3..65e0d2f873b 100644
--- a/plugins/experimental/wasm/wasm_main.cc
+++ b/plugins/experimental/wasm/wasm_main.cc
@@ -62,7 +62,7 @@ transform_handler(TSCont contp, ats_wasm::TransformInfo *ti)
 
   ats_wasm::Context *c;
 
-  TSDebug(WASM_DEBUG_TAG, "[%s] transform handler begins", __FUNCTION__);
+  Dbg(dbg_ctl, "[%s] transform handler begins", __FUNCTION__);
   c = ti->context;
 
   output_conn = TSTransformOutputVConnGet(contp);
@@ -70,15 +70,15 @@ transform_handler(TSCont contp, ats_wasm::TransformInfo *ti)
 
   empty_input = false;
 
-  TSDebug(WASM_DEBUG_TAG, "[%s] cheking input VIO", __FUNCTION__);
+  Dbg(dbg_ctl, "[%s] cheking input VIO", __FUNCTION__);
   if (!TSVIOBufferGet(input_vio)) {
     if (ti->output_vio) {
-      TSDebug(WASM_DEBUG_TAG, "[%s] reenabling output VIO after input VIO does not exist", __FUNCTION__);
+      Dbg(dbg_ctl, "[%s] reenabling output VIO after input VIO does not exist", __FUNCTION__);
       TSVIONBytesSet(ti->output_vio, ti->total);
       TSVIOReenable(ti->output_vio);
       return 0;
     } else {
-      TSDebug(WASM_DEBUG_TAG, "[%s] no input VIO and output VIO", __FUNCTION__);
+      Dbg(dbg_ctl, "[%s] no input VIO and output VIO", __FUNCTION__);
       empty_input = true;
     }
   }
@@ -87,7 +87,7 @@ transform_handler(TSCont contp, ats_wasm::TransformInfo *ti)
     input_reader = TSVIOReaderGet(input_vio);
   }
 
-  TSDebug(WASM_DEBUG_TAG, "[%s] creating buffer and reader", __FUNCTION__);
+  Dbg(dbg_ctl, "[%s] creating buffer and reader", __FUNCTION__);
   if (!ti->output_buffer) {
     ti->output_buffer = TSIOBufferCreate();
     ti->output_reader = TSIOBufferReaderAlloc(ti->output_buffer);
@@ -104,7 +104,7 @@ transform_handler(TSCont contp, ats_wasm::TransformInfo *ti)
     ti->downstream_bytes = INT64_MAX;
   }
 
-  TSDebug(WASM_DEBUG_TAG, "[%s] init variables inside handler", __FUNCTION__);
+  Dbg(dbg_ctl, "[%s] init variables inside handler", __FUNCTION__);
   if (!empty_input) {
     input_avail   = TSIOBufferReaderAvail(input_reader);
     upstream_done = TSVIONDoneGet(input_vio);
@@ -139,14 +139,14 @@ transform_handler(TSCont contp, ats_wasm::TransformInfo *ti)
   }
 
   do {
-    TSDebug(WASM_DEBUG_TAG, "[%s] inside transform handler loop", __FUNCTION__);
+    Dbg(dbg_ctl, "[%s] inside transform handler loop", __FUNCTION__);
     proxy_wasm::FilterDataStatus status = proxy_wasm::FilterDataStatus::Continue;
 
     if (towrite == 0 && !empty_input) {
       break;
     }
 
-    TSDebug(WASM_DEBUG_TAG, "[%s] retrieving text and calling the wasm handler function", __FUNCTION__);
+    Dbg(dbg_ctl, "[%s] retrieving text and calling the wasm handler function", __FUNCTION__);
     if (!empty_input) {
       blk   = TSIOBufferReaderStart(ti->reserved_reader);
       start = TSIOBufferBlockReadStart(blk, ti->reserved_reader, &blk_len);
@@ -186,7 +186,7 @@ transform_handler(TSCont contp, ats_wasm::TransformInfo *ti)
       }
     }
 
-    TSDebug(WASM_DEBUG_TAG, "[%s] retrieving returns from wasm handler function and pass back to ATS", __FUNCTION__);
+    Dbg(dbg_ctl, "[%s] retrieving returns from wasm handler function and pass back to ATS", __FUNCTION__);
     if ((status == proxy_wasm::FilterDataStatus::Continue) ||
         ((status == proxy_wasm::FilterDataStatus::StopIterationAndBuffer ||
           status == proxy_wasm::FilterDataStatus::StopIterationAndWatermark) &&
@@ -261,30 +261,30 @@ transform_entry(TSCont contp, TSEvent ev, void *edata)
   event = (int)ev;
   ti    = (ats_wasm::TransformInfo *)TSContDataGet(contp);
 
-  TSDebug(WASM_DEBUG_TAG, "[%s] begin transform entry", __FUNCTION__);
+  Dbg(dbg_ctl, "[%s] begin transform entry", __FUNCTION__);
   if (TSVConnClosedGet(contp)) {
     delete ti;
     TSContDestroy(contp);
     return 0;
   }
 
-  TSDebug(WASM_DEBUG_TAG, "[%s] checking event inside transform entry", __FUNCTION__);
+  Dbg(dbg_ctl, "[%s] checking event inside transform entry", __FUNCTION__);
   switch (event) {
   case TS_EVENT_ERROR:
-    TSDebug(WASM_DEBUG_TAG, "[%s] event error", __FUNCTION__);
+    Dbg(dbg_ctl, "[%s] event error", __FUNCTION__);
     input_vio = TSVConnWriteVIOGet(contp);
     TSContCall(TSVIOContGet(input_vio), TS_EVENT_ERROR, input_vio);
     break;
 
   // we should handle TS_EVENT_VCONN_EOS similarly here if we support setting EOS from wasm module
   case TS_EVENT_VCONN_WRITE_COMPLETE:
-    TSDebug(WASM_DEBUG_TAG, "[%s] event vconn write complete", __FUNCTION__);
+    Dbg(dbg_ctl, "[%s] event vconn write complete", __FUNCTION__);
     TSVConnShutdown(TSTransformOutputVConnGet(contp), 0, 1);
     break;
 
   case TS_EVENT_VCONN_WRITE_READY:
   default:
-    TSDebug(WASM_DEBUG_TAG, "[%s] event vconn write ready/default", __FUNCTION__);
+    Dbg(dbg_ctl, "[%s] event vconn write ready/default", __FUNCTION__);
     transform_handler(contp, ti);
     break;
   }
@@ -296,7 +296,7 @@ transform_entry(TSCont contp, TSEvent ev, void *edata)
 static int
 schedule_handler(TSCont contp, TSEvent /*event*/, void * /*data*/)
 {
-  TSDebug(WASM_DEBUG_TAG, "[%s] Inside schedule_handler", __FUNCTION__);
+  Dbg(dbg_ctl, "[%s] Inside schedule_handler", __FUNCTION__);
 
   auto *c = static_cast<ats_wasm::Context *>(TSContDataGet(contp));
 
@@ -319,11 +319,11 @@ schedule_handler(TSCont contp, TSEvent /*event*/, void * /*data*/)
       auto *wasm               = static_cast<ats_wasm::Wasm *>(c->wasm());
       uint32_t root_context_id = c->id();
       if (wasm->existsTimerPeriod(root_context_id)) {
-        TSDebug(WASM_DEBUG_TAG, "[%s] reschedule continuation", __FUNCTION__);
+        Dbg(dbg_ctl, "[%s] reschedule continuation", __FUNCTION__);
         std::chrono::milliseconds period = wasm->getTimerPeriod(root_context_id);
         TSContScheduleOnPool(contp, static_cast<TSHRTime>(period.count()), TS_THREAD_POOL_NET);
       } else {
-        TSDebug(WASM_DEBUG_TAG, "[%s] can't find period for root context id: %d", __FUNCTION__, root_context_id);
+        Dbg(dbg_ctl, "[%s] can't find period for root context id: %d", __FUNCTION__, root_context_id);
       }
       break;
     }
@@ -335,30 +335,30 @@ schedule_handler(TSCont contp, TSEvent /*event*/, void * /*data*/)
     old_wasm->removeTimerPeriod(root_context_id);
 
     if (old_wasm->readyShutdown()) {
-      TSDebug(WASM_DEBUG_TAG, "[%s] starting WasmBase Shutdown", __FUNCTION__);
+      Dbg(dbg_ctl, "[%s] starting WasmBase Shutdown", __FUNCTION__);
       old_wasm->startShutdown();
       if (!old_wasm->readyDelete()) {
-        TSDebug(WASM_DEBUG_TAG, "[%s] not ready to delete WasmBase/PluginBase", __FUNCTION__);
+        Dbg(dbg_ctl, "[%s] not ready to delete WasmBase/PluginBase", __FUNCTION__);
       } else {
-        TSDebug(WASM_DEBUG_TAG, "[%s] remove wasm from deleted_configs", __FUNCTION__);
+        Dbg(dbg_ctl, "[%s] remove wasm from deleted_configs", __FUNCTION__);
         bool advance = true;
         for (auto it = wasm_config->deleted_configs.begin(); it != wasm_config->deleted_configs.end(); advance ? it++ : it) {
           advance = true;
-          TSDebug(WASM_DEBUG_TAG, "[%s] looping through deleted_configs", __FUNCTION__);
+          Dbg(dbg_ctl, "[%s] looping through deleted_configs", __FUNCTION__);
           std::shared_ptr<ats_wasm::Wasm> wbp = it->first;
           temp                                = wbp;
           if (wbp.get() == old_wasm) {
-            TSDebug(WASM_DEBUG_TAG, "[%s] found matching WasmBase", __FUNCTION__);
+            Dbg(dbg_ctl, "[%s] found matching WasmBase", __FUNCTION__);
             it      = wasm_config->deleted_configs.erase(it);
             advance = false;
           }
         }
       }
     } else {
-      TSDebug(WASM_DEBUG_TAG, "[%s] not ready to shutdown WasmBase", __FUNCTION__);
+      Dbg(dbg_ctl, "[%s] not ready to shutdown WasmBase", __FUNCTION__);
     }
 
-    TSDebug(WASM_DEBUG_TAG, "[%s] config wasm has changed. thus not scheduling", __FUNCTION__);
+    Dbg(dbg_ctl, "[%s] config wasm has changed. thus not scheduling", __FUNCTION__);
   }
 
   TSMutexUnlock(old_wasm->mutex());
@@ -453,33 +453,33 @@ http_event_handler(TSCont contp, TSEvent event, void *data)
     }
 
     if (found) {
-      TSDebug(WASM_DEBUG_TAG, "[%s] config wasm has not changed", __FUNCTION__);
+      Dbg(dbg_ctl, "[%s] config wasm has not changed", __FUNCTION__);
     } else {
       if (old_wasm->readyShutdown()) {
-        TSDebug(WASM_DEBUG_TAG, "[%s] starting WasmBase Shutdown", __FUNCTION__);
+        Dbg(dbg_ctl, "[%s] starting WasmBase Shutdown", __FUNCTION__);
         old_wasm->startShutdown();
         if (!old_wasm->readyDelete()) {
-          TSDebug(WASM_DEBUG_TAG, "[%s] not ready to delete WasmBase/PluginBase", __FUNCTION__);
+          Dbg(dbg_ctl, "[%s] not ready to delete WasmBase/PluginBase", __FUNCTION__);
         } else {
-          TSDebug(WASM_DEBUG_TAG, "[%s] remove wasm from deleted_configs", __FUNCTION__);
+          Dbg(dbg_ctl, "[%s] remove wasm from deleted_configs", __FUNCTION__);
           bool advance = true;
           for (auto it = wasm_config->deleted_configs.begin(); it != wasm_config->deleted_configs.end(); advance ? it++ : it) {
             advance = true;
-            TSDebug(WASM_DEBUG_TAG, "[%s] looping through deleted_configs", __FUNCTION__);
+            Dbg(dbg_ctl, "[%s] looping through deleted_configs", __FUNCTION__);
             std::shared_ptr<ats_wasm::Wasm> wbp = it->first;
             temp                                = wbp;
             if (wbp.get() == old_wasm) {
-              TSDebug(WASM_DEBUG_TAG, "[%s] found matching WasmBase", __FUNCTION__);
+              Dbg(dbg_ctl, "[%s] found matching WasmBase", __FUNCTION__);
               it      = wasm_config->deleted_configs.erase(it);
               advance = false;
             }
           }
         }
       } else {
-        TSDebug(WASM_DEBUG_TAG, "[%s] not ready to shutdown WasmBase", __FUNCTION__);
+        Dbg(dbg_ctl, "[%s] not ready to shutdown WasmBase", __FUNCTION__);
       }
 
-      TSDebug(WASM_DEBUG_TAG, "[%s] config wasm has changed", __FUNCTION__);
+      Dbg(dbg_ctl, "[%s] config wasm has changed", __FUNCTION__);
     }
 
     delete context;
@@ -496,7 +496,7 @@ http_event_handler(TSCont contp, TSEvent event, void *data)
 
   // check if we have reenable transaction already or not
   if ((context == nullptr) || (!context->isTxnReenable())) {
-    TSDebug(WASM_DEBUG_TAG, "[%s] no context or not yet reenabled transaction", __FUNCTION__);
+    Dbg(dbg_ctl, "[%s] no context or not yet reenabled transaction", __FUNCTION__);
 
     if (result == 0) {
       TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
@@ -504,24 +504,24 @@ http_event_handler(TSCont contp, TSEvent event, void *data)
         context->setTxnReenable();
       }
     } else if (result < 0) {
-      TSDebug(WASM_DEBUG_TAG, "[%s] abnormal event, continue with error", __FUNCTION__);
+      Dbg(dbg_ctl, "[%s] abnormal event, continue with error", __FUNCTION__);
       TSHttpTxnReenable(txnp, TS_EVENT_HTTP_ERROR);
       if (context != nullptr) {
         context->setTxnReenable();
       }
     } else {
       if (context->isLocalReply()) {
-        TSDebug(WASM_DEBUG_TAG, "[%s] abnormal return, continue with error due to local reply", __FUNCTION__);
+        Dbg(dbg_ctl, "[%s] abnormal return, continue with error due to local reply", __FUNCTION__);
         TSHttpTxnReenable(txnp, TS_EVENT_HTTP_ERROR);
         if (context != nullptr) {
           context->setTxnReenable();
         }
       } else {
-        TSDebug(WASM_DEBUG_TAG, "[%s] abnormal return, no continue, context id: %d", __FUNCTION__, context->id());
+        Dbg(dbg_ctl, "[%s] abnormal return, no continue, context id: %d", __FUNCTION__, context->id());
       }
     }
   } else {
-    TSDebug(WASM_DEBUG_TAG, "[%s] transaction already reenabled", __FUNCTION__);
+    Dbg(dbg_ctl, "[%s] transaction already reenabled", __FUNCTION__);
   }
   return 0;
 }
@@ -553,7 +553,7 @@ global_hook_handler(TSCont /*contp*/, TSEvent /*event*/, void *data)
     TSContDataSet(txn_contp, context);
 
     // create transform items
-    TSDebug(WASM_DEBUG_TAG, "[%s] creating transform info, continuation and hook", __FUNCTION__);
+    Dbg(dbg_ctl, "[%s] creating transform info, continuation and hook", __FUNCTION__);
     ats_wasm::TransformInfo *reqbody_ti  = new ats_wasm::TransformInfo();
     reqbody_ti->request                  = true;
     reqbody_ti->context                  = context;
@@ -834,18 +834,18 @@ read_configuration()
     std::shared_ptr<proxy_wasm::PluginBase> old_plugin = it->second;
 
     if (old_wasm != nullptr) {
-      TSDebug(WASM_DEBUG_TAG, "[%s] previous WasmBase exists", __FUNCTION__);
+      Dbg(dbg_ctl, "[%s] previous WasmBase exists", __FUNCTION__);
       TSMutexLock(old_wasm->mutex());
       if (old_wasm->readyShutdown()) {
-        TSDebug(WASM_DEBUG_TAG, "[%s] starting WasmBase Shutdown", __FUNCTION__);
+        Dbg(dbg_ctl, "[%s] starting WasmBase Shutdown", __FUNCTION__);
         old_wasm->startShutdown();
         if (!old_wasm->readyDelete()) {
-          TSDebug(WASM_DEBUG_TAG, "[%s] not ready to delete WasmBase/PluginBase", __FUNCTION__);
+          Dbg(dbg_ctl, "[%s] not ready to delete WasmBase/PluginBase", __FUNCTION__);
           auto deleted_config = std::make_pair(old_wasm, old_plugin);
           wasm_config->deleted_configs.push_front(deleted_config);
         }
       } else {
-        TSDebug(WASM_DEBUG_TAG, "[%s] not ready to shutdown WasmBase", __FUNCTION__);
+        Dbg(dbg_ctl, "[%s] not ready to shutdown WasmBase", __FUNCTION__);
         auto deleted_config = std::make_pair(old_wasm, old_plugin);
         wasm_config->deleted_configs.push_front(deleted_config);
       }
@@ -860,9 +860,9 @@ read_configuration()
 static int
 config_handler(TSCont /*contp*/, TSEvent /*event*/, void * /*data*/)
 {
-  TSDebug(WASM_DEBUG_TAG, "[%s] configuration reloading", __FUNCTION__);
+  Dbg(dbg_ctl, "[%s] configuration reloading", __FUNCTION__);
   read_configuration();
-  TSDebug(WASM_DEBUG_TAG, "[%s] configuration reloading ends", __FUNCTION__);
+  Dbg(dbg_ctl, "[%s] configuration reloading ends", __FUNCTION__);
   return 0;
 }
 
diff --git a/plugins/generator/generator.cc b/plugins/generator/generator.cc
index ba8b163ef6a..e8387da3420 100644
--- a/plugins/generator/generator.cc
+++ b/plugins/generator/generator.cc
@@ -63,10 +63,12 @@
 
 #define PLUGIN "generator"
 
-#define VDEBUG(fmt, ...) TSDebug(PLUGIN, fmt, ##__VA_ARGS__)
+static DbgCtl dbg_ctl{PLUGIN};
+
+#define VDEBUG(fmt, ...) Dbg(dbg_ctl, fmt, ##__VA_ARGS__)
 
 #if DEBUG
-#define VERROR(fmt, ...) TSDebug(PLUGIN, fmt, ##__VA_ARGS__)
+#define VERROR(fmt, ...) Dbg(dbg_ctl, fmt, ##__VA_ARGS__)
 #else
 #define VERROR(fmt, ...) TSError("[%s] %s: " fmt, PLUGIN, __FUNCTION__, ##__VA_ARGS__)
 #endif
diff --git a/plugins/header_rewrite/condition.h b/plugins/header_rewrite/condition.h
index 610ec879f84..9758088cde0 100644
--- a/plugins/header_rewrite/condition.h
+++ b/plugins/header_rewrite/condition.h
@@ -47,11 +47,11 @@ enum CondModifiers {
 class Condition : public Statement
 {
 public:
-  Condition() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for Condition"); }
+  Condition() { Dbg(dbg_ctl, "Calling CTOR for Condition"); }
 
   ~Condition() override
   {
-    TSDebug(PLUGIN_NAME_DBG, "Calling DTOR for Condition");
+    Dbg(dbg_ctl, "Calling DTOR for Condition");
     delete _matcher;
   }
 
diff --git a/plugins/header_rewrite/conditions.cc b/plugins/header_rewrite/conditions.cc
index d44a2cee262..c9bf0688f5d 100644
--- a/plugins/header_rewrite/conditions.cc
+++ b/plugins/header_rewrite/conditions.cc
@@ -70,7 +70,7 @@ ConditionStatus::initialize_hooks()
 bool
 ConditionStatus::eval(const Resources &res)
 {
-  TSDebug(PLUGIN_NAME, "Evaluating STATUS()");
+  Dbg(pi_dbg_ctl, "Evaluating STATUS()");
   return static_cast<MatcherType *>(_matcher)->test(res.resp_status);
 }
 
@@ -78,7 +78,7 @@ void
 ConditionStatus::append_value(std::string &s, const Resources &res)
 {
   s += std::to_string(res.resp_status);
-  TSDebug(PLUGIN_NAME, "Appending STATUS(%d) to evaluation value -> %s", res.resp_status, s.c_str());
+  Dbg(pi_dbg_ctl, "Appending STATUS(%d) to evaluation value -> %s", res.resp_status, s.c_str());
 }
 
 // ConditionMethod
@@ -100,7 +100,7 @@ ConditionMethod::eval(const Resources &res)
   std::string s;
 
   append_value(s, res);
-  TSDebug(PLUGIN_NAME, "Evaluating METHOD()");
+  Dbg(pi_dbg_ctl, "Evaluating METHOD()");
 
   return static_cast<const MatcherType *>(_matcher)->test(s);
 }
@@ -117,7 +117,7 @@ ConditionMethod::append_value(std::string &s, const Resources &res)
 
   if (bufp && hdr_loc) {
     const char *value = TSHttpHdrMethodGet(bufp, hdr_loc, &len);
-    TSDebug(PLUGIN_NAME, "Appending METHOD(%s) to evaluation value -> %.*s", _qualifier.c_str(), len, value);
+    Dbg(pi_dbg_ctl, "Appending METHOD(%s) to evaluation value -> %.*s", _qualifier.c_str(), len, value);
     s.append(value, len);
   }
 }
@@ -141,7 +141,7 @@ ConditionRandom::initialize(Parser &p)
 bool
 ConditionRandom::eval(const Resources & /* res ATS_UNUSED */)
 {
-  TSDebug(PLUGIN_NAME, "Evaluating RANDOM()");
+  Dbg(pi_dbg_ctl, "Evaluating RANDOM()");
   return static_cast<const MatcherType *>(_matcher)->test(rand_r(&_seed) % _max);
 }
 
@@ -152,7 +152,7 @@ ConditionRandom::append_value(std::string &s, const Resources & /* res ATS_UNUSE
 
   oss << rand_r(&_seed) % _max;
   s += oss.str();
-  TSDebug(PLUGIN_NAME, "Appending RANDOM(%d) to evaluation value -> %s", _max, s.c_str());
+  Dbg(pi_dbg_ctl, "Appending RANDOM(%d) to evaluation value -> %s", _max, s.c_str());
 }
 
 // ConditionAccess: access(file)
@@ -194,7 +194,7 @@ ConditionAccess::eval(const Resources & /* res ATS_UNUSED */)
     _next = tv.tv_sec; // I hope this is an atomic "set"...
     _last = check;     // This sure ought to be
   }
-  TSDebug(PLUGIN_NAME, "Evaluating ACCESS(%s) -> %d", _qualifier.c_str(), _last);
+  Dbg(pi_dbg_ctl, "Evaluating ACCESS(%s) -> %d", _qualifier.c_str(), _last);
 
   return _last;
 }
@@ -234,13 +234,13 @@ ConditionHeader::append_value(std::string &s, const Resources &res)
     TSMLoc field_loc;
 
     field_loc = TSMimeHdrFieldFind(bufp, hdr_loc, _qualifier_wks ? _qualifier_wks : _qualifier.c_str(), _qualifier.size());
-    TSDebug(PLUGIN_NAME, "Getting Header: %s, field_loc: %p", _qualifier.c_str(), field_loc);
+    Dbg(pi_dbg_ctl, "Getting Header: %s, field_loc: %p", _qualifier.c_str(), field_loc);
 
     while (field_loc) {
       const char *value     = TSMimeHdrFieldValueStringGet(bufp, hdr_loc, field_loc, -1, &len);
       TSMLoc next_field_loc = TSMimeHdrFieldNextDup(bufp, hdr_loc, field_loc);
 
-      TSDebug(PLUGIN_NAME, "Appending HEADER(%s) to evaluation value -> %.*s", _qualifier.c_str(), len, value);
+      Dbg(pi_dbg_ctl, "Appending HEADER(%s) to evaluation value -> %.*s", _qualifier.c_str(), len, value);
       s.append(value, len);
       // multiple headers with the same name must be semantically the same as one value which is comma separated
       if (next_field_loc) {
@@ -258,7 +258,7 @@ ConditionHeader::eval(const Resources &res)
   std::string s;
 
   append_value(s, res);
-  TSDebug(PLUGIN_NAME, "Evaluating HEADER()");
+  Dbg(pi_dbg_ctl, "Evaluating HEADER()");
 
   return static_cast<const MatcherType *>(_matcher)->test(s);
 }
@@ -279,7 +279,7 @@ ConditionUrl::set_qualifier(const std::string &q)
 {
   Condition::set_qualifier(q);
 
-  TSDebug(PLUGIN_NAME, "\tParsing %%{URL:%s}", q.c_str());
+  Dbg(pi_dbg_ctl, "\tParsing %%{URL:%s}", q.c_str());
   _url_qual = parse_url_qualifier(q);
 }
 
@@ -291,7 +291,7 @@ ConditionUrl::append_value(std::string &s, const Resources &res)
 
   if (_type == CLIENT) {
     // CLIENT always uses the pristine URL
-    TSDebug(PLUGIN_NAME, "   Using the pristine url");
+    Dbg(pi_dbg_ctl, "   Using the pristine url");
     if (TSHttpTxnPristineUrlGet(res.txnp, &bufp, &url) != TS_SUCCESS) {
       TSError("[%s] Error getting the pristine URL", PLUGIN_NAME);
       return;
@@ -300,13 +300,13 @@ ConditionUrl::append_value(std::string &s, const Resources &res)
     // called at the remap hook
     bufp = res._rri->requestBufp;
     if (_type == URL) {
-      TSDebug(PLUGIN_NAME, "   Using the request url");
+      Dbg(pi_dbg_ctl, "   Using the request url");
       url = res._rri->requestUrl;
     } else if (_type == FROM) {
-      TSDebug(PLUGIN_NAME, "   Using the from url");
+      Dbg(pi_dbg_ctl, "   Using the from url");
       url = res._rri->mapFromUrl;
     } else if (_type == TO) {
-      TSDebug(PLUGIN_NAME, "   Using the to url");
+      Dbg(pi_dbg_ctl, "   Using the to url");
       url = res._rri->mapToUrl;
     } else {
       TSError("[%s] Invalid option value", PLUGIN_NAME);
@@ -333,39 +333,39 @@ ConditionUrl::append_value(std::string &s, const Resources &res)
   case URL_QUAL_HOST:
     q_str = TSUrlHostGet(bufp, url, &i);
     s.append(q_str, i);
-    TSDebug(PLUGIN_NAME, "   Host to match is: %.*s", i, q_str);
+    Dbg(pi_dbg_ctl, "   Host to match is: %.*s", i, q_str);
     break;
   case URL_QUAL_PORT:
     i = TSUrlPortGet(bufp, url);
     s.append(std::to_string(i));
-    TSDebug(PLUGIN_NAME, "   Port to match is: %d", i);
+    Dbg(pi_dbg_ctl, "   Port to match is: %d", i);
     break;
   case URL_QUAL_PATH:
     q_str = TSUrlPathGet(bufp, url, &i);
     s.append(q_str, i);
-    TSDebug(PLUGIN_NAME, "   Path to match is: %.*s", i, q_str);
+    Dbg(pi_dbg_ctl, "   Path to match is: %.*s", i, q_str);
     break;
   case URL_QUAL_QUERY:
     q_str = TSUrlHttpQueryGet(bufp, url, &i);
     s.append(q_str, i);
-    TSDebug(PLUGIN_NAME, "   Query parameters to match is: %.*s", i, q_str);
+    Dbg(pi_dbg_ctl, "   Query parameters to match is: %.*s", i, q_str);
     break;
   case URL_QUAL_MATRIX:
     q_str = TSUrlHttpParamsGet(bufp, url, &i);
     s.append(q_str, i);
-    TSDebug(PLUGIN_NAME, "   Matrix parameters to match is: %.*s", i, q_str);
+    Dbg(pi_dbg_ctl, "   Matrix parameters to match is: %.*s", i, q_str);
     break;
   case URL_QUAL_SCHEME:
     q_str = TSUrlSchemeGet(bufp, url, &i);
     s.append(q_str, i);
-    TSDebug(PLUGIN_NAME, "   Scheme to match is: %.*s", i, q_str);
+    Dbg(pi_dbg_ctl, "   Scheme to match is: %.*s", i, q_str);
     break;
   case URL_QUAL_URL:
   case URL_QUAL_NONE: {
     // TSUrlStringGet returns an allocated char * we must free
     char *non_const_q_str = TSUrlStringGet(bufp, url, &i);
     s.append(non_const_q_str, i);
-    TSDebug(PLUGIN_NAME, "   URL to match is: %.*s", i, non_const_q_str);
+    Dbg(pi_dbg_ctl, "   URL to match is: %.*s", i, non_const_q_str);
     TSfree(non_const_q_str);
     break;
   }
@@ -397,7 +397,7 @@ ConditionDBM::initialize(Parser &p)
     _file = _qualifier.substr(0, pos);
     //_dbm = mdbm_open(_file.c_str(), O_RDONLY, 0, 0, 0);
     // if (NULL != _dbm) {
-    //   TSDebug(PLUGIN_NAME, "Opened DBM file %s", _file.c_str());
+    //   Dbg(pi_dbg_ctl, "Opened DBM file %s", _file.c_str());
     //   _key.set_value(_qualifier.substr(pos + 1));
     // } else {
     //   TSError("[%s] Failed to open DBM file: %s", PLUGIN_NAME, _file.c_str());
@@ -420,7 +420,7 @@ ConditionDBM::append_value(std::string & /* s ATS_UNUSED */, const Resources & /
   // if (key.size() > 0) {
   //   datum k, v;
 
-  //   TSDebug(PLUGIN_NAME, "Looking up DBM(\"%s\")", key.c_str());
+  //   Dbg(pi_dbg_ctl, "Looking up DBM(\"%s\")", key.c_str());
   //   k.dptr = const_cast<char*>(key.c_str());
   //   k.dsize = key.size();
 
@@ -428,7 +428,7 @@ ConditionDBM::append_value(std::string & /* s ATS_UNUSED */, const Resources & /
   //   //v = mdbm_fetch(_dbm, k);
   //   TSMutexUnlock(_mutex);
   //   if (v.dsize > 0) {
-  //     TSDebug(PLUGIN_NAME, "Appending DBM(%.*s) to evaluation value -> %.*s", k.dsize, k.dptr, v.dsize, v.dptr);
+  //     Dbg(pi_dbg_ctl, "Appending DBM(%.*s) to evaluation value -> %.*s", k.dsize, k.dptr, v.dsize, v.dptr);
   //     s.append(v.dptr, v.dsize);
   //   }
   // }
@@ -440,7 +440,7 @@ ConditionDBM::eval(const Resources &res)
   std::string s;
 
   append_value(s, res);
-  TSDebug(PLUGIN_NAME, "Evaluating DBM()");
+  Dbg(pi_dbg_ctl, "Evaluating DBM()");
 
   return static_cast<const MatcherType *>(_matcher)->test(s);
 }
@@ -496,7 +496,7 @@ ConditionCookie::append_value(std::string &s, const Resources &res)
     goto out_release_field;
   }
 
-  TSDebug(PLUGIN_NAME, "Appending COOKIE(%s) to evaluation value -> %.*s", cookie_name, cookie_value_len, cookie_value);
+  Dbg(pi_dbg_ctl, "Appending COOKIE(%s) to evaluation value -> %.*s", cookie_name, cookie_value_len, cookie_value);
   s.append(cookie_value, cookie_value_len);
 
 // Unwind
@@ -510,7 +510,7 @@ ConditionCookie::eval(const Resources &res)
   std::string s;
 
   append_value(s, res);
-  TSDebug(PLUGIN_NAME, "Evaluating COOKIE()");
+  Dbg(pi_dbg_ctl, "Evaluating COOKIE()");
 
   return static_cast<const MatcherType *>(_matcher)->test(s);
 }
@@ -521,7 +521,7 @@ ConditionInternalTxn::eval(const Resources &res)
 {
   bool ret = (0 != TSHttpTxnIsInternal(res.txnp));
 
-  TSDebug(PLUGIN_NAME, "Evaluating INTERNAL-TRANSACTION() -> %d", ret);
+  Dbg(pi_dbg_ctl, "Evaluating INTERNAL-TRANSACTION() -> %d", ret);
   return ret;
 }
 
@@ -548,7 +548,7 @@ ConditionIp::set_qualifier(const std::string &q)
 {
   Condition::set_qualifier(q);
 
-  TSDebug(PLUGIN_NAME, "\tParsing %%{IP:%s} qualifier", q.c_str());
+  Dbg(pi_dbg_ctl, "\tParsing %%{IP:%s} qualifier", q.c_str());
 
   if (q == "CLIENT") {
     _ip_qual = IP_QUAL_CLIENT;
@@ -595,7 +595,7 @@ ConditionIp::eval(const Resources &res)
     append_value(s, res);
     bool rval = static_cast<const Matchers<std::string> *>(_matcher)->test(s);
 
-    TSDebug(PLUGIN_NAME, "Evaluating IP(): %s - rval: %d", s.c_str(), rval);
+    Dbg(pi_dbg_ctl, "Evaluating IP(): %s - rval: %d", s.c_str(), rval);
 
     return rval;
   }
@@ -618,7 +618,7 @@ ConditionIp::append_value(std::string &s, const Resources &res)
     ip_set = (nullptr != getIP(TSHttpTxnServerAddrGet(res.txnp), ip));
     break;
   case IP_QUAL_OUTBOUND:
-    TSDebug(PLUGIN_NAME, "Requesting output ip");
+    Dbg(pi_dbg_ctl, "Requesting output ip");
     ip_set = (nullptr != getIP(TSHttpTxnOutgoingAddrGet(res.txnp), ip));
     break;
   }
@@ -648,11 +648,11 @@ ConditionTransactCount::eval(const Resources &res)
   if (ssn) {
     int n = TSHttpSsnTransactionCount(ssn);
 
-    TSDebug(PLUGIN_NAME, "Evaluating TXN-COUNT()");
+    Dbg(pi_dbg_ctl, "Evaluating TXN-COUNT()");
     return static_cast<MatcherType *>(_matcher)->test(n);
   }
 
-  TSDebug(PLUGIN_NAME, "\tNo session found, returning false");
+  Dbg(pi_dbg_ctl, "\tNo session found, returning false");
   return false;
 }
 
@@ -667,7 +667,7 @@ ConditionTransactCount::append_value(std::string &s, Resources const &res)
     int length = ink_fast_itoa(count, value, sizeof(value));
 
     if (length > 0) {
-      TSDebug(PLUGIN_NAME, "Appending TXN-COUNT %s to evaluation value %.*s", _qualifier.c_str(), length, value);
+      Dbg(pi_dbg_ctl, "Appending TXN-COUNT %s to evaluation value %.*s", _qualifier.c_str(), length, value);
       s.append(value, length);
     }
   }
@@ -735,7 +735,7 @@ ConditionNow::set_qualifier(const std::string &q)
 {
   Condition::set_qualifier(q);
 
-  TSDebug(PLUGIN_NAME, "\tParsing %%{NOW:%s} qualifier", q.c_str());
+  Dbg(pi_dbg_ctl, "\tParsing %%{NOW:%s} qualifier", q.c_str());
 
   if (q == "EPOCH") {
     _now_qual = NOW_QUAL_EPOCH;
@@ -765,7 +765,7 @@ ConditionNow::append_value(std::string &s, const Resources & /* res ATS_UNUSED *
 
   oss << get_now_qualified(_now_qual);
   s += oss.str();
-  TSDebug(PLUGIN_NAME, "Appending NOW() to evaluation value -> %s", s.c_str());
+  Dbg(pi_dbg_ctl, "Appending NOW() to evaluation value -> %s", s.c_str());
 }
 
 bool
@@ -773,7 +773,7 @@ ConditionNow::eval(const Resources &res)
 {
   int64_t now = get_now_qualified(_now_qual);
 
-  TSDebug(PLUGIN_NAME, "Evaluating NOW()");
+  Dbg(pi_dbg_ctl, "Evaluating NOW()");
   return static_cast<const MatcherType *>(_matcher)->test(now);
 }
 
@@ -815,7 +815,7 @@ ConditionGeo::set_qualifier(const std::string &q)
 {
   Condition::set_qualifier(q);
 
-  TSDebug(PLUGIN_NAME, "\tParsing %%{GEO:%s} qualifier", q.c_str());
+  Dbg(pi_dbg_ctl, "\tParsing %%{GEO:%s} qualifier", q.c_str());
 
   if (q == "COUNTRY") {
     _geo_qual = GEO_QUAL_COUNTRY;
@@ -845,7 +845,7 @@ ConditionGeo::append_value(std::string &s, const Resources &res)
     oss << get_geo_string(TSHttpTxnClientAddrGet(res.txnp));
   }
   s += oss.str();
-  TSDebug(PLUGIN_NAME, "Appending GEO() to evaluation value -> %s", s.c_str());
+  Dbg(pi_dbg_ctl, "Appending GEO() to evaluation value -> %s", s.c_str());
 }
 
 bool
@@ -853,7 +853,7 @@ ConditionGeo::eval(const Resources &res)
 {
   bool ret = false;
 
-  TSDebug(PLUGIN_NAME, "Evaluating GEO()");
+  Dbg(pi_dbg_ctl, "Evaluating GEO()");
   if (is_int_type()) {
     int64_t geo = get_geo_int(TSHttpTxnClientAddrGet(res.txnp));
 
@@ -896,7 +896,7 @@ ConditionId::set_qualifier(const std::string &q)
 {
   Condition::set_qualifier(q);
 
-  TSDebug(PLUGIN_NAME, "\tParsing %%{ID:%s} qualifier", q.c_str());
+  Dbg(pi_dbg_ctl, "\tParsing %%{ID:%s} qualifier", q.c_str());
 
   if (q == "UNIQUE") {
     _id_qual = ID_QUAL_UNIQUE;
@@ -934,7 +934,7 @@ ConditionId::append_value(std::string &s, const Resources &res ATS_UNUSED)
     }
   } break;
   }
-  TSDebug(PLUGIN_NAME, "Appending ID() to evaluation value -> %s", s.c_str());
+  Dbg(pi_dbg_ctl, "Appending ID() to evaluation value -> %s", s.c_str());
 }
 
 bool
@@ -943,7 +943,7 @@ ConditionId::eval(const Resources &res)
   if (_id_qual == ID_QUAL_REQUEST) {
     uint64_t id = TSHttpTxnIdGet(res.txnp);
 
-    TSDebug(PLUGIN_NAME, "Evaluating GEO() -> %" PRIu64, id);
+    Dbg(pi_dbg_ctl, "Evaluating GEO() -> %" PRIu64, id);
     return static_cast<const Matchers<uint64_t> *>(_matcher)->test(id);
   } else {
     std::string s;
@@ -951,7 +951,7 @@ ConditionId::eval(const Resources &res)
     append_value(s, res);
     bool rval = static_cast<const Matchers<std::string> *>(_matcher)->test(s);
 
-    TSDebug(PLUGIN_NAME, "Evaluating ID(): %s - rval: %d", s.c_str(), rval);
+    Dbg(pi_dbg_ctl, "Evaluating ID(): %s - rval: %d", s.c_str(), rval);
     return rval;
   }
 }
@@ -976,7 +976,7 @@ ConditionCidr::set_qualifier(const std::string &q)
 
   Condition::set_qualifier(q);
 
-  TSDebug(PLUGIN_NAME, "\tParsing %%{CIDR:%s} qualifier", q.c_str());
+  Dbg(pi_dbg_ctl, "\tParsing %%{CIDR:%s} qualifier", q.c_str());
   cidr = strtol(q.c_str(), &endp, 10);
   if (cidr >= 0 && cidr <= 32) {
     _v4_mask.s_addr = UINT32_MAX >> (32 - cidr);
@@ -1007,7 +1007,7 @@ ConditionCidr::eval(const Resources &res)
   std::string s;
 
   append_value(s, res);
-  TSDebug(PLUGIN_NAME, "Evaluating CIDR()");
+  Dbg(pi_dbg_ctl, "Evaluating CIDR()");
 
   return static_cast<MatcherType *>(_matcher)->test(s);
 }
@@ -1082,7 +1082,7 @@ ConditionInbound::set_qualifier(const std::string &q)
 {
   Condition::set_qualifier(q);
 
-  TSDebug(PLUGIN_NAME, "\tParsing %%{%s:%s} qualifier", TAG, q.c_str());
+  Dbg(pi_dbg_ctl, "\tParsing %%{%s:%s} qualifier", TAG, q.c_str());
 
   if (q == "LOCAL-ADDR") {
     _net_qual = NET_QUAL_LOCAL_ADDR;
@@ -1140,7 +1140,7 @@ ConditionInbound::eval(const Resources &res)
     append_value(s, res);
     bool rval = static_cast<const Matchers<std::string> *>(_matcher)->test(s);
 
-    TSDebug(PLUGIN_NAME, "Evaluating %s(): %s - rval: %d", TAG, s.c_str(), rval);
+    Dbg(pi_dbg_ctl, "Evaluating %s(): %s - rval: %d", TAG, s.c_str(), rval);
 
     return rval;
   }
@@ -1215,7 +1215,7 @@ ConditionInbound::append_value(std::string &s, const Resources &res, NetworkSess
 
 ConditionStringLiteral::ConditionStringLiteral(const std::string &v)
 {
-  TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for ConditionStringLiteral");
+  Dbg(dbg_ctl, "Calling CTOR for ConditionStringLiteral");
   _literal = v;
 }
 
@@ -1223,13 +1223,13 @@ void
 ConditionStringLiteral::append_value(std::string &s, const Resources &res)
 {
   s += _literal;
-  TSDebug(PLUGIN_NAME, "Appending '%s' to evaluation value", _literal.c_str());
+  Dbg(pi_dbg_ctl, "Appending '%s' to evaluation value", _literal.c_str());
 }
 
 bool
 ConditionStringLiteral::eval(const Resources &res)
 {
-  TSDebug(PLUGIN_NAME, "Evaluating StringLiteral");
+  Dbg(pi_dbg_ctl, "Evaluating StringLiteral");
 
   return static_cast<const MatcherType *>(_matcher)->test(_literal);
 }
@@ -1251,7 +1251,7 @@ ConditionSessionTransactCount::eval(const Resources &res)
 {
   int const val = TSHttpTxnServerSsnTransactionCount(res.txnp);
 
-  TSDebug(PLUGIN_NAME, "Evaluating SSN-TXN-COUNT()");
+  Dbg(pi_dbg_ctl, "Evaluating SSN-TXN-COUNT()");
   return static_cast<MatcherType *>(_matcher)->test(val);
 }
 
@@ -1263,7 +1263,7 @@ ConditionSessionTransactCount::append_value(std::string &s, Resources const &res
   int const length = ink_fast_itoa(count, value, sizeof(value));
 
   if (length > 0) {
-    TSDebug(PLUGIN_NAME, "Appending SSN-TXN-COUNT %s to evaluation value %.*s", _qualifier.c_str(), length, value);
+    Dbg(pi_dbg_ctl, "Appending SSN-TXN-COUNT %s to evaluation value %.*s", _qualifier.c_str(), length, value);
     s.append(value, length);
   }
 }
@@ -1272,7 +1272,7 @@ void
 ConditionTcpInfo::initialize(Parser &p)
 {
   Condition::initialize(p);
-  TSDebug(PLUGIN_NAME, "Initializing TCP Info");
+  Dbg(pi_dbg_ctl, "Initializing TCP Info");
   MatcherType *match     = new MatcherType(_cond_op);
   std::string const &arg = p.get_arg();
 
@@ -1296,7 +1296,7 @@ ConditionTcpInfo::eval(const Resources &res)
   append_value(s, res);
   bool rval = static_cast<const Matchers<std::string> *>(_matcher)->test(s);
 
-  TSDebug(PLUGIN_NAME, "Evaluating TCP-Info: %s - rval: %d", s.c_str(), rval);
+  Dbg(pi_dbg_ctl, "Evaluating TCP-Info: %s - rval: %d", s.c_str(), rval);
 
   return rval;
 }
@@ -1306,7 +1306,7 @@ ConditionTcpInfo::append_value(std::string &s, Resources const &res)
 {
 #if defined(TCP_INFO) && defined(HAVE_STRUCT_TCP_INFO)
   if (TSHttpTxnIsInternal(res.txnp)) {
-    TSDebug(PLUGIN_NAME, "No TCP-INFO available for internal transactions");
+    Dbg(pi_dbg_ctl, "No TCP-INFO available for internal transactions");
     return;
   }
   TSReturnCode tsSsn;
@@ -1315,10 +1315,10 @@ ConditionTcpInfo::append_value(std::string &s, Resources const &res)
   socklen_t tcp_info_len = sizeof(info);
   tsSsn                  = TSHttpTxnClientFdGet(res.txnp, &fd);
   if (tsSsn != TS_SUCCESS || fd <= 0) {
-    TSDebug(PLUGIN_NAME, "error getting the client socket fd from ssn");
+    Dbg(pi_dbg_ctl, "error getting the client socket fd from ssn");
   }
   if (getsockopt(fd, IPPROTO_TCP, TCP_INFO, &info, &tcp_info_len) != 0) {
-    TSDebug(PLUGIN_NAME, "getsockopt(%d, TCP_INFO) failed: %s", fd, strerror(errno));
+    Dbg(pi_dbg_ctl, "getsockopt(%d, TCP_INFO) failed: %s", fd, strerror(errno));
   }
 
   if (tsSsn == TS_SUCCESS) {
@@ -1355,7 +1355,7 @@ ConditionCache::eval(const Resources &res)
   std::string s;
 
   append_value(s, res);
-  TSDebug(PLUGIN_NAME, "Evaluating CACHE()");
+  Dbg(pi_dbg_ctl, "Evaluating CACHE()");
 
   return static_cast<const MatcherType *>(_matcher)->test(s);
 }
@@ -1373,14 +1373,14 @@ ConditionCache::append_value(std::string &s, const Resources &res)
     "skipped"    // TS_CACHE_LOOKUP_SKIPPED
   };
 
-  TSDebug(PLUGIN_NAME, "Appending CACHE() to evaluation value -> %s", s.c_str());
+  Dbg(pi_dbg_ctl, "Appending CACHE() to evaluation value -> %s", s.c_str());
 
   if (TSHttpTxnCacheLookupStatusGet(txn, &status) == TS_ERROR || status < 0 || status >= 4) {
-    TSDebug(PLUGIN_NAME, "Cache Status Invalid: %d", status);
+    Dbg(pi_dbg_ctl, "Cache Status Invalid: %d", status);
 
     s += "none";
   } else {
-    TSDebug(PLUGIN_NAME, "Cache Status Valid: %d", status);
+    Dbg(pi_dbg_ctl, "Cache Status Valid: %d", status);
 
     s += names[status];
   }
@@ -1401,7 +1401,7 @@ void
 ConditionNextHop::set_qualifier(const std::string &q)
 {
   Condition::set_qualifier(q);
-  TSDebug(PLUGIN_NAME, "\tParsing %%{NEXT-HOP:%s}", q.c_str());
+  Dbg(pi_dbg_ctl, "\tParsing %%{NEXT-HOP:%s}", q.c_str());
   _next_hop_qual = parse_next_hop_qualifier(q);
 }
 
@@ -1412,15 +1412,15 @@ ConditionNextHop::append_value(std::string &s, const Resources &res)
   case NEXT_HOP_HOST: {
     char const *const name = TSHttpTxnNextHopNameGet(res.txnp);
     if (nullptr != name) {
-      TSDebug(PLUGIN_NAME, "Appending '%s' to evaluation value", name);
+      Dbg(pi_dbg_ctl, "Appending '%s' to evaluation value", name);
       s.append(name);
     } else {
-      TSDebug(PLUGIN_NAME, "NextHopName is empty");
+      Dbg(pi_dbg_ctl, "NextHopName is empty");
     }
   } break;
   case NEXT_HOP_PORT: {
     int const port = TSHttpTxnNextHopPortGet(res.txnp);
-    TSDebug(PLUGIN_NAME, "Appending '%d' to evaluation value", port);
+    Dbg(pi_dbg_ctl, "Appending '%d' to evaluation value", port);
     s.append(std::to_string(port));
   } break;
   default:
diff --git a/plugins/header_rewrite/conditions.h b/plugins/header_rewrite/conditions.h
index bec8946c1e2..e8ea12aec8c 100644
--- a/plugins/header_rewrite/conditions.h
+++ b/plugins/header_rewrite/conditions.h
@@ -41,7 +41,7 @@
 class ConditionTrue : public Condition
 {
 public:
-  ConditionTrue() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for ConditionTrue"); }
+  ConditionTrue() { Dbg(dbg_ctl, "Calling CTOR for ConditionTrue"); }
 
   // noncopyable
   ConditionTrue(const ConditionTrue &)  = delete;
@@ -57,7 +57,7 @@ class ConditionTrue : public Condition
   bool
   eval(const Resources & /* res ATS_UNUSED */) override
   {
-    TSDebug(PLUGIN_NAME, "Evaluating TRUE()");
+    Dbg(pi_dbg_ctl, "Evaluating TRUE()");
     return true;
   }
 };
@@ -66,7 +66,7 @@ class ConditionTrue : public Condition
 class ConditionFalse : public Condition
 {
 public:
-  ConditionFalse() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for ConditionFalse"); }
+  ConditionFalse() { Dbg(dbg_ctl, "Calling CTOR for ConditionFalse"); }
 
   // noncopyable
   ConditionFalse(const ConditionFalse &) = delete;
@@ -82,7 +82,7 @@ class ConditionFalse : public Condition
   bool
   eval(const Resources & /* res ATS_UNUSED */) override
   {
-    TSDebug(PLUGIN_NAME, "Evaluating FALSE()");
+    Dbg(pi_dbg_ctl, "Evaluating FALSE()");
     return false;
   }
 };
@@ -93,7 +93,7 @@ class ConditionStatus : public Condition
   using MatcherType = Matchers<TSHttpStatus>;
 
 public:
-  ConditionStatus() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for ConditionStatus"); }
+  ConditionStatus() { Dbg(dbg_ctl, "Calling CTOR for ConditionStatus"); }
 
   // noncopyable
   ConditionStatus(const ConditionStatus &) = delete;
@@ -113,7 +113,7 @@ class ConditionMethod : public Condition
   using MatcherType = Matchers<std::string>;
 
 public:
-  ConditionMethod() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for ConditionMethod"); }
+  ConditionMethod() { Dbg(dbg_ctl, "Calling CTOR for ConditionMethod"); }
 
   // noncopyable
   ConditionMethod(const ConditionMethod &) = delete;
@@ -132,7 +132,7 @@ class ConditionRandom : public Condition
   using MatcherType = Matchers<unsigned int>;
 
 public:
-  ConditionRandom() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for ConditionRandom"); }
+  ConditionRandom() { Dbg(dbg_ctl, "Calling CTOR for ConditionRandom"); }
 
   // noncopyable
   ConditionRandom(const ConditionRandom &) = delete;
@@ -153,7 +153,7 @@ class ConditionRandom : public Condition
 class ConditionAccess : public Condition
 {
 public:
-  ConditionAccess() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for ConditionAccess"); }
+  ConditionAccess() { Dbg(dbg_ctl, "Calling CTOR for ConditionAccess"); }
 
   // noncopyable
   ConditionAccess(const ConditionAccess &) = delete;
@@ -176,7 +176,7 @@ class ConditionCookie : public Condition
   using MatcherType = Matchers<std::string>;
 
 public:
-  ConditionCookie() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for ConditionCookie"); }
+  ConditionCookie() { Dbg(dbg_ctl, "Calling CTOR for ConditionCookie"); }
 
   // noncopyable
   ConditionCookie(const ConditionCookie &) = delete;
@@ -249,7 +249,7 @@ class ConditionHeader : public Condition
 public:
   explicit ConditionHeader(bool client = false) : _client(client)
   {
-    TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for ConditionHeader, client %d", client);
+    Dbg(dbg_ctl, "Calling CTOR for ConditionHeader, client %d", client);
   }
 
   // noncopyable
@@ -274,7 +274,7 @@ class ConditionUrl : public Condition
 public:
   enum UrlType { CLIENT, URL, FROM, TO };
 
-  explicit ConditionUrl(const UrlType type) : _type(type) { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for ConditionUrl"); }
+  explicit ConditionUrl(const UrlType type) : _type(type) { Dbg(dbg_ctl, "Calling CTOR for ConditionUrl"); }
 
   // noncopyable
   ConditionUrl(const ConditionUrl &)   = delete;
@@ -303,7 +303,7 @@ class ConditionDBM : public Condition
       _file(""),
       _mutex(TSMutexCreate())
   {
-    TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for ConditionDBM");
+    Dbg(dbg_ctl, "Calling CTOR for ConditionDBM");
   }
 
   ~ConditionDBM() override
@@ -351,7 +351,7 @@ class ConditionIp : public Condition
   using MatcherTypeIp = Matchers<const sockaddr *>;
 
 public:
-  explicit ConditionIp() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for ConditionIp"); };
+  explicit ConditionIp() { Dbg(dbg_ctl, "Calling CTOR for ConditionIp"); };
 
   // noncopyable
   ConditionIp(const ConditionIp &)    = delete;
@@ -374,7 +374,7 @@ class ConditionTransactCount : public Condition
   using MatcherType = Matchers<int>;
 
 public:
-  ConditionTransactCount() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for ConditionTransactCount"); }
+  ConditionTransactCount() { Dbg(dbg_ctl, "Calling CTOR for ConditionTransactCount"); }
 
   // noncopyable
   ConditionTransactCount(const ConditionTransactCount &) = delete;
@@ -393,7 +393,7 @@ class ConditionNow : public Condition
   using MatcherType = Matchers<int64_t>;
 
 public:
-  explicit ConditionNow() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for ConditionNow"); }
+  explicit ConditionNow() { Dbg(dbg_ctl, "Calling CTOR for ConditionNow"); }
 
   // noncopyable
   ConditionNow(const ConditionNow &)   = delete;
@@ -415,7 +415,7 @@ class ConditionNow : public Condition
 class ConditionGeo : public Condition
 {
 public:
-  explicit ConditionGeo() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for ConditionGeo"); }
+  explicit ConditionGeo() { Dbg(dbg_ctl, "Calling CTOR for ConditionGeo"); }
 
   // noncopyable
   ConditionGeo(const ConditionGeo &)   = delete;
@@ -452,7 +452,7 @@ class ConditionGeo : public Condition
 class ConditionId : public Condition
 {
 public:
-  explicit ConditionId() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for ConditionId"); };
+  explicit ConditionId() { Dbg(dbg_ctl, "Calling CTOR for ConditionId"); };
 
   // noncopyable
   ConditionId(const ConditionId &)    = delete;
@@ -479,7 +479,7 @@ class ConditionCidr : public Condition
   explicit ConditionCidr()
   {
     _create_masks(); // This must be called here, because we might not have parameters specified
-    TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for ConditionCidr");
+    Dbg(dbg_ctl, "Calling CTOR for ConditionCidr");
   };
 
   ConditionCidr(self &)   = delete;
@@ -509,7 +509,7 @@ class ConditionInbound : public Condition
   using self          = ConditionInbound;
 
 public:
-  explicit ConditionInbound() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for ConditionInbound"); };
+  explicit ConditionInbound() { Dbg(dbg_ctl, "Calling CTOR for ConditionInbound"); };
   ConditionInbound(self &) = delete;
   self &operator=(self &)  = delete;
 
@@ -553,7 +553,7 @@ class ConditionSessionTransactCount : public Condition
   using MatcherType = Matchers<int>;
 
 public:
-  ConditionSessionTransactCount() { TSDebug(PLUGIN_NAME_DBG, "ConditionSessionTransactCount()"); }
+  ConditionSessionTransactCount() { Dbg(dbg_ctl, "ConditionSessionTransactCount()"); }
 
   // noncopyable
   ConditionSessionTransactCount(const ConditionSessionTransactCount &) = delete;
@@ -572,7 +572,7 @@ class ConditionTcpInfo : public Condition
   using MatcherType = Matchers<int>;
 
 public:
-  ConditionTcpInfo() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for ConditionTcpInfo"); }
+  ConditionTcpInfo() { Dbg(dbg_ctl, "Calling CTOR for ConditionTcpInfo"); }
 
   // noncopyable
   ConditionTcpInfo(const ConditionTcpInfo &) = delete;
@@ -592,7 +592,7 @@ class ConditionCache : public Condition
   using MatcherType = Matchers<std::string>;
 
 public:
-  ConditionCache() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for ConditionCache"); }
+  ConditionCache() { Dbg(dbg_ctl, "Calling CTOR for ConditionCache"); }
 
   // noncopyable
   ConditionCache(const ConditionCache &) = delete;
@@ -613,7 +613,7 @@ class ConditionNextHop : public Condition
 public:
   enum HostType { NAME, PORT };
 
-  explicit ConditionNextHop() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for ConditionNextHop"); }
+  explicit ConditionNextHop() { Dbg(dbg_ctl, "Calling CTOR for ConditionNextHop"); }
 
   // noncopyable
   ConditionNextHop(const ConditionNextHop &) = delete;
diff --git a/plugins/header_rewrite/conditions_geo_geoip.cc b/plugins/header_rewrite/conditions_geo_geoip.cc
index f8830239444..aae804650c4 100644
--- a/plugins/header_rewrite/conditions_geo_geoip.cc
+++ b/plugins/header_rewrite/conditions_geo_geoip.cc
@@ -44,7 +44,7 @@ GeoIPConditionGeo::initLibrary(const std::string &)
       gGeoIP[db] = GeoIP_open_type(db, GEOIP_MMAP_CACHE);
 
       char *db_info = GeoIP_database_info(gGeoIP[db]);
-      TSDebug(PLUGIN_NAME, "initialized GeoIP-DB[%d] %s", db, db_info);
+      Dbg(pi_dbg_ctl, "initialized GeoIP-DB[%d] %s", db, db_info);
       free(db_info);
     }
   }
@@ -79,7 +79,7 @@ GeoIPConditionGeo::get_geo_string(const sockaddr *addr) const
       default:
         break;
       }
-      TSDebug(PLUGIN_NAME, "eval(): Client IPv%d seems to come from Country: %s", v, ret.c_str());
+      Dbg(pi_dbg_ctl, "eval(): Client IPv%d seems to come from Country: %s", v, ret.c_str());
       break;
 
     // ASN database
@@ -103,7 +103,7 @@ GeoIPConditionGeo::get_geo_string(const sockaddr *addr) const
       default:
         break;
       }
-      TSDebug(PLUGIN_NAME, "eval(): Client IPv%d seems to come from ASN Name: %s", v, ret.c_str());
+      Dbg(pi_dbg_ctl, "eval(): Client IPv%d seems to come from ASN Name: %s", v, ret.c_str());
       break;
     default:
       break;
@@ -145,7 +145,7 @@ GeoIPConditionGeo::get_geo_int(const sockaddr *addr) const
     default:
       break;
     }
-    TSDebug(PLUGIN_NAME, "eval(): Client IPv%d seems to come from Country ISO: %" PRId64, v, ret);
+    Dbg(pi_dbg_ctl, "eval(): Client IPv%d seems to come from Country ISO: %" PRId64, v, ret);
     break;
 
   case GEO_QUAL_ASN: {
@@ -176,7 +176,7 @@ GeoIPConditionGeo::get_geo_int(const sockaddr *addr) const
       ret = strtol(asn_name, nullptr, 10);
     }
   }
-    TSDebug(PLUGIN_NAME, "eval(): Client IPv%d seems to come from ASN #: %" PRId64, v, ret);
+    Dbg(pi_dbg_ctl, "eval(): Client IPv%d seems to come from ASN #: %" PRId64, v, ret);
     break;
 
   // Likely shouldn't trip, should we assert?
diff --git a/plugins/header_rewrite/conditions_geo_maxmind.cc b/plugins/header_rewrite/conditions_geo_maxmind.cc
index 27912db1de2..3f6d2b154e5 100644
--- a/plugins/header_rewrite/conditions_geo_maxmind.cc
+++ b/plugins/header_rewrite/conditions_geo_maxmind.cc
@@ -36,12 +36,12 @@ void
 MMConditionGeo::initLibrary(const std::string &path)
 {
   if (path.empty()) {
-    TSDebug(PLUGIN_NAME, "Empty MaxMind db path specified. Not initializing!");
+    Dbg(pi_dbg_ctl, "Empty MaxMind db path specified. Not initializing!");
     return;
   }
 
   if (gMaxMindDB != nullptr) {
-    TSDebug(PLUGIN_NAME, "Maxmind library already initialized");
+    Dbg(pi_dbg_ctl, "Maxmind library already initialized");
     return;
   }
 
@@ -49,11 +49,11 @@ MMConditionGeo::initLibrary(const std::string &path)
 
   int status = MMDB_open(path.c_str(), MMDB_MODE_MMAP, gMaxMindDB);
   if (MMDB_SUCCESS != status) {
-    TSDebug(PLUGIN_NAME, "Cannot open %s - %s", path.c_str(), MMDB_strerror(status));
+    Dbg(pi_dbg_ctl, "Cannot open %s - %s", path.c_str(), MMDB_strerror(status));
     delete gMaxMindDB;
     return;
   }
-  TSDebug(PLUGIN_NAME, "Loaded %s", path.c_str());
+  Dbg(pi_dbg_ctl, "Loaded %s", path.c_str());
 }
 
 std::string
@@ -63,31 +63,31 @@ MMConditionGeo::get_geo_string(const sockaddr *addr) const
   int mmdb_error;
 
   if (gMaxMindDB == nullptr) {
-    TSDebug(PLUGIN_NAME, "MaxMind not initialized; using default value");
+    Dbg(pi_dbg_ctl, "MaxMind not initialized; using default value");
     return ret;
   }
 
   MMDB_lookup_result_s result = MMDB_lookup_sockaddr(gMaxMindDB, addr, &mmdb_error);
 
   if (MMDB_SUCCESS != mmdb_error) {
-    TSDebug(PLUGIN_NAME, "Error during sockaddr lookup: %s", MMDB_strerror(mmdb_error));
+    Dbg(pi_dbg_ctl, "Error during sockaddr lookup: %s", MMDB_strerror(mmdb_error));
     return ret;
   }
 
   MMDB_entry_data_list_s *entry_data_list = nullptr;
   if (!result.found_entry) {
-    TSDebug(PLUGIN_NAME, "No entry for this IP was found");
+    Dbg(pi_dbg_ctl, "No entry for this IP was found");
     return ret;
   }
 
   int status = MMDB_get_entry_data_list(&result.entry, &entry_data_list);
   if (MMDB_SUCCESS != status) {
-    TSDebug(PLUGIN_NAME, "Error looking up entry data: %s", MMDB_strerror(status));
+    Dbg(pi_dbg_ctl, "Error looking up entry data: %s", MMDB_strerror(status));
     return ret;
   }
 
   if (entry_data_list == nullptr) {
-    TSDebug(PLUGIN_NAME, "No data found");
+    Dbg(pi_dbg_ctl, "No data found");
     return ret;
   }
 
@@ -100,7 +100,7 @@ MMConditionGeo::get_geo_string(const sockaddr *addr) const
     field_name = "autonomous_system_organization";
     break;
   default:
-    TSDebug(PLUGIN_NAME, "Unsupported field %d", _geo_qual);
+    Dbg(pi_dbg_ctl, "Unsupported field %d", _geo_qual);
     return ret;
     break;
   }
@@ -109,7 +109,7 @@ MMConditionGeo::get_geo_string(const sockaddr *addr) const
 
   status = MMDB_get_value(&result.entry, &entry_data, field_name, NULL);
   if (MMDB_SUCCESS != status) {
-    TSDebug(PLUGIN_NAME, "ERROR on get value asn value: %s", MMDB_strerror(status));
+    Dbg(pi_dbg_ctl, "ERROR on get value asn value: %s", MMDB_strerror(status));
     return ret;
   }
   ret = std::string(entry_data.utf8_string, entry_data.data_size);
@@ -128,31 +128,31 @@ MMConditionGeo::get_geo_int(const sockaddr *addr) const
   int mmdb_error;
 
   if (gMaxMindDB == nullptr) {
-    TSDebug(PLUGIN_NAME, "MaxMind not initialized; using default value");
+    Dbg(pi_dbg_ctl, "MaxMind not initialized; using default value");
     return ret;
   }
 
   MMDB_lookup_result_s result = MMDB_lookup_sockaddr(gMaxMindDB, addr, &mmdb_error);
 
   if (MMDB_SUCCESS != mmdb_error) {
-    TSDebug(PLUGIN_NAME, "Error during sockaddr lookup: %s", MMDB_strerror(mmdb_error));
+    Dbg(pi_dbg_ctl, "Error during sockaddr lookup: %s", MMDB_strerror(mmdb_error));
     return ret;
   }
 
   MMDB_entry_data_list_s *entry_data_list = nullptr;
   if (!result.found_entry) {
-    TSDebug(PLUGIN_NAME, "No entry for this IP was found");
+    Dbg(pi_dbg_ctl, "No entry for this IP was found");
     return ret;
   }
 
   int status = MMDB_get_entry_data_list(&result.entry, &entry_data_list);
   if (MMDB_SUCCESS != status) {
-    TSDebug(PLUGIN_NAME, "Error looking up entry data: %s", MMDB_strerror(status));
+    Dbg(pi_dbg_ctl, "Error looking up entry data: %s", MMDB_strerror(status));
     return ret;
   }
 
   if (entry_data_list == nullptr) {
-    TSDebug(PLUGIN_NAME, "No data found");
+    Dbg(pi_dbg_ctl, "No data found");
     return ret;
   }
 
@@ -162,7 +162,7 @@ MMConditionGeo::get_geo_int(const sockaddr *addr) const
     field_name = "autonomous_system_number";
     break;
   default:
-    TSDebug(PLUGIN_NAME, "Unsupported field %d", _geo_qual);
+    Dbg(pi_dbg_ctl, "Unsupported field %d", _geo_qual);
     return ret;
     break;
   }
@@ -171,7 +171,7 @@ MMConditionGeo::get_geo_int(const sockaddr *addr) const
 
   status = MMDB_get_value(&result.entry, &entry_data, field_name, NULL);
   if (MMDB_SUCCESS != status) {
-    TSDebug(PLUGIN_NAME, "ERROR on get value asn value: %s", MMDB_strerror(status));
+    Dbg(pi_dbg_ctl, "ERROR on get value asn value: %s", MMDB_strerror(status));
     return ret;
   }
   ret = entry_data.uint32;
diff --git a/plugins/header_rewrite/header_rewrite.cc b/plugins/header_rewrite/header_rewrite.cc
index 3bb3bf9ddd7..b6999b3b684 100644
--- a/plugins/header_rewrite/header_rewrite.cc
+++ b/plugins/header_rewrite/header_rewrite.cc
@@ -36,12 +36,18 @@
 const char PLUGIN_NAME[]     = "header_rewrite";
 const char PLUGIN_NAME_DBG[] = "dbg_header_rewrite";
 
+namespace header_rewrite_ns
+{
+DbgCtl dbg_ctl{PLUGIN_NAME_DBG};
+DbgCtl pi_dbg_ctl{PLUGIN_NAME};
+} // namespace header_rewrite_ns
+
 static std::once_flag initGeoLibs;
 
 static void
 initGeoLib(const std::string &dbPath)
 {
-  TSDebug(PLUGIN_NAME, "Loading geo db %s", dbPath.c_str());
+  Dbg(pi_dbg_ctl, "Loading geo db %s", dbPath.c_str());
 #if TS_USE_HRW_GEOIP
   GeoIPConditionGeo::initLibrary(dbPath);
 #elif TS_USE_HRW_MAXMINDDB
@@ -59,7 +65,7 @@ class RulesConfig
 public:
   RulesConfig()
   {
-    TSDebug(PLUGIN_NAME_DBG, "RulesConfig CTOR");
+    Dbg(dbg_ctl, "RulesConfig CTOR");
     memset(_rules, 0, sizeof(_rules));
     memset(_resids, 0, sizeof(_resids));
 
@@ -69,7 +75,7 @@ class RulesConfig
 
   ~RulesConfig()
   {
-    TSDebug(PLUGIN_NAME_DBG, "RulesConfig DTOR");
+    Dbg(dbg_ctl, "RulesConfig DTOR");
     for (int i = TS_HTTP_READ_REQUEST_HDR_HOOK; i <= TS_HTTP_LAST_HOOK; ++i) { // lgtm[cpp/constant-comparison]
       delete _rules[i];
     }
@@ -108,7 +114,7 @@ bool
 RulesConfig::add_rule(RuleSet *rule)
 {
   if (rule && rule->has_operator()) {
-    TSDebug(PLUGIN_NAME_DBG, "   Adding rule to hook=%s", TSHttpHookNameLookup(rule->get_hook()));
+    Dbg(dbg_ctl, "   Adding rule to hook=%s", TSHttpHookNameLookup(rule->get_hook()));
     if (nullptr == _rules[rule->get_hook()]) {
       _rules[rule->get_hook()] = rule;
     } else {
@@ -157,7 +163,7 @@ RulesConfig::parse_config(const std::string &fname, TSHttpHookID default_hook)
 
     getline(f, line);
     ++lineno; // ToDo: we should probably use this for error messages ...
-    TSDebug(PLUGIN_NAME_DBG, "Reading line: %d: %s", lineno, line.c_str());
+    Dbg(dbg_ctl, "Reading line: %d: %s", lineno, line.c_str());
 
     while (std::isspace(line[0])) {
       line.erase(0, 1);
@@ -275,7 +281,7 @@ cont_rewrite_headers(TSCont contp, TSEvent event, void *edata)
     break;
   default:
     TSError("[%s] unknown event for this plugin", PLUGIN_NAME);
-    TSDebug(PLUGIN_NAME, "unknown event for this plugin");
+    Dbg(pi_dbg_ctl, "unknown event for this plugin");
     break;
   }
 
@@ -343,7 +349,7 @@ TSPluginInit(int argc, const char *argv[])
     geoDBpath = std::string(TSConfigDirGet()) + '/' + geoDBpath;
   }
 
-  TSDebug(PLUGIN_NAME, "Global geo db %s", geoDBpath.c_str());
+  Dbg(pi_dbg_ctl, "Global geo db %s", geoDBpath.c_str());
 
   std::call_once(initGeoLibs, [&geoDBpath]() { initGeoLib(geoDBpath); });
 
@@ -355,9 +361,9 @@ TSPluginInit(int argc, const char *argv[])
   for (int i = optind; i < argc; ++i) {
     // Parse the config file(s). Note that multiple config files are
     // just appended to the configurations.
-    TSDebug(PLUGIN_NAME, "Loading global configuration file %s", argv[i]);
+    Dbg(pi_dbg_ctl, "Loading global configuration file %s", argv[i]);
     if (conf->parse_config(argv[i], TS_HTTP_READ_RESPONSE_HDR_HOOK)) {
-      TSDebug(PLUGIN_NAME, "Successfully loaded global config file %s", argv[i]);
+      Dbg(pi_dbg_ctl, "Successfully loaded global config file %s", argv[i]);
       got_config = true;
     } else {
       TSError("[%s] failed to parse configuration file %s", PLUGIN_NAME, argv[i]);
@@ -370,7 +376,7 @@ TSPluginInit(int argc, const char *argv[])
 
     for (int i = TS_HTTP_READ_REQUEST_HDR_HOOK; i < TS_HTTP_LAST_HOOK; ++i) {
       if (conf->rule(i)) {
-        TSDebug(PLUGIN_NAME, "Adding global ruleset to hook=%s", TSHttpHookNameLookup(static_cast<TSHttpHookID>(i)));
+        Dbg(pi_dbg_ctl, "Adding global ruleset to hook=%s", TSHttpHookNameLookup(static_cast<TSHttpHookID>(i)));
         TSHttpHookAdd(static_cast<TSHttpHookID>(i), contp);
       }
     }
@@ -388,7 +394,7 @@ TSReturnCode
 TSRemapInit(TSRemapInterface *api_info, char *errbuf, int errbuf_size)
 {
   CHECK_REMAP_API_COMPATIBILITY(api_info, errbuf, errbuf_size);
-  TSDebug(PLUGIN_NAME, "Remap plugin is successfully initialized");
+  Dbg(pi_dbg_ctl, "Remap plugin is successfully initialized");
 
   return TS_SUCCESS;
 }
@@ -396,7 +402,7 @@ TSRemapInit(TSRemapInterface *api_info, char *errbuf, int errbuf_size)
 TSReturnCode
 TSRemapNewInstance(int argc, char *argv[], void **ih, char * /* errbuf ATS_UNUSED */, int /* errbuf_size ATS_UNUSED */)
 {
-  TSDebug(PLUGIN_NAME, "Instantiating a new remap.config plugin rule");
+  Dbg(pi_dbg_ctl, "Instantiating a new remap.config plugin rule");
 
   if (argc < 3) {
     TSError("[%s] Unable to create remap instance, need config file", PLUGIN_NAME);
@@ -427,7 +433,7 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char * /* errbuf ATS_UNUSE
       geoDBpath = std::string(TSConfigDirGet()) + '/' + geoDBpath;
     }
 
-    TSDebug(PLUGIN_NAME, "Remap geo db %s", geoDBpath.c_str());
+    Dbg(pi_dbg_ctl, "Remap geo db %s", geoDBpath.c_str());
 
     std::call_once(initGeoLibs, [&geoDBpath]() { initGeoLib(geoDBpath); });
   }
@@ -435,21 +441,21 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char * /* errbuf ATS_UNUSE
   RulesConfig *conf = new RulesConfig;
 
   for (int i = optind; i < argc; ++i) {
-    TSDebug(PLUGIN_NAME, "Loading remap configuration file %s", argv[i]);
+    Dbg(pi_dbg_ctl, "Loading remap configuration file %s", argv[i]);
     if (!conf->parse_config(argv[i], TS_REMAP_PSEUDO_HOOK)) {
       TSError("[%s] Unable to create remap instance", PLUGIN_NAME);
       delete conf;
       return TS_ERROR;
     } else {
-      TSDebug(PLUGIN_NAME, "Successfully loaded remap config file %s", argv[i]);
+      Dbg(pi_dbg_ctl, "Successfully loaded remap config file %s", argv[i]);
     }
   }
 
   // For debugging only
-  if (TSIsDebugTagSet(PLUGIN_NAME)) {
+  if (pi_dbg_ctl.on()) {
     for (int i = TS_HTTP_READ_REQUEST_HDR_HOOK; i < TS_HTTP_LAST_HOOK; ++i) {
       if (conf->rule(i)) {
-        TSDebug(PLUGIN_NAME, "Adding remap ruleset to hook=%s", TSHttpHookNameLookup(static_cast<TSHttpHookID>(i)));
+        Dbg(pi_dbg_ctl, "Adding remap ruleset to hook=%s", TSHttpHookNameLookup(static_cast<TSHttpHookID>(i)));
       }
     }
   }
@@ -473,7 +479,7 @@ TSRemapDoRemap(void *ih, TSHttpTxn rh, TSRemapRequestInfo *rri)
 {
   // Make sure things are properly setup (this should never happen)
   if (nullptr == ih) {
-    TSDebug(PLUGIN_NAME, "No Rules configured, falling back to default");
+    Dbg(pi_dbg_ctl, "No Rules configured, falling back to default");
     return TSREMAP_NO_REMAP;
   }
 
@@ -484,7 +490,7 @@ TSRemapDoRemap(void *ih, TSHttpTxn rh, TSRemapRequestInfo *rri)
   for (int i = TS_HTTP_READ_REQUEST_HDR_HOOK; i < TS_HTTP_LAST_HOOK; ++i) {
     if (conf->rule(i)) {
       TSHttpTxnHookAdd(rh, static_cast<TSHttpHookID>(i), conf->continuation());
-      TSDebug(PLUGIN_NAME, "Added remapped TXN hook=%s", TSHttpHookNameLookup(static_cast<TSHttpHookID>(i)));
+      Dbg(pi_dbg_ctl, "Added remapped TXN hook=%s", TSHttpHookNameLookup(static_cast<TSHttpHookID>(i)));
     }
   }
 
@@ -510,6 +516,6 @@ TSRemapDoRemap(void *ih, TSHttpTxn rh, TSRemapRequestInfo *rri)
     rule = rule->next;
   }
 
-  TSDebug(PLUGIN_NAME_DBG, "Returning from TSRemapDoRemap with status: %d", rval);
+  Dbg(dbg_ctl, "Returning from TSRemapDoRemap with status: %d", rval);
   return rval;
 }
diff --git a/plugins/header_rewrite/lulu.h b/plugins/header_rewrite/lulu.h
index cadc9023742..5d3e7e838ec 100644
--- a/plugins/header_rewrite/lulu.h
+++ b/plugins/header_rewrite/lulu.h
@@ -35,3 +35,10 @@ uint16_t getPort(sockaddr const *s_sockaddr);
 
 extern const char PLUGIN_NAME[];
 extern const char PLUGIN_NAME_DBG[];
+
+namespace header_rewrite_ns
+{
+extern DbgCtl dbg_ctl;
+extern DbgCtl pi_dbg_ctl;
+} // namespace header_rewrite_ns
+using namespace header_rewrite_ns;
diff --git a/plugins/header_rewrite/matcher.h b/plugins/header_rewrite/matcher.h
index b50cdaf6975..4b215921060 100644
--- a/plugins/header_rewrite/matcher.h
+++ b/plugins/header_rewrite/matcher.h
@@ -47,8 +47,8 @@ enum MatcherOps {
 class Matcher
 {
 public:
-  explicit Matcher(const MatcherOps op) : _op(op) { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for Matcher"); }
-  virtual ~Matcher() { TSDebug(PLUGIN_NAME_DBG, "Calling DTOR for Matcher"); }
+  explicit Matcher(const MatcherOps op) : _op(op) { Dbg(dbg_ctl, "Calling CTOR for Matcher"); }
+  virtual ~Matcher() { Dbg(dbg_ctl, "Calling DTOR for Matcher"); }
 
   // noncopyable
   Matcher(const Matcher &)        = delete;
@@ -83,10 +83,10 @@ template <class T> class Matchers : public Matcher
       std::stringstream ss;
       ss << _data;
       TSError("[%s] Invalid regex: failed to precompile: %s", PLUGIN_NAME, ss.str().c_str());
-      TSDebug(PLUGIN_NAME, "Invalid regex: failed to precompile: %s", ss.str().c_str());
+      Dbg(pi_dbg_ctl, "Invalid regex: failed to precompile: %s", ss.str().c_str());
       throw std::runtime_error("Malformed regex");
     } else {
-      TSDebug(PLUGIN_NAME, "Regex precompiled successfully");
+      Dbg(pi_dbg_ctl, "Regex precompiled successfully");
     }
   }
 
@@ -146,7 +146,7 @@ template <class T> class Matchers : public Matcher
     std::stringstream ss;
 
     ss << '"' << t << '"' << op << '"' << _data << '"' << " -> " << r;
-    TSDebug(PLUGIN_NAME, "\ttesting: %s", ss.str().c_str());
+    Dbg(pi_dbg_ctl, "\ttesting: %s", ss.str().c_str());
   }
 
   // For basic types
@@ -155,7 +155,7 @@ template <class T> class Matchers : public Matcher
   {
     bool r = (t == _data);
 
-    if (TSIsDebugTagSet(PLUGIN_NAME)) {
+    if (pi_dbg_ctl.on()) {
       debug_helper(t, " == ", r);
     }
     return r;
@@ -166,7 +166,7 @@ template <class T> class Matchers : public Matcher
   {
     bool r = (t < _data);
 
-    if (TSIsDebugTagSet(PLUGIN_NAME)) {
+    if (pi_dbg_ctl.on()) {
       debug_helper(t, " < ", r);
     }
     return r;
@@ -177,7 +177,7 @@ template <class T> class Matchers : public Matcher
   {
     bool r = t > _data;
 
-    if (TSIsDebugTagSet(PLUGIN_NAME)) {
+    if (pi_dbg_ctl.on()) {
       debug_helper(t, " > ", r);
     }
     return r;
@@ -202,9 +202,9 @@ template <class T> class Matchers : public Matcher
   {
     int ovector[OVECCOUNT];
 
-    TSDebug(PLUGIN_NAME, "Test regular expression %s : %s", _data.c_str(), t.c_str());
+    Dbg(pi_dbg_ctl, "Test regular expression %s : %s", _data.c_str(), t.c_str());
     if (reHelper.regexMatch(t.c_str(), t.length(), ovector) > 0) {
-      TSDebug(PLUGIN_NAME, "Successfully found regular expression match");
+      Dbg(pi_dbg_ctl, "Successfully found regular expression match");
       return true;
     }
     return false;
@@ -226,10 +226,10 @@ template <> class Matchers<const sockaddr *> : public Matcher
   {
     if (!extract_ranges(data)) {
       TSError("[%s] Invalid IP-range: failed to parse: %s", PLUGIN_NAME, data.c_str());
-      TSDebug(PLUGIN_NAME, "Invalid IP-range: failed to parse: %s", data.c_str());
+      Dbg(pi_dbg_ctl, "Invalid IP-range: failed to parse: %s", data.c_str());
       throw std::runtime_error("Malformed IP-range");
     } else {
-      TSDebug(PLUGIN_NAME, "IP-range precompiled successfully");
+      Dbg(pi_dbg_ctl, "IP-range precompiled successfully");
     }
   }
 
@@ -237,10 +237,10 @@ template <> class Matchers<const sockaddr *> : public Matcher
   test(const sockaddr *addr) const
   {
     if (ipHelper.contains(swoc::IPAddr(addr))) {
-      if (TSIsDebugTagSet(PLUGIN_NAME)) {
+      if (pi_dbg_ctl.on()) {
         char text[INET6_ADDRSTRLEN];
 
-        TSDebug(PLUGIN_NAME, "Successfully found IP-range match on %s", getIP(addr, text));
+        Dbg(pi_dbg_ctl, "Successfully found IP-range match on %s", getIP(addr, text));
       }
       return true;
     } else {
@@ -259,10 +259,10 @@ template <> class Matchers<const sockaddr *> : public Matcher
     }
 
     if (ipHelper.count() > 0) {
-      TSDebug(PLUGIN_NAME, "    Added %zu IP ranges while parsing", ipHelper.count());
+      Dbg(pi_dbg_ctl, "    Added %zu IP ranges while parsing", ipHelper.count());
       return true;
     } else {
-      TSDebug(PLUGIN_NAME, "    No IP ranges added, possibly bad input");
+      Dbg(pi_dbg_ctl, "    No IP ranges added, possibly bad input");
       return false;
     }
   }
diff --git a/plugins/header_rewrite/operator.h b/plugins/header_rewrite/operator.h
index 6157900293e..3d0b74c0ed5 100644
--- a/plugins/header_rewrite/operator.h
+++ b/plugins/header_rewrite/operator.h
@@ -43,7 +43,7 @@ enum OperModifiers {
 class Operator : public Statement
 {
 public:
-  Operator() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for Operator"); }
+  Operator() { Dbg(dbg_ctl, "Calling CTOR for Operator"); }
 
   // noncopyable
   Operator(const Operator &)       = delete;
@@ -75,7 +75,7 @@ class Operator : public Statement
 class OperatorHeaders : public Operator
 {
 public:
-  OperatorHeaders() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for OperatorHeaders"); }
+  OperatorHeaders() { Dbg(dbg_ctl, "Calling CTOR for OperatorHeaders"); }
 
   // noncopyable
   OperatorHeaders(const OperatorHeaders &) = delete;
@@ -95,7 +95,7 @@ class OperatorHeaders : public Operator
 class OperatorCookies : public Operator
 {
 public:
-  OperatorCookies() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for OperatorCookies"); }
+  OperatorCookies() { Dbg(dbg_ctl, "Calling CTOR for OperatorCookies"); }
 
   // noncopyable
   OperatorCookies(const OperatorCookies &) = delete;
diff --git a/plugins/header_rewrite/operators.cc b/plugins/header_rewrite/operators.cc
index 7abd880be80..9c978d60bb6 100644
--- a/plugins/header_rewrite/operators.cc
+++ b/plugins/header_rewrite/operators.cc
@@ -50,23 +50,23 @@ OperatorSetConfig::exec(const Resources &res) const
     switch (_type) {
     case TS_RECORDDATATYPE_INT:
       if (TS_SUCCESS == TSHttpTxnConfigIntSet(res.txnp, _key, _value.get_int_value())) {
-        TSDebug(PLUGIN_NAME, "OperatorSetConfig::exec() invoked on %s=%d", _config.c_str(), _value.get_int_value());
+        Dbg(pi_dbg_ctl, "OperatorSetConfig::exec() invoked on %s=%d", _config.c_str(), _value.get_int_value());
       } else {
-        TSDebug(PLUGIN_NAME, "OperatorSetConfig::exec() invocation failed on %s=%d", _config.c_str(), _value.get_int_value());
+        Dbg(pi_dbg_ctl, "OperatorSetConfig::exec() invocation failed on %s=%d", _config.c_str(), _value.get_int_value());
       }
       break;
     case TS_RECORDDATATYPE_FLOAT:
       if (TS_SUCCESS == TSHttpTxnConfigFloatSet(res.txnp, _key, _value.get_float_value())) {
-        TSDebug(PLUGIN_NAME, "OperatorSetConfig::exec() invoked on %s=%f", _config.c_str(), _value.get_float_value());
+        Dbg(pi_dbg_ctl, "OperatorSetConfig::exec() invoked on %s=%f", _config.c_str(), _value.get_float_value());
       } else {
-        TSDebug(PLUGIN_NAME, "OperatorSetConfig::exec() invocation failed on %s=%f", _config.c_str(), _value.get_float_value());
+        Dbg(pi_dbg_ctl, "OperatorSetConfig::exec() invocation failed on %s=%f", _config.c_str(), _value.get_float_value());
       }
       break;
     case TS_RECORDDATATYPE_STRING:
       if (TS_SUCCESS == TSHttpTxnConfigStringSet(res.txnp, _key, _value.get_value().c_str(), _value.size())) {
-        TSDebug(PLUGIN_NAME, "OperatorSetConfig::exec() invoked on %s=%s", _config.c_str(), _value.get_value().c_str());
+        Dbg(pi_dbg_ctl, "OperatorSetConfig::exec() invoked on %s=%s", _config.c_str(), _value.get_value().c_str());
       } else {
-        TSDebug(PLUGIN_NAME, "OperatorSetConfig::exec() invocation failed on %s=%s", _config.c_str(), _value.get_value().c_str());
+        Dbg(pi_dbg_ctl, "OperatorSetConfig::exec() invocation failed on %s=%s", _config.c_str(), _value.get_value().c_str());
       }
       break;
     default:
@@ -124,7 +124,7 @@ OperatorSetStatus::exec(const Resources &res) const
     break;
   }
 
-  TSDebug(PLUGIN_NAME, "OperatorSetStatus::exec() invoked with status=%d", _status.get_int_value());
+  Dbg(pi_dbg_ctl, "OperatorSetStatus::exec() invoked with status=%d", _status.get_int_value());
 }
 
 // OperatorSetStatusReason
@@ -153,7 +153,7 @@ OperatorSetStatusReason::exec(const Resources &res) const
 
     _reason.append_value(reason, res);
     if (reason.size() > 0) {
-      TSDebug(PLUGIN_NAME, "Setting Status Reason to %s", reason.c_str());
+      Dbg(pi_dbg_ctl, "Setting Status Reason to %s", reason.c_str());
       TSHttpHdrReasonSet(res.bufp, res.hdr_loc, reason.c_str(), reason.size());
     }
   }
@@ -197,7 +197,7 @@ OperatorSetDestination::exec(const Resources &res) const
     } else {
       bufp = res.bufp;
       if (TSHttpHdrUrlGet(res.bufp, res.hdr_loc, &url_m_loc) != TS_SUCCESS) {
-        TSDebug(PLUGIN_NAME, "TSHttpHdrUrlGet was unable to return the url m_loc");
+        Dbg(pi_dbg_ctl, "TSHttpHdrUrlGet was unable to return the url m_loc");
         return;
       }
     }
@@ -207,35 +207,35 @@ OperatorSetDestination::exec(const Resources &res) const
     case URL_QUAL_HOST:
       _value.append_value(value, res);
       if (value.empty()) {
-        TSDebug(PLUGIN_NAME, "Would set destination HOST to an empty value, skipping");
+        Dbg(pi_dbg_ctl, "Would set destination HOST to an empty value, skipping");
       } else {
         const_cast<Resources &>(res).changed_url = true;
         TSUrlHostSet(bufp, url_m_loc, value.c_str(), value.size());
-        TSDebug(PLUGIN_NAME, "OperatorSetDestination::exec() invoked with HOST: %s", value.c_str());
+        Dbg(pi_dbg_ctl, "OperatorSetDestination::exec() invoked with HOST: %s", value.c_str());
       }
       break;
 
     case URL_QUAL_PATH:
       _value.append_value(value, res);
       if (value.empty()) {
-        TSDebug(PLUGIN_NAME, "Would set destination PATH to an empty value, skipping");
+        Dbg(pi_dbg_ctl, "Would set destination PATH to an empty value, skipping");
       } else {
         const_cast<Resources &>(res).changed_url = true;
         TSUrlPathSet(bufp, url_m_loc, value.c_str(), value.size());
-        TSDebug(PLUGIN_NAME, "OperatorSetDestination::exec() invoked with PATH: %s", value.c_str());
+        Dbg(pi_dbg_ctl, "OperatorSetDestination::exec() invoked with PATH: %s", value.c_str());
       }
       break;
 
     case URL_QUAL_QUERY:
       _value.append_value(value, res);
       if (value.empty()) {
-        TSDebug(PLUGIN_NAME, "Would set destination QUERY to an empty value, skipping");
+        Dbg(pi_dbg_ctl, "Would set destination QUERY to an empty value, skipping");
       } else {
         // 1.6.4--Support for preserving QSA in case of set-destination
         if (get_oper_modifiers() & OPER_QSA) {
           int query_len     = 0;
           const char *query = TSUrlHttpQueryGet(bufp, url_m_loc, &query_len);
-          TSDebug(PLUGIN_NAME, "QSA mode, append original query string: %.*s", query_len, query);
+          Dbg(pi_dbg_ctl, "QSA mode, append original query string: %.*s", query_len, query);
           // std::string connector = (value.find("?") == std::string::npos)? "?" : "&";
           value.append("&");
           value.append(query, query_len);
@@ -243,51 +243,51 @@ OperatorSetDestination::exec(const Resources &res) const
 
         const_cast<Resources &>(res).changed_url = true;
         TSUrlHttpQuerySet(bufp, url_m_loc, value.c_str(), value.size());
-        TSDebug(PLUGIN_NAME, "OperatorSetDestination::exec() invoked with QUERY: %s", value.c_str());
+        Dbg(pi_dbg_ctl, "OperatorSetDestination::exec() invoked with QUERY: %s", value.c_str());
       }
       break;
 
     case URL_QUAL_PORT:
       if (_value.get_int_value() <= 0 || _value.get_int_value() > 0xFFFF) {
-        TSDebug(PLUGIN_NAME, "Would set destination PORT to an invalid range, skipping");
+        Dbg(pi_dbg_ctl, "Would set destination PORT to an invalid range, skipping");
       } else {
         const_cast<Resources &>(res).changed_url = true;
         TSUrlPortSet(bufp, url_m_loc, _value.get_int_value());
-        TSDebug(PLUGIN_NAME, "OperatorSetDestination::exec() invoked with PORT: %d", _value.get_int_value());
+        Dbg(pi_dbg_ctl, "OperatorSetDestination::exec() invoked with PORT: %d", _value.get_int_value());
       }
       break;
     case URL_QUAL_URL:
       _value.append_value(value, res);
       if (value.empty()) {
-        TSDebug(PLUGIN_NAME, "Would set destination URL to an empty value, skipping");
+        Dbg(pi_dbg_ctl, "Would set destination URL to an empty value, skipping");
       } else {
         const char *start = value.c_str();
         const char *end   = start + value.size();
         TSMLoc new_url_loc;
         if (TSUrlCreate(bufp, &new_url_loc) == TS_SUCCESS && TSUrlParse(bufp, new_url_loc, &start, end) == TS_PARSE_DONE &&
             TSHttpHdrUrlSet(bufp, res.hdr_loc, new_url_loc) == TS_SUCCESS) {
-          TSDebug(PLUGIN_NAME, "Set destination URL to %s", value.c_str());
+          Dbg(pi_dbg_ctl, "Set destination URL to %s", value.c_str());
         } else {
-          TSDebug(PLUGIN_NAME, "Failed to set URL %s", value.c_str());
+          Dbg(pi_dbg_ctl, "Failed to set URL %s", value.c_str());
         }
       }
       break;
     case URL_QUAL_SCHEME:
       _value.append_value(value, res);
       if (value.empty()) {
-        TSDebug(PLUGIN_NAME, "Would set destination SCHEME to an empty value, skipping");
+        Dbg(pi_dbg_ctl, "Would set destination SCHEME to an empty value, skipping");
       } else {
         TSUrlSchemeSet(bufp, url_m_loc, value.c_str(), value.length());
-        TSDebug(PLUGIN_NAME, "OperatorSetDestination::exec() invoked with SCHEME: %s", value.c_str());
+        Dbg(pi_dbg_ctl, "OperatorSetDestination::exec() invoked with SCHEME: %s", value.c_str());
       }
       break;
     default:
-      TSDebug(PLUGIN_NAME, "Set destination %i has no handler", _url_qual);
+      Dbg(pi_dbg_ctl, "Set destination %i has no handler", _url_qual);
       break;
     }
   } else {
-    TSDebug(PLUGIN_NAME, "OperatorSetDestination::exec() unable to continue due to missing bufp=%p or hdr_loc=%p, rri=%p!",
-            res.bufp, res.hdr_loc, res._rri);
+    Dbg(pi_dbg_ctl, "OperatorSetDestination::exec() unable to continue due to missing bufp=%p or hdr_loc=%p, rri=%p!", res.bufp,
+        res.hdr_loc, res._rri);
   }
 }
 
@@ -307,7 +307,7 @@ OperatorRMDestination::exec(const Resources &res) const
     } else {
       bufp = res.bufp;
       if (TSHttpHdrUrlGet(res.bufp, res.hdr_loc, &url_m_loc) != TS_SUCCESS) {
-        TSDebug(PLUGIN_NAME, "TSHttpHdrUrlGet was unable to return the url m_loc");
+        Dbg(pi_dbg_ctl, "TSHttpHdrUrlGet was unable to return the url m_loc");
         return;
       }
     }
@@ -317,25 +317,25 @@ OperatorRMDestination::exec(const Resources &res) const
     case URL_QUAL_PATH:
       const_cast<Resources &>(res).changed_url = true;
       TSUrlPathSet(bufp, url_m_loc, value.c_str(), value.size());
-      TSDebug(PLUGIN_NAME, "OperatorRMDestination::exec() deleting PATH");
+      Dbg(pi_dbg_ctl, "OperatorRMDestination::exec() deleting PATH");
       break;
     case URL_QUAL_QUERY:
       const_cast<Resources &>(res).changed_url = true;
       TSUrlHttpQuerySet(bufp, url_m_loc, value.c_str(), value.size());
-      TSDebug(PLUGIN_NAME, "OperatorRMDestination::exec() deleting QUERY");
+      Dbg(pi_dbg_ctl, "OperatorRMDestination::exec() deleting QUERY");
       break;
     case URL_QUAL_PORT:
       const_cast<Resources &>(res).changed_url = true;
       TSUrlPortSet(bufp, url_m_loc, 0);
-      TSDebug(PLUGIN_NAME, "OperatorRMDestination::exec() deleting PORT");
+      Dbg(pi_dbg_ctl, "OperatorRMDestination::exec() deleting PORT");
       break;
     default:
-      TSDebug(PLUGIN_NAME, "RM Destination %i has no handler", _url_qual);
+      Dbg(pi_dbg_ctl, "RM Destination %i has no handler", _url_qual);
       break;
     }
   } else {
-    TSDebug(PLUGIN_NAME, "OperatorRMDestination::exec() unable to continue due to missing bufp=%p or hdr_loc=%p, rri=%p!", res.bufp,
-            res.hdr_loc, res._rri);
+    Dbg(pi_dbg_ctl, "OperatorRMDestination::exec() unable to continue due to missing bufp=%p or hdr_loc=%p, rri=%p!", res.bufp,
+        res.hdr_loc, res._rri);
   }
 }
 
@@ -366,7 +366,7 @@ EditRedirectResponse(TSHttpTxn txnp, const std::string &location, TSHttpStatus s
   static std::string header("Location");
   if (TS_SUCCESS == TSMimeHdrFieldCreateNamed(bufp, hdr_loc, header.c_str(), header.size(), &field_loc)) {
     if (TS_SUCCESS == TSMimeHdrFieldValueStringSet(bufp, hdr_loc, field_loc, -1, location.c_str(), location.size())) {
-      TSDebug(PLUGIN_NAME, "   Adding header %s", header.c_str());
+      Dbg(pi_dbg_ctl, "   Adding header %s", header.c_str());
       TSMimeHdrFieldAppend(bufp, hdr_loc, field_loc);
     }
     const char *reason = TSHttpHdrReasonLookup(status);
@@ -400,7 +400,7 @@ cont_add_location(TSCont contp, TSEvent event, void *edata)
     if (TSHttpTxnClientRespGet(txnp, &bufp, &hdr_loc) == TS_SUCCESS) {
       EditRedirectResponse(txnp, osd->get_location(), status, bufp, hdr_loc);
     } else {
-      TSDebug(PLUGIN_NAME, "Could not retrieve the response header");
+      Dbg(pi_dbg_ctl, "Could not retrieve the response header");
     }
 
   } break;
@@ -425,9 +425,9 @@ OperatorSetRedirect::exec(const Resources &res) const
     bool remap = false;
     if (nullptr != res._rri) {
       remap = true;
-      TSDebug(PLUGIN_NAME, "OperatorSetRedirect:exec() invoked from remap plugin");
+      Dbg(pi_dbg_ctl, "OperatorSetRedirect:exec() invoked from remap plugin");
     } else {
-      TSDebug(PLUGIN_NAME, "OperatorSetRedirect:exec() not invoked from remap plugin");
+      Dbg(pi_dbg_ctl, "OperatorSetRedirect:exec() not invoked from remap plugin");
     }
 
     TSMBuffer bufp;
@@ -440,7 +440,7 @@ OperatorSetRedirect::exec(const Resources &res) const
       // Handle when not called from remap plugin.
       bufp = res.client_bufp;
       if (TS_SUCCESS != TSHttpHdrUrlGet(res.client_bufp, res.client_hdr_loc, &url_loc)) {
-        TSDebug(PLUGIN_NAME, "Could not get client URL");
+        Dbg(pi_dbg_ctl, "Could not get client URL");
       }
     }
 
@@ -451,7 +451,7 @@ OperatorSetRedirect::exec(const Resources &res) const
       int path_len     = 0;
       const char *path = TSUrlPathGet(bufp, url_loc, &path_len);
       if (path_len > 0) {
-        TSDebug(PLUGIN_NAME, "Find %%{PATH} in redirect url, replace it with: %.*s", path_len, path);
+        Dbg(pi_dbg_ctl, "Find %%{PATH} in redirect url, replace it with: %.*s", path_len, path);
         value.insert(pos_path, path, path_len);
       }
     }
@@ -461,7 +461,7 @@ OperatorSetRedirect::exec(const Resources &res) const
     const char *query = TSUrlHttpQueryGet(bufp, url_loc, &query_len);
 
     if ((get_oper_modifiers() & OPER_QSA) && (query_len > 0)) {
-      TSDebug(PLUGIN_NAME, "QSA mode, append original query string: %.*s", query_len, query);
+      Dbg(pi_dbg_ctl, "QSA mode, append original query string: %.*s", query_len, query);
       std::string connector = (value.find('?') == std::string::npos) ? "?" : "&";
       value.append(connector);
       value.append(query, query_len);
@@ -473,7 +473,7 @@ OperatorSetRedirect::exec(const Resources &res) const
     if (remap) {
       // Set new location.
       if (TS_PARSE_ERROR == TSUrlParse(bufp, url_loc, &start, end)) {
-        TSDebug(PLUGIN_NAME, "Could not set Location field value to: %s", value.c_str());
+        Dbg(pi_dbg_ctl, "Could not set Location field value to: %s", value.c_str());
       }
       // Set the new status.
       TSHttpTxnStatusSet(res.txnp, static_cast<TSHttpStatus>(_status.get_int_value()));
@@ -498,8 +498,8 @@ OperatorSetRedirect::exec(const Resources &res) const
       TSHttpHdrStatusSet(res.bufp, res.hdr_loc, status);
       EditRedirectResponse(res.txnp, value, status, res.bufp, res.hdr_loc);
     }
-    TSDebug(PLUGIN_NAME, "OperatorSetRedirect::exec() invoked with destination=%s and status code=%d", value.c_str(),
-            _status.get_int_value());
+    Dbg(pi_dbg_ctl, "OperatorSetRedirect::exec() invoked with destination=%s and status code=%d", value.c_str(),
+        _status.get_int_value());
   }
 }
 
@@ -530,22 +530,22 @@ OperatorSetTimeoutOut::exec(const Resources &res) const
 {
   switch (_type) {
   case TO_OUT_ACTIVE:
-    TSDebug(PLUGIN_NAME, "OperatorSetTimeoutOut::exec(active, %d)", _timeout.get_int_value());
+    Dbg(pi_dbg_ctl, "OperatorSetTimeoutOut::exec(active, %d)", _timeout.get_int_value());
     TSHttpTxnActiveTimeoutSet(res.txnp, _timeout.get_int_value());
     break;
 
   case TO_OUT_INACTIVE:
-    TSDebug(PLUGIN_NAME, "OperatorSetTimeoutOut::exec(inactive, %d)", _timeout.get_int_value());
+    Dbg(pi_dbg_ctl, "OperatorSetTimeoutOut::exec(inactive, %d)", _timeout.get_int_value());
     TSHttpTxnNoActivityTimeoutSet(res.txnp, _timeout.get_int_value());
     break;
 
   case TO_OUT_CONNECT:
-    TSDebug(PLUGIN_NAME, "OperatorSetTimeoutOut::exec(connect, %d)", _timeout.get_int_value());
+    Dbg(pi_dbg_ctl, "OperatorSetTimeoutOut::exec(connect, %d)", _timeout.get_int_value());
     TSHttpTxnConnectTimeoutSet(res.txnp, _timeout.get_int_value());
     break;
 
   case TO_OUT_DNS:
-    TSDebug(PLUGIN_NAME, "OperatorSetTimeoutOut::exec(dns, %d)", _timeout.get_int_value());
+    Dbg(pi_dbg_ctl, "OperatorSetTimeoutOut::exec(dns, %d)", _timeout.get_int_value());
     TSHttpTxnDNSTimeoutSet(res.txnp, _timeout.get_int_value());
     break;
   default:
@@ -569,7 +569,7 @@ OperatorSkipRemap::initialize(Parser &p)
 void
 OperatorSkipRemap::exec(const Resources &res) const
 {
-  TSDebug(PLUGIN_NAME, "OperatorSkipRemap::exec() skipping remap: %s", _skip_remap ? "True" : "False");
+  Dbg(pi_dbg_ctl, "OperatorSkipRemap::exec() skipping remap: %s", _skip_remap ? "True" : "False");
   TSHttpTxnCntlSet(res.txnp, TS_HTTP_CNTL_SKIP_REMAPPING, _skip_remap);
 }
 
@@ -580,10 +580,10 @@ OperatorRMHeader::exec(const Resources &res) const
   TSMLoc field_loc, tmp;
 
   if (res.bufp && res.hdr_loc) {
-    TSDebug(PLUGIN_NAME, "OperatorRMHeader::exec() invoked on %s", _header.c_str());
+    Dbg(pi_dbg_ctl, "OperatorRMHeader::exec() invoked on %s", _header.c_str());
     field_loc = TSMimeHdrFieldFind(res.bufp, res.hdr_loc, _header.c_str(), _header.size());
     while (field_loc) {
-      TSDebug(PLUGIN_NAME, "   Deleting header %s", _header.c_str());
+      Dbg(pi_dbg_ctl, "   Deleting header %s", _header.c_str());
       tmp = TSMimeHdrFieldNextDup(res.bufp, res.hdr_loc, field_loc);
       TSMimeHdrFieldDestroy(res.bufp, res.hdr_loc, field_loc);
       TSHandleMLocRelease(res.bufp, res.hdr_loc, field_loc);
@@ -610,17 +610,17 @@ OperatorAddHeader::exec(const Resources &res) const
 
   // Never set an empty header (I don't think that ever makes sense?)
   if (value.empty()) {
-    TSDebug(PLUGIN_NAME, "Would set header %s to an empty value, skipping", _header.c_str());
+    Dbg(pi_dbg_ctl, "Would set header %s to an empty value, skipping", _header.c_str());
     return;
   }
 
   if (res.bufp && res.hdr_loc) {
-    TSDebug(PLUGIN_NAME, "OperatorAddHeader::exec() invoked on %s: %s", _header.c_str(), value.c_str());
+    Dbg(pi_dbg_ctl, "OperatorAddHeader::exec() invoked on %s: %s", _header.c_str(), value.c_str());
     TSMLoc field_loc;
 
     if (TS_SUCCESS == TSMimeHdrFieldCreateNamed(res.bufp, res.hdr_loc, _header.c_str(), _header.size(), &field_loc)) {
       if (TS_SUCCESS == TSMimeHdrFieldValueStringSet(res.bufp, res.hdr_loc, field_loc, -1, value.c_str(), value.size())) {
-        TSDebug(PLUGIN_NAME, "   Adding header %s", _header.c_str());
+        Dbg(pi_dbg_ctl, "   Adding header %s", _header.c_str());
         TSMimeHdrFieldAppend(res.bufp, res.hdr_loc, field_loc);
       }
       TSHandleMLocRelease(res.bufp, res.hdr_loc, field_loc);
@@ -646,20 +646,20 @@ OperatorSetHeader::exec(const Resources &res) const
 
   // Never set an empty header (I don't think that ever makes sense?)
   if (value.empty()) {
-    TSDebug(PLUGIN_NAME, "Would set header %s to an empty value, skipping", _header.c_str());
+    Dbg(pi_dbg_ctl, "Would set header %s to an empty value, skipping", _header.c_str());
     return;
   }
 
   if (res.bufp && res.hdr_loc) {
     TSMLoc field_loc = TSMimeHdrFieldFind(res.bufp, res.hdr_loc, _header_wks ? _header_wks : _header.c_str(), _header.size());
 
-    TSDebug(PLUGIN_NAME, "OperatorSetHeader::exec() invoked on %s: %s", _header.c_str(), value.c_str());
+    Dbg(pi_dbg_ctl, "OperatorSetHeader::exec() invoked on %s: %s", _header.c_str(), value.c_str());
 
     if (!field_loc) {
       // No existing header, so create one
       if (TS_SUCCESS == TSMimeHdrFieldCreateNamed(res.bufp, res.hdr_loc, _header.c_str(), _header.size(), &field_loc)) {
         if (TS_SUCCESS == TSMimeHdrFieldValueStringSet(res.bufp, res.hdr_loc, field_loc, -1, value.c_str(), value.size())) {
-          TSDebug(PLUGIN_NAME, "   Adding header %s", _header.c_str());
+          Dbg(pi_dbg_ctl, "   Adding header %s", _header.c_str());
           TSMimeHdrFieldAppend(res.bufp, res.hdr_loc, field_loc);
         }
         TSHandleMLocRelease(res.bufp, res.hdr_loc, field_loc);
@@ -673,7 +673,7 @@ OperatorSetHeader::exec(const Resources &res) const
         if (first) {
           first = false;
           if (TS_SUCCESS == TSMimeHdrFieldValueStringSet(res.bufp, res.hdr_loc, field_loc, -1, value.c_str(), value.size())) {
-            TSDebug(PLUGIN_NAME, "   Overwriting header %s", _header.c_str());
+            Dbg(pi_dbg_ctl, "   Overwriting header %s", _header.c_str());
           }
         } else {
           TSMimeHdrFieldDestroy(res.bufp, res.hdr_loc, field_loc);
@@ -732,9 +732,9 @@ OperatorCounter::initialize(Parser &p)
       TSError("[%s] TSStatCreate() failed. Can't create counter: %s", PLUGIN_NAME, _counter_name.c_str());
       return;
     }
-    TSDebug(PLUGIN_NAME, "OperatorCounter::initialize(%s) created counter with id: %d", _counter_name.c_str(), _counter);
+    Dbg(pi_dbg_ctl, "OperatorCounter::initialize(%s) created counter with id: %d", _counter_name.c_str(), _counter);
   } else {
-    TSDebug(PLUGIN_NAME, "OperatorCounter::initialize(%s) reusing id: %d", _counter_name.c_str(), _counter);
+    Dbg(pi_dbg_ctl, "OperatorCounter::initialize(%s) reusing id: %d", _counter_name.c_str(), _counter);
   }
 }
 
@@ -746,7 +746,7 @@ OperatorCounter::exec(const Resources & /* ATS_UNUSED res */) const
     return;
   }
 
-  TSDebug(PLUGIN_NAME, "OperatorCounter::exec() invoked on %s", _counter_name.c_str());
+  Dbg(pi_dbg_ctl, "OperatorCounter::exec() invoked on %s", _counter_name.c_str());
   TSStatIntIncrement(_counter, 1);
 }
 
@@ -755,13 +755,13 @@ void
 OperatorRMCookie::exec(const Resources &res) const
 {
   if (res.bufp && res.hdr_loc) {
-    TSDebug(PLUGIN_NAME, "OperatorRMCookie::exec() invoked on cookie %s", _cookie.c_str());
+    Dbg(pi_dbg_ctl, "OperatorRMCookie::exec() invoked on cookie %s", _cookie.c_str());
     TSMLoc field_loc;
 
     // Find Cookie
     field_loc = TSMimeHdrFieldFind(res.bufp, res.hdr_loc, TS_MIME_FIELD_COOKIE, TS_MIME_LEN_COOKIE);
     if (nullptr == field_loc) {
-      TSDebug(PLUGIN_NAME, "OperatorRMCookie::exec, no cookie");
+      Dbg(pi_dbg_ctl, "OperatorRMCookie::exec, no cookie");
       return;
     }
 
@@ -771,11 +771,11 @@ OperatorRMCookie::exec(const Resources &res) const
     if (CookieHelper::cookieModifyHelper(cookies, cookies_len, updated_cookie, CookieHelper::COOKIE_OP_DEL, _cookie)) {
       if (updated_cookie.empty()) {
         if (TS_SUCCESS == TSMimeHdrFieldDestroy(res.bufp, res.hdr_loc, field_loc)) {
-          TSDebug(PLUGIN_NAME, "OperatorRMCookie::exec, empty cookie deleted");
+          Dbg(pi_dbg_ctl, "OperatorRMCookie::exec, empty cookie deleted");
         }
       } else if (TS_SUCCESS == TSMimeHdrFieldValueStringSet(res.bufp, res.hdr_loc, field_loc, -1, updated_cookie.c_str(),
                                                             updated_cookie.size())) {
-        TSDebug(PLUGIN_NAME, "OperatorRMCookie::exec, updated_cookie = [%s]", updated_cookie.c_str());
+        Dbg(pi_dbg_ctl, "OperatorRMCookie::exec, updated_cookie = [%s]", updated_cookie.c_str());
       }
     }
     TSHandleMLocRelease(res.bufp, res.hdr_loc, field_loc);
@@ -798,17 +798,17 @@ OperatorAddCookie::exec(const Resources &res) const
   _value.append_value(value, res);
 
   if (res.bufp && res.hdr_loc) {
-    TSDebug(PLUGIN_NAME, "OperatorAddCookie::exec() invoked on cookie %s", _cookie.c_str());
+    Dbg(pi_dbg_ctl, "OperatorAddCookie::exec() invoked on cookie %s", _cookie.c_str());
     TSMLoc field_loc;
 
     // Find Cookie
     field_loc = TSMimeHdrFieldFind(res.bufp, res.hdr_loc, TS_MIME_FIELD_COOKIE, TS_MIME_LEN_COOKIE);
     if (nullptr == field_loc) {
-      TSDebug(PLUGIN_NAME, "OperatorAddCookie::exec, no cookie");
+      Dbg(pi_dbg_ctl, "OperatorAddCookie::exec, no cookie");
       if (TS_SUCCESS == TSMimeHdrFieldCreateNamed(res.bufp, res.hdr_loc, TS_MIME_FIELD_COOKIE, TS_MIME_LEN_COOKIE, &field_loc)) {
         value = _cookie + '=' + value;
         if (TS_SUCCESS == TSMimeHdrFieldValueStringSet(res.bufp, res.hdr_loc, field_loc, -1, value.c_str(), value.size())) {
-          TSDebug(PLUGIN_NAME, "Adding cookie %s", _cookie.c_str());
+          Dbg(pi_dbg_ctl, "Adding cookie %s", _cookie.c_str());
           TSMimeHdrFieldAppend(res.bufp, res.hdr_loc, field_loc);
         }
         TSHandleMLocRelease(res.bufp, res.hdr_loc, field_loc);
@@ -822,7 +822,7 @@ OperatorAddCookie::exec(const Resources &res) const
     if (CookieHelper::cookieModifyHelper(cookies, cookies_len, updated_cookie, CookieHelper::COOKIE_OP_ADD, _cookie, value) &&
         TS_SUCCESS ==
           TSMimeHdrFieldValueStringSet(res.bufp, res.hdr_loc, field_loc, -1, updated_cookie.c_str(), updated_cookie.size())) {
-      TSDebug(PLUGIN_NAME, "OperatorAddCookie::exec, updated_cookie = [%s]", updated_cookie.c_str());
+      Dbg(pi_dbg_ctl, "OperatorAddCookie::exec, updated_cookie = [%s]", updated_cookie.c_str());
     }
   }
 }
@@ -843,17 +843,17 @@ OperatorSetCookie::exec(const Resources &res) const
   _value.append_value(value, res);
 
   if (res.bufp && res.hdr_loc) {
-    TSDebug(PLUGIN_NAME, "OperatorSetCookie::exec() invoked on cookie %s", _cookie.c_str());
+    Dbg(pi_dbg_ctl, "OperatorSetCookie::exec() invoked on cookie %s", _cookie.c_str());
     TSMLoc field_loc;
 
     // Find Cookie
     field_loc = TSMimeHdrFieldFind(res.bufp, res.hdr_loc, TS_MIME_FIELD_COOKIE, TS_MIME_LEN_COOKIE);
     if (nullptr == field_loc) {
-      TSDebug(PLUGIN_NAME, "OperatorSetCookie::exec, no cookie");
+      Dbg(pi_dbg_ctl, "OperatorSetCookie::exec, no cookie");
       if (TS_SUCCESS == TSMimeHdrFieldCreateNamed(res.bufp, res.hdr_loc, TS_MIME_FIELD_COOKIE, TS_MIME_LEN_COOKIE, &field_loc)) {
         value = _cookie + "=" + value;
         if (TS_SUCCESS == TSMimeHdrFieldValueStringSet(res.bufp, res.hdr_loc, field_loc, -1, value.c_str(), value.size())) {
-          TSDebug(PLUGIN_NAME, "Adding cookie %s", _cookie.c_str());
+          Dbg(pi_dbg_ctl, "Adding cookie %s", _cookie.c_str());
           TSMimeHdrFieldAppend(res.bufp, res.hdr_loc, field_loc);
         }
         TSHandleMLocRelease(res.bufp, res.hdr_loc, field_loc);
@@ -867,7 +867,7 @@ OperatorSetCookie::exec(const Resources &res) const
     if (CookieHelper::cookieModifyHelper(cookies, cookies_len, updated_cookie, CookieHelper::COOKIE_OP_SET, _cookie, value) &&
         TS_SUCCESS ==
           TSMimeHdrFieldValueStringSet(res.bufp, res.hdr_loc, field_loc, -1, updated_cookie.c_str(), updated_cookie.size())) {
-      TSDebug(PLUGIN_NAME, "OperatorSetCookie::exec, updated_cookie = [%s]", updated_cookie.c_str());
+      Dbg(pi_dbg_ctl, "OperatorSetCookie::exec, updated_cookie = [%s]", updated_cookie.c_str());
     }
     TSHandleMLocRelease(res.bufp, res.hdr_loc, field_loc);
   }
@@ -879,7 +879,7 @@ CookieHelper::cookieModifyHelper(const char *cookies, const size_t cookies_len,
                                  const std::string &cookie_value)
 {
   if (0 == cookie_key.size()) {
-    TSDebug(PLUGIN_NAME, "CookieHelper::cookieModifyHelper, empty cookie_key");
+    Dbg(pi_dbg_ctl, "CookieHelper::cookieModifyHelper, empty cookie_key");
     return false;
   }
 
@@ -985,7 +985,7 @@ OperatorSetConnDSCP::exec(const Resources &res) const
 {
   if (res.txnp) {
     TSHttpTxnClientPacketDscpSet(res.txnp, _ds_value.get_int_value());
-    TSDebug(PLUGIN_NAME, "   Setting DSCP to %d", _ds_value.get_int_value());
+    Dbg(pi_dbg_ctl, "   Setting DSCP to %d", _ds_value.get_int_value());
   }
 }
 
@@ -1011,7 +1011,7 @@ OperatorSetConnMark::exec(const Resources &res) const
 {
   if (res.txnp) {
     TSHttpTxnClientPacketMarkSet(res.txnp, _ds_value.get_int_value());
-    TSDebug(PLUGIN_NAME, "   Setting MARK to %d", _ds_value.get_int_value());
+    Dbg(pi_dbg_ctl, "   Setting MARK to %d", _ds_value.get_int_value());
   }
 }
 
@@ -1097,9 +1097,9 @@ OperatorSetHttpCntl::exec(const Resources &res) const
 {
   if (_flag) {
     TSHttpTxnCntlSet(res.txnp, _cntl_qual, true);
-    TSDebug(PLUGIN_NAME, "   Turning ON %s for transaction", HttpCntls[static_cast<size_t>(_cntl_qual)]);
+    Dbg(pi_dbg_ctl, "   Turning ON %s for transaction", HttpCntls[static_cast<size_t>(_cntl_qual)]);
   } else {
     TSHttpTxnCntlSet(res.txnp, _cntl_qual, false);
-    TSDebug(PLUGIN_NAME, "   Turning OFF %s for transaction", HttpCntls[static_cast<size_t>(_cntl_qual)]);
+    Dbg(pi_dbg_ctl, "   Turning OFF %s for transaction", HttpCntls[static_cast<size_t>(_cntl_qual)]);
   }
 }
diff --git a/plugins/header_rewrite/operators.h b/plugins/header_rewrite/operators.h
index ba9256e91e4..5dbdbb2b5d6 100644
--- a/plugins/header_rewrite/operators.h
+++ b/plugins/header_rewrite/operators.h
@@ -35,7 +35,7 @@
 class OperatorSetConfig : public Operator
 {
 public:
-  OperatorSetConfig() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for OperatorSetConfig"); }
+  OperatorSetConfig() { Dbg(dbg_ctl, "Calling CTOR for OperatorSetConfig"); }
 
   // noncopyable
   OperatorSetConfig(const OperatorSetConfig &) = delete;
@@ -57,7 +57,7 @@ class OperatorSetConfig : public Operator
 class OperatorSetStatus : public Operator
 {
 public:
-  OperatorSetStatus() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for OperatorSetStatus"); }
+  OperatorSetStatus() { Dbg(dbg_ctl, "Calling CTOR for OperatorSetStatus"); }
 
   // noncopyable
   OperatorSetStatus(const OperatorSetStatus &) = delete;
@@ -78,7 +78,7 @@ class OperatorSetStatus : public Operator
 class OperatorSetStatusReason : public Operator
 {
 public:
-  OperatorSetStatusReason() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for OperatorSetStatusReason"); }
+  OperatorSetStatusReason() { Dbg(dbg_ctl, "Calling CTOR for OperatorSetStatusReason"); }
 
   // noncopyable
   OperatorSetStatusReason(const OperatorSetStatusReason &) = delete;
@@ -97,7 +97,7 @@ class OperatorSetStatusReason : public Operator
 class OperatorSetDestination : public Operator
 {
 public:
-  OperatorSetDestination() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for OperatorSetDestination"); }
+  OperatorSetDestination() { Dbg(dbg_ctl, "Calling CTOR for OperatorSetDestination"); }
 
   // noncopyable
   OperatorSetDestination(const OperatorSetDestination &) = delete;
@@ -117,7 +117,7 @@ class OperatorSetDestination : public Operator
 class OperatorRMDestination : public Operator
 {
 public:
-  OperatorRMDestination() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for OperatorRMDestination"); }
+  OperatorRMDestination() { Dbg(dbg_ctl, "Calling CTOR for OperatorRMDestination"); }
 
   // noncopyable
   OperatorRMDestination(const OperatorRMDestination &) = delete;
@@ -135,7 +135,7 @@ class OperatorRMDestination : public Operator
 class OperatorSetRedirect : public Operator
 {
 public:
-  OperatorSetRedirect() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for OperatorSetRedirect"); }
+  OperatorSetRedirect() { Dbg(dbg_ctl, "Calling CTOR for OperatorSetRedirect"); }
 
   // noncopyable
   OperatorSetRedirect(const OperatorSetRedirect &) = delete;
@@ -166,7 +166,7 @@ class OperatorSetRedirect : public Operator
 class OperatorNoOp : public Operator
 {
 public:
-  OperatorNoOp() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for OperatorNoOp"); }
+  OperatorNoOp() { Dbg(dbg_ctl, "Calling CTOR for OperatorNoOp"); }
 
   // noncopyable
   OperatorNoOp(const OperatorNoOp &)   = delete;
@@ -179,7 +179,7 @@ class OperatorNoOp : public Operator
 class OperatorSetTimeoutOut : public Operator
 {
 public:
-  OperatorSetTimeoutOut() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for OperatorSetTimeoutOut"); }
+  OperatorSetTimeoutOut() { Dbg(dbg_ctl, "Calling CTOR for OperatorSetTimeoutOut"); }
 
   // noncopyable
   OperatorSetTimeoutOut(const OperatorSetTimeoutOut &) = delete;
@@ -206,7 +206,7 @@ class OperatorSetTimeoutOut : public Operator
 class OperatorSkipRemap : public Operator
 {
 public:
-  OperatorSkipRemap() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for OperatorSkipRemap"); }
+  OperatorSkipRemap() { Dbg(dbg_ctl, "Calling CTOR for OperatorSkipRemap"); }
 
   // noncopyable
   OperatorSkipRemap(const OperatorSkipRemap &) = delete;
@@ -225,7 +225,7 @@ class OperatorSkipRemap : public Operator
 class OperatorRMHeader : public OperatorHeaders
 {
 public:
-  OperatorRMHeader() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for OperatorRMHeader"); }
+  OperatorRMHeader() { Dbg(dbg_ctl, "Calling CTOR for OperatorRMHeader"); }
 
   // noncopyable
   OperatorRMHeader(const OperatorRMHeader &) = delete;
@@ -238,7 +238,7 @@ class OperatorRMHeader : public OperatorHeaders
 class OperatorAddHeader : public OperatorHeaders
 {
 public:
-  OperatorAddHeader() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for OperatorAddHeader"); }
+  OperatorAddHeader() { Dbg(dbg_ctl, "Calling CTOR for OperatorAddHeader"); }
 
   // noncopyable
   OperatorAddHeader(const OperatorAddHeader &) = delete;
@@ -256,7 +256,7 @@ class OperatorAddHeader : public OperatorHeaders
 class OperatorSetHeader : public OperatorHeaders
 {
 public:
-  OperatorSetHeader() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for OperatorSetHeader"); }
+  OperatorSetHeader() { Dbg(dbg_ctl, "Calling CTOR for OperatorSetHeader"); }
 
   // noncopyable
   OperatorSetHeader(const OperatorSetHeader &) = delete;
@@ -274,7 +274,7 @@ class OperatorSetHeader : public OperatorHeaders
 class OperatorCounter : public Operator
 {
 public:
-  OperatorCounter() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for OperatorCounter"); }
+  OperatorCounter() { Dbg(dbg_ctl, "Calling CTOR for OperatorCounter"); }
 
   // noncopyable
   OperatorCounter(const OperatorCounter &) = delete;
@@ -293,7 +293,7 @@ class OperatorCounter : public Operator
 class OperatorRMCookie : public OperatorCookies
 {
 public:
-  OperatorRMCookie() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for OperatorRMCookie"); }
+  OperatorRMCookie() { Dbg(dbg_ctl, "Calling CTOR for OperatorRMCookie"); }
 
   // noncopyable
   OperatorRMCookie(const OperatorRMCookie &) = delete;
@@ -306,7 +306,7 @@ class OperatorRMCookie : public OperatorCookies
 class OperatorAddCookie : public OperatorCookies
 {
 public:
-  OperatorAddCookie() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for OperatorAddCookie"); }
+  OperatorAddCookie() { Dbg(dbg_ctl, "Calling CTOR for OperatorAddCookie"); }
 
   // noncopyable
   OperatorAddCookie(const OperatorAddCookie &) = delete;
@@ -324,7 +324,7 @@ class OperatorAddCookie : public OperatorCookies
 class OperatorSetCookie : public OperatorCookies
 {
 public:
-  OperatorSetCookie() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for OperatorSetCookie"); }
+  OperatorSetCookie() { Dbg(dbg_ctl, "Calling CTOR for OperatorSetCookie"); }
 
   // noncopyable
   OperatorSetCookie(const OperatorSetCookie &) = delete;
@@ -354,7 +354,7 @@ bool cookieModifyHelper(const char *cookies, const size_t cookies_len, std::stri
 class OperatorSetConnDSCP : public Operator
 {
 public:
-  OperatorSetConnDSCP() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for OperatorSetConnDSCP"); }
+  OperatorSetConnDSCP() { Dbg(dbg_ctl, "Calling CTOR for OperatorSetConnDSCP"); }
 
   // noncopyable
   OperatorSetConnDSCP(const OperatorSetConnDSCP &) = delete;
@@ -373,7 +373,7 @@ class OperatorSetConnDSCP : public Operator
 class OperatorSetConnMark : public Operator
 {
 public:
-  OperatorSetConnMark() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for OperatorSetConnMark"); }
+  OperatorSetConnMark() { Dbg(dbg_ctl, "Calling CTOR for OperatorSetConnMark"); }
 
   // noncopyable
   OperatorSetConnMark(const OperatorSetConnMark &) = delete;
@@ -392,7 +392,7 @@ class OperatorSetConnMark : public Operator
 class OperatorSetDebug : public Operator
 {
 public:
-  OperatorSetDebug() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for OperatorSetDebug"); }
+  OperatorSetDebug() { Dbg(dbg_ctl, "Calling CTOR for OperatorSetDebug"); }
 
   // noncopyable
   OperatorSetDebug(const OperatorSetDebug &) = delete;
@@ -408,7 +408,7 @@ class OperatorSetDebug : public Operator
 class OperatorSetBody : public Operator
 {
 public:
-  OperatorSetBody() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for OperatorSetBody"); }
+  OperatorSetBody() { Dbg(dbg_ctl, "Calling CTOR for OperatorSetBody"); }
 
   // noncopyable
   OperatorSetBody(const OperatorSetBody &) = delete;
@@ -427,7 +427,7 @@ class OperatorSetBody : public Operator
 class OperatorSetHttpCntl : public Operator
 {
 public:
-  OperatorSetHttpCntl() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for OperatorSetHttpCntl"); }
+  OperatorSetHttpCntl() { Dbg(dbg_ctl, "Calling CTOR for OperatorSetHttpCntl"); }
 
   // noncopyable
   OperatorSetHttpCntl(const OperatorSetHttpCntl &) = delete;
diff --git a/plugins/header_rewrite/resources.cc b/plugins/header_rewrite/resources.cc
index 0b8d2b525eb..d51ddd8a611 100644
--- a/plugins/header_rewrite/resources.cc
+++ b/plugins/header_rewrite/resources.cc
@@ -28,13 +28,13 @@
 void
 Resources::gather(const ResourceIDs ids, TSHttpHookID hook)
 {
-  TSDebug(PLUGIN_NAME, "Building resources, hook=%s", TSHttpHookNameLookup(hook));
+  Dbg(pi_dbg_ctl, "Building resources, hook=%s", TSHttpHookNameLookup(hook));
 
   // If we need the client request headers, make sure it's also available in the client vars.
   if (ids & RSRC_CLIENT_REQUEST_HEADERS) {
-    TSDebug(PLUGIN_NAME, "\tAdding TXN client request header buffers");
+    Dbg(pi_dbg_ctl, "\tAdding TXN client request header buffers");
     if (TSHttpTxnClientReqGet(txnp, &client_bufp, &client_hdr_loc) != TS_SUCCESS) {
-      TSDebug(PLUGIN_NAME, "could not gather bufp/hdr_loc for request");
+      Dbg(pi_dbg_ctl, "could not gather bufp/hdr_loc for request");
       return;
     }
   }
@@ -43,25 +43,25 @@ Resources::gather(const ResourceIDs ids, TSHttpHookID hook)
   case TS_HTTP_READ_RESPONSE_HDR_HOOK:
     // Read response headers from server
     if (ids & RSRC_SERVER_RESPONSE_HEADERS) {
-      TSDebug(PLUGIN_NAME, "\tAdding TXN server response header buffers");
+      Dbg(pi_dbg_ctl, "\tAdding TXN server response header buffers");
       if (TSHttpTxnServerRespGet(txnp, &bufp, &hdr_loc) != TS_SUCCESS) {
-        TSDebug(PLUGIN_NAME, "could not gather bufp/hdr_loc for response");
+        Dbg(pi_dbg_ctl, "could not gather bufp/hdr_loc for response");
         return;
       }
     }
     if (ids & RSRC_RESPONSE_STATUS) {
-      TSDebug(PLUGIN_NAME, "\tAdding TXN server response status resource");
+      Dbg(pi_dbg_ctl, "\tAdding TXN server response status resource");
       resp_status = TSHttpHdrStatusGet(bufp, hdr_loc);
     }
     break;
 
   case TS_HTTP_SEND_REQUEST_HDR_HOOK:
-    TSDebug(PLUGIN_NAME, "Processing TS_HTTP_SEND_REQUEST_HDR_HOOK");
+    Dbg(pi_dbg_ctl, "Processing TS_HTTP_SEND_REQUEST_HDR_HOOK");
     // Read request headers to server
     if (ids & RSRC_SERVER_REQUEST_HEADERS) {
-      TSDebug(PLUGIN_NAME, "\tAdding TXN server request header buffers");
+      Dbg(pi_dbg_ctl, "\tAdding TXN server request header buffers");
       if (!TSHttpTxnServerReqGet(txnp, &bufp, &hdr_loc)) {
-        TSDebug(PLUGIN_NAME, "could not gather bufp/hdr_loc for request");
+        Dbg(pi_dbg_ctl, "could not gather bufp/hdr_loc for request");
         return;
       }
     }
@@ -79,13 +79,13 @@ Resources::gather(const ResourceIDs ids, TSHttpHookID hook)
   case TS_HTTP_SEND_RESPONSE_HDR_HOOK:
     // Send response headers to client
     if (ids & RSRC_CLIENT_RESPONSE_HEADERS) {
-      TSDebug(PLUGIN_NAME, "\tAdding TXN client response header buffers");
+      Dbg(pi_dbg_ctl, "\tAdding TXN client response header buffers");
       if (TSHttpTxnClientRespGet(txnp, &bufp, &hdr_loc) != TS_SUCCESS) {
-        TSDebug(PLUGIN_NAME, "could not gather bufp/hdr_loc for request");
+        Dbg(pi_dbg_ctl, "could not gather bufp/hdr_loc for request");
         return;
       }
       if (ids & RSRC_RESPONSE_STATUS) {
-        TSDebug(PLUGIN_NAME, "\tAdding TXN client response status resource");
+        Dbg(pi_dbg_ctl, "\tAdding TXN client response status resource");
         resp_status = TSHttpHdrStatusGet(bufp, hdr_loc);
       }
     }
@@ -94,7 +94,7 @@ Resources::gather(const ResourceIDs ids, TSHttpHookID hook)
   case TS_REMAP_PSEUDO_HOOK:
     // Pseudo-hook for a remap instance
     if (client_bufp && client_hdr_loc) {
-      TSDebug(PLUGIN_NAME, "\tAdding TXN client request header buffers for remap instance");
+      Dbg(pi_dbg_ctl, "\tAdding TXN client request header buffers for remap instance");
       bufp    = client_bufp;
       hdr_loc = client_hdr_loc;
     }
@@ -103,7 +103,7 @@ Resources::gather(const ResourceIDs ids, TSHttpHookID hook)
   case TS_HTTP_TXN_START_HOOK:
     // Get TCP Info at transaction start
     if (client_bufp && client_hdr_loc) {
-      TSDebug(PLUGIN_NAME, "\tAdding TXN client request header buffers for TXN Start instance");
+      Dbg(pi_dbg_ctl, "\tAdding TXN client request header buffers for TXN Start instance");
       bufp    = client_bufp;
       hdr_loc = client_hdr_loc;
     }
@@ -111,9 +111,9 @@ Resources::gather(const ResourceIDs ids, TSHttpHookID hook)
 
   case TS_HTTP_TXN_CLOSE_HOOK:
     // Get TCP Info at transaction close
-    TSDebug(PLUGIN_NAME, "\tAdding TXN close buffers");
+    Dbg(pi_dbg_ctl, "\tAdding TXN close buffers");
     if (TSHttpTxnClientRespGet(txnp, &bufp, &hdr_loc) != TS_SUCCESS) {
-      TSDebug(PLUGIN_NAME, "could not gather bufp/hdr_loc for request");
+      Dbg(pi_dbg_ctl, "could not gather bufp/hdr_loc for request");
       return;
     }
     break;
diff --git a/plugins/header_rewrite/resources.h b/plugins/header_rewrite/resources.h
index 3ef49d96df2..d637afe9aa4 100644
--- a/plugins/header_rewrite/resources.h
+++ b/plugins/header_rewrite/resources.h
@@ -45,12 +45,12 @@ class Resources
 public:
   explicit Resources(TSHttpTxn txnptr, TSCont contptr) : txnp(txnptr), contp(contptr)
   {
-    TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for Resources (InkAPI)");
+    Dbg(dbg_ctl, "Calling CTOR for Resources (InkAPI)");
   }
 
   Resources(TSHttpTxn txnptr, TSRemapRequestInfo *rri) : txnp(txnptr), _rri(rri)
   {
-    TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for Resources (RemapAPI)");
+    Dbg(dbg_ctl, "Calling CTOR for Resources (RemapAPI)");
   }
 
   ~Resources() { destroy(); }
diff --git a/plugins/header_rewrite/ruleset.cc b/plugins/header_rewrite/ruleset.cc
index a77d1791834..9aa1334a0cc 100644
--- a/plugins/header_rewrite/ruleset.cc
+++ b/plugins/header_rewrite/ruleset.cc
@@ -46,7 +46,7 @@ RuleSet::add_condition(Parser &p, const char *filename, int lineno)
   Condition *c = condition_factory(p.get_op());
 
   if (nullptr != c) {
-    TSDebug(PLUGIN_NAME, "    Adding condition: %%{%s} with arg: %s", p.get_op().c_str(), p.get_arg().c_str());
+    Dbg(pi_dbg_ctl, "    Adding condition: %%{%s} with arg: %s", p.get_op().c_str(), p.get_arg().c_str());
     c->initialize(p);
     if (!c->set_hook(_hook)) {
       delete c;
@@ -76,12 +76,12 @@ RuleSet::add_operator(Parser &p, const char *filename, int lineno)
   Operator *o = operator_factory(p.get_op());
 
   if (nullptr != o) {
-    TSDebug(PLUGIN_NAME, "    Adding operator: %s(%s)=\"%s\"", p.get_op().c_str(), p.get_arg().c_str(), p.get_value().c_str());
+    Dbg(pi_dbg_ctl, "    Adding operator: %s(%s)=\"%s\"", p.get_op().c_str(), p.get_arg().c_str(), p.get_value().c_str());
     o->initialize(p);
     if (!o->set_hook(_hook)) {
       delete o;
-      TSDebug(PLUGIN_NAME, "in %s:%d: can't use this operator in hook=%s:  %s(%s)", filename, lineno, TSHttpHookNameLookup(_hook),
-              p.get_op().c_str(), p.get_arg().c_str());
+      Dbg(pi_dbg_ctl, "in %s:%d: can't use this operator in hook=%s:  %s(%s)", filename, lineno, TSHttpHookNameLookup(_hook),
+          p.get_op().c_str(), p.get_arg().c_str());
       TSError("[%s] in %s:%d: can't use this operator in hook=%s:  %s(%s)", PLUGIN_NAME, filename, lineno,
               TSHttpHookNameLookup(_hook), p.get_op().c_str(), p.get_arg().c_str());
       return false;
diff --git a/plugins/header_rewrite/ruleset.h b/plugins/header_rewrite/ruleset.h
index 278d958eaf3..85a57b5ad3e 100644
--- a/plugins/header_rewrite/ruleset.h
+++ b/plugins/header_rewrite/ruleset.h
@@ -35,11 +35,11 @@
 class RuleSet
 {
 public:
-  RuleSet() { TSDebug(PLUGIN_NAME_DBG, "RuleSet CTOR"); }
+  RuleSet() { Dbg(dbg_ctl, "RuleSet CTOR"); }
 
   ~RuleSet()
   {
-    TSDebug(PLUGIN_NAME_DBG, "RulesSet DTOR");
+    Dbg(dbg_ctl, "RulesSet DTOR");
     delete next;
     delete _cond;
     delete _oper;
diff --git a/plugins/header_rewrite/statement.h b/plugins/header_rewrite/statement.h
index 500b4a7831c..2c7e370a68a 100644
--- a/plugins/header_rewrite/statement.h
+++ b/plugins/header_rewrite/statement.h
@@ -102,11 +102,11 @@ enum NetworkSessionQualifiers {
 class Statement
 {
 public:
-  Statement() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for Statement"); }
+  Statement() { Dbg(dbg_ctl, "Calling CTOR for Statement"); }
 
   virtual ~Statement()
   {
-    TSDebug(PLUGIN_NAME_DBG, "Calling DTOR for Statement");
+    Dbg(dbg_ctl, "Calling DTOR for Statement");
     delete _next;
   }
 
diff --git a/plugins/header_rewrite/value.cc b/plugins/header_rewrite/value.cc
index e6c8ddc0dea..600c1f0810f 100644
--- a/plugins/header_rewrite/value.cc
+++ b/plugins/header_rewrite/value.cc
@@ -32,7 +32,7 @@
 
 Value::~Value()
 {
-  TSDebug(PLUGIN_NAME_DBG, "Calling DTOR for Value");
+  Dbg(dbg_ctl, "Calling DTOR for Value");
   for (auto &_cond_val : _cond_vals) {
     delete _cond_val;
   }
diff --git a/plugins/header_rewrite/value.h b/plugins/header_rewrite/value.h
index ac90d30f79c..8d68ca7d1ad 100644
--- a/plugins/header_rewrite/value.h
+++ b/plugins/header_rewrite/value.h
@@ -39,7 +39,7 @@
 class Value : Statement
 {
 public:
-  Value() { TSDebug(PLUGIN_NAME_DBG, "Calling CTOR for Value"); }
+  Value() { Dbg(dbg_ctl, "Calling CTOR for Value"); }
 
   ~Value() override;
 
diff --git a/plugins/healthchecks/healthchecks.cc b/plugins/healthchecks/healthchecks.cc
index 465bd05b279..e7f0764056a 100644
--- a/plugins/healthchecks/healthchecks.cc
+++ b/plugins/healthchecks/healthchecks.cc
@@ -40,6 +40,8 @@ limitations under the License.
 static const char PLUGIN_NAME[] = "healthchecks";
 static const char SEPARATORS[]  = " \t\n";
 
+static DbgCtl dbg_ctl{PLUGIN_NAME};
+
 #define MAX_PATH_LEN     4096
 #define MAX_BODY_LEN     16384
 #define FREELIST_TIMEOUT 300
@@ -136,13 +138,13 @@ setup_watchers(int fd)
 
   while (conf) {
     conf->wd = inotify_add_watch(fd, conf->fname, IN_DELETE_SELF | IN_CLOSE_WRITE | IN_ATTRIB);
-    TSDebug(PLUGIN_NAME, "Setting up a watcher for %s", conf->fname);
+    Dbg(dbg_ctl, "Setting up a watcher for %s", conf->fname);
     strncpy(fname, conf->fname, MAX_PATH_LEN);
 
     char *dname = dirname(fname);
     /* Make sure to only watch each directory once */
     if (!(dir = find_direntry(dname, head_dir))) {
-      TSDebug(PLUGIN_NAME, "Setting up a watcher for directory %s", dname);
+      Dbg(dbg_ctl, "Setting up a watcher for directory %s", dname);
       dir = tsapi::malloc<HCDirEntry>();
       memset(dir, 0, sizeof(HCDirEntry));
       strncpy(dir->dname, dname, MAX_PATH_LEN - 1);
@@ -200,7 +202,7 @@ hc_thread(void *data ATS_UNUSED)
         do {
           HCFileData *next = fdata->_next;
 
-          TSDebug(PLUGIN_NAME, "Cleaning up entry from freelist");
+          Dbg(dbg_ctl, "Cleaning up entry from freelist");
           TSfree(fdata);
           fdata = next;
         } while (fdata);
@@ -227,18 +229,18 @@ hc_thread(void *data ATS_UNUSED)
           HCFileData *old_data;
 
           if (event->mask & (IN_CLOSE_WRITE | IN_ATTRIB)) {
-            TSDebug(PLUGIN_NAME, "Modify file event (%d) on %s", event->mask, finfo->fname);
+            Dbg(dbg_ctl, "Modify file event (%d) on %s", event->mask, finfo->fname);
           } else if (event->mask & (IN_CREATE | IN_MOVED_TO)) {
-            TSDebug(PLUGIN_NAME, "Create file event (%d) on %s", event->mask, finfo->fname);
+            Dbg(dbg_ctl, "Create file event (%d) on %s", event->mask, finfo->fname);
             finfo->wd = inotify_add_watch(fd, finfo->fname, IN_DELETE_SELF | IN_CLOSE_WRITE | IN_ATTRIB);
           } else if (event->mask & (IN_DELETE_SELF | IN_MOVED_FROM)) {
-            TSDebug(PLUGIN_NAME, "Delete file event (%d) on %s", event->mask, finfo->fname);
+            Dbg(dbg_ctl, "Delete file event (%d) on %s", event->mask, finfo->fname);
             finfo->wd = inotify_rm_watch(fd, finfo->wd);
           }
           /* Load the new data and then swap this atomically */
           memset(new_data, 0, sizeof(HCFileData));
           reload_status_file(finfo, new_data);
-          TSDebug(PLUGIN_NAME, "Reloaded %s, len == %d, exists == %d", finfo->fname, new_data->b_len, new_data->exists);
+          Dbg(dbg_ctl, "Reloaded %s, len == %d, exists == %d", finfo->fname, new_data->b_len, new_data->exists);
           old_data = finfo->data.exchange(new_data);
 
           /* Add the old data to the head of the freelist */
@@ -353,7 +355,7 @@ parse_configs(const char *fname)
 
       /* Fill in the info if everything was ok */
       if (state > 4) {
-        TSDebug(PLUGIN_NAME, "Parsed: %s %s %s %s %s", finfo->path, finfo->fname, mime, ok, miss);
+        Dbg(dbg_ctl, "Parsed: %s %s %s %s %s", finfo->path, finfo->fname, mime, ok, miss);
         finfo->ok   = gen_header(ok, mime, &finfo->o_len);
         finfo->miss = gen_header(miss, mime, &finfo->m_len);
         finfo->data = tsapi::malloc<HCFileData>();
@@ -361,7 +363,7 @@ parse_configs(const char *fname)
         reload_status_file(finfo, finfo->data);
 
         /* Add it the linked list */
-        TSDebug(PLUGIN_NAME, "Adding path=%s to linked list", finfo->path);
+        Dbg(dbg_ctl, "Adding path=%s to linked list", finfo->path);
         if (nullptr == head_finfo) {
           head_finfo = finfo;
         } else {
@@ -411,10 +413,10 @@ hc_process_read(TSCont contp, TSEvent event, HCState *my_state)
 {
   if (event == TS_EVENT_VCONN_READ_READY) {
     if (my_state->data->exists) {
-      TSDebug(PLUGIN_NAME, "Setting OK response header");
+      Dbg(dbg_ctl, "Setting OK response header");
       my_state->output_bytes = add_data_to_resp(my_state->info->ok, my_state->info->o_len, my_state);
     } else {
-      TSDebug(PLUGIN_NAME, "Setting MISS response header");
+      Dbg(dbg_ctl, "Setting MISS response header");
       my_state->output_bytes = add_data_to_resp(my_state->info->miss, my_state->info->m_len, my_state);
     }
     TSVConnShutdown(my_state->net_vc, 1, 0);
@@ -509,7 +511,7 @@ health_check_origin(TSCont contp ATS_UNUSED, TSEvent event ATS_UNUSED, void *eda
 
     while (info) {
       if (info->p_len == path_len && !memcmp(info->path, path, path_len)) {
-        TSDebug(PLUGIN_NAME, "Found match for /%.*s", path_len, path);
+        Dbg(dbg_ctl, "Found match for /%.*s", path_len, path);
         break;
       }
       info = info->_next;
@@ -579,6 +581,6 @@ TSPluginInit(int argc, const char *argv[])
 
   /* Create a continuation with a mutex as there is a shared global structure
      containing the headers to add */
-  TSDebug(PLUGIN_NAME, "Started %s plugin", PLUGIN_NAME);
+  Dbg(dbg_ctl, "Started %s plugin", PLUGIN_NAME);
   TSHttpHookAdd(TS_HTTP_READ_REQUEST_HDR_HOOK, TSContCreate(health_check_origin, nullptr));
 }
diff --git a/plugins/ja3_fingerprint/ja3_fingerprint.cc b/plugins/ja3_fingerprint/ja3_fingerprint.cc
index 6e0e8245c9a..13056b48807 100644
--- a/plugins/ja3_fingerprint/ja3_fingerprint.cc
+++ b/plugins/ja3_fingerprint/ja3_fingerprint.cc
@@ -50,6 +50,7 @@
 #define n2s(c, s) ((s = (((unsigned int)(c[0])) << 8) | (((unsigned int)(c[1])))), c += 2)
 
 const char *PLUGIN_NAME = "ja3_fingerprint";
+static DbgCtl dbg_ctl{PLUGIN_NAME};
 static TSTextLogObject pluginlog;
 static int ja3_idx    = -1;
 static int enable_raw = 0;
@@ -136,7 +137,7 @@ getIP(sockaddr const *s_sockaddr, char res[INET6_ADDRSTRLEN])
 static std::string
 custom_get_ja3(SSL *s)
 {
-  TSDebug(PLUGIN_NAME, "Entering custom_get_ja3()...");
+  Dbg(dbg_ctl, "Entering custom_get_ja3()...");
   std::string ja3;
   const unsigned char *p, *d;
   int i, j, len;
@@ -209,7 +210,7 @@ custom_get_ja3(SSL *s)
 
   // Append eclist and ecpflist
   ja3 += "," + eclist + "," + ecpflist;
-  TSDebug(PLUGIN_NAME, "ja3 string: %s", ja3.c_str());
+  Dbg(dbg_ctl, "ja3 string: %s", ja3.c_str());
   return ja3;
 }
 #elif OPENSSL_VERSION_NUMBER >= 0x10101000L
@@ -312,7 +313,7 @@ client_hello_ja3_handler(TSCont contp, TSEvent event, void *edata)
     getIP(TSNetVConnRemoteAddrGet(ssl_vc), data->ip_addr);
 
     TSUserArgSet(ssl_vc, ja3_idx, static_cast<void *>(data));
-    TSDebug(PLUGIN_NAME, "client_hello_ja3_handler(): JA3: %s", data->ja3_string.c_str());
+    Dbg(dbg_ctl, "client_hello_ja3_handler(): JA3: %s", data->ja3_string.c_str());
 
     // MD5 hash
     unsigned char digest[MD5_DIGEST_LENGTH];
@@ -323,7 +324,7 @@ client_hello_ja3_handler(TSCont contp, TSEvent event, void *edata)
     for (int i = 0; i < 16; i++) {
       snprintf(&(data->md5_string[i * 2]), sizeof(data->md5_string) - (i * 2), "%02x", static_cast<unsigned int>(digest[i]));
     }
-    TSDebug(PLUGIN_NAME, "Fingerprint: %s", data->md5_string);
+    Dbg(dbg_ctl, "Fingerprint: %s", data->md5_string);
     break;
   }
   case TS_EVENT_VCONN_CLOSE: {
@@ -331,7 +332,7 @@ client_hello_ja3_handler(TSCont contp, TSEvent event, void *edata)
     ja3_data *data = static_cast<ja3_data *>(TSUserArgGet(ssl_vc, ja3_idx));
 
     if (data == nullptr) {
-      TSDebug(PLUGIN_NAME, "client_hello_ja3_handler(): Failed to retrieve ja3 data at VCONN_CLOSE.");
+      Dbg(dbg_ctl, "client_hello_ja3_handler(): Failed to retrieve ja3 data at VCONN_CLOSE.");
       return TS_ERROR;
     }
 
@@ -341,7 +342,7 @@ client_hello_ja3_handler(TSCont contp, TSEvent event, void *edata)
     break;
   }
   default: {
-    TSDebug(PLUGIN_NAME, "client_hello_ja3_handler(): Unexpected event.");
+    Dbg(dbg_ctl, "client_hello_ja3_handler(): Unexpected event.");
     break;
   }
   }
@@ -357,7 +358,7 @@ req_hdr_ja3_handler(TSCont contp, TSEvent event, void *edata)
   TSVConn vconn  = nullptr;
   if ((txnp = static_cast<TSHttpTxn>(edata)) == nullptr || (ssnp = TSHttpTxnSsnGet(txnp)) == nullptr ||
       (vconn = TSHttpSsnClientVConnGet(ssnp)) == nullptr) {
-    TSDebug(PLUGIN_NAME, "req_hdr_ja3_handler(): Failure to retrieve txn/ssn/vconn object.");
+    Dbg(dbg_ctl, "req_hdr_ja3_handler(): Failure to retrieve txn/ssn/vconn object.");
     TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
     return TS_SUCCESS;
   }
@@ -369,7 +370,7 @@ req_hdr_ja3_handler(TSCont contp, TSEvent event, void *edata)
     ja3_remap_info *info = static_cast<ja3_remap_info *>(TSContDataGet(contp));
     bool raw_flag        = info ? info->raw : enable_raw;
     bool log_flag        = info ? info->log : enable_log;
-    TSDebug(PLUGIN_NAME, "req_hdr_ja3_handler(): Found ja3 string.");
+    Dbg(dbg_ctl, "req_hdr_ja3_handler(): Found ja3 string.");
 
     // Get handle to headers
     TSMBuffer bufp;
@@ -391,7 +392,7 @@ req_hdr_ja3_handler(TSCont contp, TSEvent event, void *edata)
                            static_cast<int>(data->ja3_string.size()), data->ja3_string.data(), 32, data->md5_string);
     }
   } else {
-    TSDebug(PLUGIN_NAME, "req_hdr_ja3_handler(): ja3 data not set. Not SSL vconn. Abort.");
+    Dbg(dbg_ctl, "req_hdr_ja3_handler(): ja3 data not set. Not SSL vconn. Abort.");
   }
   TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
   return TS_SUCCESS;
@@ -410,25 +411,25 @@ read_config_option(int argc, const char *argv[], int &raw, int &log)
   while ((opt = getopt_long(argc, const_cast<char *const *>(argv), "", longopts, nullptr)) >= 0) {
     switch (opt) {
     case '?':
-      TSDebug(PLUGIN_NAME, "read_config_option(): Unrecognized command arguments.");
+      Dbg(dbg_ctl, "read_config_option(): Unrecognized command arguments.");
     case 0:
     case -1:
       break;
     default:
-      TSDebug(PLUGIN_NAME, "read_config_option(): Unexpected options error.");
+      Dbg(dbg_ctl, "read_config_option(): Unexpected options error.");
       return false;
     }
   }
 
-  TSDebug(PLUGIN_NAME, "read_config_option(): ja3 raw is %s", (raw == 1) ? "enabled" : "disabled");
-  TSDebug(PLUGIN_NAME, "read_config_option(): ja3 logging is %s", (log == 1) ? "enabled" : "disabled");
+  Dbg(dbg_ctl, "read_config_option(): ja3 raw is %s", (raw == 1) ? "enabled" : "disabled");
+  Dbg(dbg_ctl, "read_config_option(): ja3 logging is %s", (log == 1) ? "enabled" : "disabled");
   return true;
 }
 
 void
 TSPluginInit(int argc, const char *argv[])
 {
-  TSDebug(PLUGIN_NAME, "Initializing plugin");
+  Dbg(dbg_ctl, "Initializing plugin");
 
   TSPluginRegistrationInfo info;
 
@@ -446,7 +447,7 @@ TSPluginInit(int argc, const char *argv[])
   } else {
     if (enable_log && !pluginlog) {
       TSAssert(TS_SUCCESS == TSTextLogObjectCreate(PLUGIN_NAME, TS_LOG_MODE_ADD_TIMESTAMP, &pluginlog));
-      TSDebug(PLUGIN_NAME, "log object created successfully");
+      Dbg(dbg_ctl, "log object created successfully");
     }
     // SNI handler
     TSCont ja3_cont = TSContCreate(client_hello_ja3_handler, nullptr);
@@ -469,7 +470,7 @@ TSPluginInit(int argc, const char *argv[])
 TSReturnCode
 TSRemapInit(TSRemapInterface *api_info, char *errbuf, int errbuf_size)
 {
-  TSDebug(PLUGIN_NAME, "JA3 Remap Plugin initializing..");
+  Dbg(dbg_ctl, "JA3 Remap Plugin initializing..");
 
   // Check if there is config conflict as both global and remap plugin
   if (ja3_idx >= 0) {
@@ -495,18 +496,18 @@ TSRemapInit(TSRemapInterface *api_info, char *errbuf, int errbuf_size)
 TSReturnCode
 TSRemapNewInstance(int argc, char *argv[], void **ih, char * /* errbuf ATS_UNUSED */, int /* errbuf_size ATS_UNUSED */)
 {
-  TSDebug(PLUGIN_NAME, "New instance for client matching %s to %s", argv[0], argv[1]);
+  Dbg(dbg_ctl, "New instance for client matching %s to %s", argv[0], argv[1]);
   std::unique_ptr<ja3_remap_info> pri{new ja3_remap_info};
 
   // Parse parameters
   if (!read_config_option(argc - 1, const_cast<const char **>(argv + 1), pri->raw, pri->log)) {
-    TSDebug(PLUGIN_NAME, "TSRemapNewInstance(): Bad arguments");
+    Dbg(dbg_ctl, "TSRemapNewInstance(): Bad arguments");
     return TS_ERROR;
   }
 
   if (pri->log && !pluginlog) {
     TSAssert(TS_SUCCESS == TSTextLogObjectCreate(PLUGIN_NAME, TS_LOG_MODE_ADD_TIMESTAMP, &pluginlog));
-    TSDebug(PLUGIN_NAME, "log object created successfully");
+    Dbg(dbg_ctl, "log object created successfully");
   }
 
   // Create continuation
diff --git a/plugins/libloader/libloader.cc b/plugins/libloader/libloader.cc
index 1f6e1f110b0..ac2c0bc4d26 100644
--- a/plugins/libloader/libloader.cc
+++ b/plugins/libloader/libloader.cc
@@ -69,6 +69,8 @@ TSPluginInit(int argc, const char *argv[])
 
   atexit(unloadlibs);
 
+  static DbgCtl dbg_ctl{"libloader"};
+
   for (i = 1; i < argc; ++i) {
     const char *lib = argv[i];
     void *handle    = dlopen(lib, RTLD_GLOBAL | RTLD_NOW);
@@ -77,7 +79,7 @@ TSPluginInit(int argc, const char *argv[])
       l->handle = handle;
       l->next   = libs;
       libs      = l;
-      TSDebug("libloader", " loaded %s", lib);
+      Dbg(dbg_ctl, " loaded %s", lib);
     } else {
       TSError("[libloader] failed to load %s: %s\n", lib, dlerror());
     }
diff --git a/plugins/lua/ts_lua.cc b/plugins/lua/ts_lua.cc
index 47bc6bba41d..d738705aaee 100644
--- a/plugins/lua/ts_lua.cc
+++ b/plugins/lua/ts_lua.cc
@@ -121,8 +121,8 @@ create_lua_vms()
     if (TS_SUCCESS == TSMgmtIntCreate(TS_RECORDTYPE_CONFIG, ts_lua_mgmt_state_str, TS_LUA_MAX_STATE_COUNT,
                                       TS_RECORDUPDATE_RESTART_TS, TS_RECORDCHECK_INT, ts_lua_mgmt_state_regex,
                                       TS_RECORDACCESS_READ_ONLY)) {
-      TSDebug(TS_LUA_DEBUG_TAG, "[%s] registered config string %s: with default [%d]", __FUNCTION__, ts_lua_mgmt_state_str,
-              TS_LUA_MAX_STATE_COUNT);
+      Dbg(dbg_ctl, "[%s] registered config string %s: with default [%d]", __FUNCTION__, ts_lua_mgmt_state_str,
+          TS_LUA_MAX_STATE_COUNT);
     } else {
       TSError("[%s][%s] failed to register %s", TS_LUA_DEBUG_TAG, __FUNCTION__, ts_lua_mgmt_state_str);
     }
@@ -133,11 +133,11 @@ create_lua_vms()
     TSMgmtInt mgmt_state = 0;
 
     if (TS_SUCCESS != TSMgmtIntGet(ts_lua_mgmt_state_str, &mgmt_state)) {
-      TSDebug(TS_LUA_DEBUG_TAG, "[%s] setting max state to default: %d", __FUNCTION__, TS_LUA_MAX_STATE_COUNT);
+      Dbg(dbg_ctl, "[%s] setting max state to default: %d", __FUNCTION__, TS_LUA_MAX_STATE_COUNT);
       ts_lua_max_state_count = TS_LUA_MAX_STATE_COUNT;
     } else {
       ts_lua_max_state_count = (int)mgmt_state;
-      TSDebug(TS_LUA_DEBUG_TAG, "[%s] found %s: [%d]", __FUNCTION__, ts_lua_mgmt_state_str, ts_lua_max_state_count);
+      Dbg(dbg_ctl, "[%s] found %s: [%d]", __FUNCTION__, ts_lua_mgmt_state_str, ts_lua_max_state_count);
     }
 
     if (ts_lua_max_state_count < 1) {
@@ -268,11 +268,11 @@ lifecycleHandler(TSCont contp, TSEvent event, void *edata)
   size_t const reset_tag_len = strlen(reset_tag);
 
   if (reset_tag_len <= msgp->data_size && 0 == strncasecmp(reset_tag, msgstr, reset_tag_len)) {
-    TSDebug(TS_LUA_DEBUG_TAG, "[%s] LIFECYCLE_MSG: %s", __FUNCTION__, reset_tag);
+    Dbg(dbg_ctl, "[%s] LIFECYCLE_MSG: %s", __FUNCTION__, reset_tag);
     state = Reset;
     fprintf(stderr, "[%s] %s (%s) resetting per state gc_kb_max and threads_max\n", timebuf, TS_LUA_DEBUG_TAG, labelstr);
   } else {
-    TSDebug(TS_LUA_DEBUG_TAG, "[%s] LIFECYCLE_MSG: %s", __FUNCTION__, print_tag);
+    Dbg(dbg_ctl, "[%s] LIFECYCLE_MSG: %s", __FUNCTION__, print_tag);
   }
 
   for (int index = 0; index < ts_lua_max_state_count; ++index) {
@@ -325,7 +325,7 @@ TSRemapInit(TSRemapInterface *api_info, char *errbuf, int errbuf_size)
 
       // start the stats management
       if (nullptr != plugin_stats) {
-        TSDebug(TS_LUA_DEBUG_TAG, "Starting up stats management continuation");
+        Dbg(dbg_ctl, "Starting up stats management continuation");
         TSCont const scontp = TSContCreate(statsHandler, TSMutexCreate());
         TSContDataSet(scontp, plugin_stats);
         TSContScheduleOnPool(scontp, TS_LUA_STATS_TIMEOUT, TS_THREAD_POOL_TASK);
@@ -364,7 +364,7 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char *errbuf, int errbuf_s
     switch (opt) {
     case 's':
       states = atoi(optarg);
-      TSDebug(TS_LUA_DEBUG_TAG, "[%s] setting number of lua VMs [%d]", __FUNCTION__, states);
+      Dbg(dbg_ctl, "[%s] setting number of lua VMs [%d]", __FUNCTION__, states);
       // set state
       break;
     case 'i':
@@ -411,7 +411,7 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char *errbuf, int errbuf_s
 
   // check to make sure it is a lua file and there is no parameter for the lua file
   if (fn && (argc - optind < 2)) {
-    TSDebug(TS_LUA_DEBUG_TAG, "[%s] checking if script has been registered", __FUNCTION__);
+    Dbg(dbg_ctl, "[%s] checking if script has been registered", __FUNCTION__);
 
     // we only need to check the first lua VM for script registration
     TSMutexLock(ts_lua_main_ctx_array[0].mutexp);
@@ -420,7 +420,7 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char *errbuf, int errbuf_s
   }
 
   if (!conf) {
-    TSDebug(TS_LUA_DEBUG_TAG, "[%s] creating new conf instance", __FUNCTION__);
+    Dbg(dbg_ctl, "[%s] creating new conf instance", __FUNCTION__);
 
     conf = tsapi::malloc<ts_lua_instance_conf>();
     if (!conf) {
@@ -436,7 +436,7 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char *errbuf, int errbuf_s
     conf->ref_count = 1;
     conf->ljgc      = ljgc;
 
-    TSDebug(TS_LUA_DEBUG_TAG, "Reference Count = %d , creating new instance...", conf->ref_count);
+    Dbg(dbg_ctl, "Reference Count = %d , creating new instance...", conf->ref_count);
 
     if (fn) {
       snprintf(conf->script, TS_LUA_MAX_SCRIPT_FNAME_LENGTH, "%s", script);
@@ -461,7 +461,7 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char *errbuf, int errbuf_s
     }
   } else {
     conf->ref_count++;
-    TSDebug(TS_LUA_DEBUG_TAG, "Reference Count = %d , reference existing instance...", conf->ref_count);
+    Dbg(dbg_ctl, "Reference Count = %d , reference existing instance...", conf->ref_count);
   }
 
   *ih = conf;
@@ -477,10 +477,10 @@ TSRemapDeleteInstance(void *ih)
   ts_lua_del_instance(static_cast<ts_lua_instance_conf *>(ih));
   ((ts_lua_instance_conf *)ih)->ref_count--;
   if (((ts_lua_instance_conf *)ih)->ref_count == 0) {
-    TSDebug(TS_LUA_DEBUG_TAG, "Reference Count = %d , freeing...", ((ts_lua_instance_conf *)ih)->ref_count);
+    Dbg(dbg_ctl, "Reference Count = %d , freeing...", ((ts_lua_instance_conf *)ih)->ref_count);
     TSfree(ih);
   } else {
-    TSDebug(TS_LUA_DEBUG_TAG, "Reference Count = %d , not freeing...", ((ts_lua_instance_conf *)ih)->ref_count);
+    Dbg(dbg_ctl, "Reference Count = %d , not freeing...", ((ts_lua_instance_conf *)ih)->ref_count);
   }
   return;
 }
@@ -552,10 +552,10 @@ ts_lua_remap_plugin_init(void *ih, TSHttpTxn rh, TSRemapRequestInfo *rri)
   lua_pop(L, 1);
 
   if (http_ctx->has_hook) {
-    TSDebug(TS_LUA_DEBUG_TAG, "[%s] has txn hook -> adding txn close hook handler to release resources", __FUNCTION__);
+    Dbg(dbg_ctl, "[%s] has txn hook -> adding txn close hook handler to release resources", __FUNCTION__);
     TSHttpTxnHookAdd(rh, TS_HTTP_TXN_CLOSE_HOOK, contp);
   } else {
-    TSDebug(TS_LUA_DEBUG_TAG, "[%s] no txn hook -> release resources now", __FUNCTION__);
+    Dbg(dbg_ctl, "[%s] no txn hook -> release resources now", __FUNCTION__);
     ts_lua_destroy_http_ctx(http_ctx);
   }
 
@@ -567,21 +567,21 @@ ts_lua_remap_plugin_init(void *ih, TSHttpTxn rh, TSRemapRequestInfo *rri)
 void
 TSRemapOSResponse(void *ih, TSHttpTxn rh, int os_response_type)
 {
-  TSDebug(TS_LUA_DEBUG_TAG, "[%s] os response function and type - %d", __FUNCTION__, os_response_type);
+  Dbg(dbg_ctl, "[%s] os response function and type - %d", __FUNCTION__, os_response_type);
   ts_lua_remap_plugin_init(ih, rh, nullptr);
 }
 
 TSRemapStatus
 TSRemapDoRemap(void *ih, TSHttpTxn rh, TSRemapRequestInfo *rri)
 {
-  TSDebug(TS_LUA_DEBUG_TAG, "[%s] remap function", __FUNCTION__);
+  Dbg(dbg_ctl, "[%s] remap function", __FUNCTION__);
   return ts_lua_remap_plugin_init(ih, rh, rri);
 }
 
 static int
 configHandler(TSCont contp, TSEvent event ATS_UNUSED, void *edata ATS_UNUSED)
 {
-  TSDebug(TS_LUA_DEBUG_TAG, "[%s] calling configuration handler", __FUNCTION__);
+  Dbg(dbg_ctl, "[%s] calling configuration handler", __FUNCTION__);
   ts_lua_instance_conf *conf = (ts_lua_instance_conf *)TSContDataGet(contp);
   ts_lua_reload_module(conf, ts_lua_g_main_ctx_array, conf->states);
   return 0;
@@ -611,7 +611,7 @@ globalHookHandler(TSCont contp, TSEvent event ATS_UNUSED, void *edata)
   main_ctx = static_cast<decltype(main_ctx)>(pthread_getspecific(lua_g_state_key));
   if (main_ctx == nullptr) {
     req_id = __sync_fetch_and_add(&ts_lua_g_http_next_id, 1);
-    TSDebug(TS_LUA_DEBUG_TAG, "[%s] req_id: %" PRId64, __FUNCTION__, req_id);
+    Dbg(dbg_ctl, "[%s] req_id: %" PRId64, __FUNCTION__, req_id);
     main_ctx = &ts_lua_g_main_ctx_array[req_id % conf->states];
     pthread_setspecific(lua_g_state_key, main_ctx);
   }
@@ -725,10 +725,10 @@ globalHookHandler(TSCont contp, TSEvent event ATS_UNUSED, void *edata)
 
   if (http_ctx->has_hook) {
     // add a hook to release resources for context
-    TSDebug(TS_LUA_DEBUG_TAG, "[%s] has txn hook -> adding txn close hook handler to release resources", __FUNCTION__);
+    Dbg(dbg_ctl, "[%s] has txn hook -> adding txn close hook handler to release resources", __FUNCTION__);
     TSHttpTxnHookAdd(txnp, TS_HTTP_TXN_CLOSE_HOOK, txn_contp);
   } else {
-    TSDebug(TS_LUA_DEBUG_TAG, "[%s] no txn hook -> release resources now", __FUNCTION__);
+    Dbg(dbg_ctl, "[%s] no txn hook -> release resources now", __FUNCTION__);
     ts_lua_destroy_http_ctx(http_ctx);
   }
 
@@ -800,7 +800,7 @@ TSPluginInit(int argc, const char *argv[])
     case 'j':
       jit = atoi(optarg);
       if (jit == 0) {
-        TSDebug(TS_LUA_DEBUG_TAG, "[%s] disable JIT mode", __FUNCTION__);
+        Dbg(dbg_ctl, "[%s] disable JIT mode", __FUNCTION__);
         for (int index = 0; index < ts_lua_max_state_count; ++index) {
           ts_lua_main_ctx *const main_ctx = (ts_lua_g_main_ctx_array + index);
           lua_State *const lstate         = main_ctx->lua;
@@ -812,7 +812,7 @@ TSPluginInit(int argc, const char *argv[])
       break;
     case 'r':
       reload = 1;
-      TSDebug(TS_LUA_DEBUG_TAG, "[%s] enable global plugin reload [%d]", __FUNCTION__, reload);
+      Dbg(dbg_ctl, "[%s] enable global plugin reload [%d]", __FUNCTION__, reload);
       break;
     }
 
@@ -879,77 +879,77 @@ TSPluginInit(int argc, const char *argv[])
   lua_getglobal(l, TS_LUA_FUNCTION_G_SEND_REQUEST);
   if (lua_type(l, -1) == LUA_TFUNCTION) {
     TSHttpHookAdd(TS_HTTP_SEND_REQUEST_HDR_HOOK, global_contp);
-    TSDebug(TS_LUA_DEBUG_TAG, "send_request_hdr_hook added");
+    Dbg(dbg_ctl, "send_request_hdr_hook added");
   }
   lua_pop(l, 1);
 
   lua_getglobal(l, TS_LUA_FUNCTION_G_READ_RESPONSE);
   if (lua_type(l, -1) == LUA_TFUNCTION) {
     TSHttpHookAdd(TS_HTTP_READ_RESPONSE_HDR_HOOK, global_contp);
-    TSDebug(TS_LUA_DEBUG_TAG, "read_response_hdr_hook added");
+    Dbg(dbg_ctl, "read_response_hdr_hook added");
   }
   lua_pop(l, 1);
 
   lua_getglobal(l, TS_LUA_FUNCTION_G_SEND_RESPONSE);
   if (lua_type(l, -1) == LUA_TFUNCTION) {
     TSHttpHookAdd(TS_HTTP_SEND_RESPONSE_HDR_HOOK, global_contp);
-    TSDebug(TS_LUA_DEBUG_TAG, "send_response_hdr_hook added");
+    Dbg(dbg_ctl, "send_response_hdr_hook added");
   }
   lua_pop(l, 1);
 
   lua_getglobal(l, TS_LUA_FUNCTION_G_CACHE_LOOKUP_COMPLETE);
   if (lua_type(l, -1) == LUA_TFUNCTION) {
     TSHttpHookAdd(TS_HTTP_CACHE_LOOKUP_COMPLETE_HOOK, global_contp);
-    TSDebug(TS_LUA_DEBUG_TAG, "cache_lookup_complete_hook added");
+    Dbg(dbg_ctl, "cache_lookup_complete_hook added");
   }
   lua_pop(l, 1);
 
   lua_getglobal(l, TS_LUA_FUNCTION_G_READ_REQUEST);
   if (lua_type(l, -1) == LUA_TFUNCTION) {
     TSHttpHookAdd(TS_HTTP_READ_REQUEST_HDR_HOOK, global_contp);
-    TSDebug(TS_LUA_DEBUG_TAG, "read_request_hdr_hook added");
+    Dbg(dbg_ctl, "read_request_hdr_hook added");
   }
   lua_pop(l, 1);
 
   lua_getglobal(l, TS_LUA_FUNCTION_G_TXN_START);
   if (lua_type(l, -1) == LUA_TFUNCTION) {
     TSHttpHookAdd(TS_HTTP_TXN_START_HOOK, global_contp);
-    TSDebug(TS_LUA_DEBUG_TAG, "txn_start_hook added");
+    Dbg(dbg_ctl, "txn_start_hook added");
   }
   lua_pop(l, 1);
 
   lua_getglobal(l, TS_LUA_FUNCTION_G_PRE_REMAP);
   if (lua_type(l, -1) == LUA_TFUNCTION) {
     TSHttpHookAdd(TS_HTTP_PRE_REMAP_HOOK, global_contp);
-    TSDebug(TS_LUA_DEBUG_TAG, "pre_remap_hook added");
+    Dbg(dbg_ctl, "pre_remap_hook added");
   }
   lua_pop(l, 1);
 
   lua_getglobal(l, TS_LUA_FUNCTION_G_POST_REMAP);
   if (lua_type(l, -1) == LUA_TFUNCTION) {
     TSHttpHookAdd(TS_HTTP_POST_REMAP_HOOK, global_contp);
-    TSDebug(TS_LUA_DEBUG_TAG, "post_remap_hook added");
+    Dbg(dbg_ctl, "post_remap_hook added");
   }
   lua_pop(l, 1);
 
   lua_getglobal(l, TS_LUA_FUNCTION_G_OS_DNS);
   if (lua_type(l, -1) == LUA_TFUNCTION) {
     TSHttpHookAdd(TS_HTTP_OS_DNS_HOOK, global_contp);
-    TSDebug(TS_LUA_DEBUG_TAG, "os_dns_hook added");
+    Dbg(dbg_ctl, "os_dns_hook added");
   }
   lua_pop(l, 1);
 
   lua_getglobal(l, TS_LUA_FUNCTION_G_READ_CACHE);
   if (lua_type(l, -1) == LUA_TFUNCTION) {
     TSHttpHookAdd(TS_HTTP_READ_CACHE_HDR_HOOK, global_contp);
-    TSDebug(TS_LUA_DEBUG_TAG, "read_cache_hdr_hook added");
+    Dbg(dbg_ctl, "read_cache_hdr_hook added");
   }
   lua_pop(l, 1);
 
   lua_getglobal(l, TS_LUA_FUNCTION_G_TXN_CLOSE);
   if (lua_type(l, -1) == LUA_TFUNCTION) {
     TSHttpHookAdd(TS_HTTP_TXN_CLOSE_HOOK, global_contp);
-    TSDebug(TS_LUA_DEBUG_TAG, "txn_close_hook added");
+    Dbg(dbg_ctl, "txn_close_hook added");
   }
   lua_pop(l, 1);
 
diff --git a/plugins/lua/ts_lua_common.h b/plugins/lua/ts_lua_common.h
index 30dec10ea76..df1512668b5 100644
--- a/plugins/lua/ts_lua_common.h
+++ b/plugins/lua/ts_lua_common.h
@@ -185,3 +185,9 @@ typedef struct {
 #ifndef ATS_UNUSED
 #define ATS_UNUSED __attribute__((unused))
 #endif
+
+namespace ts_lua_ns
+{
+extern DbgCtl dbg_ctl;
+}
+using namespace ts_lua_ns;
diff --git a/plugins/lua/ts_lua_crypto.cc b/plugins/lua/ts_lua_crypto.cc
index 34ee04c71ff..d337a45e8e6 100644
--- a/plugins/lua/ts_lua_crypto.cc
+++ b/plugins/lua/ts_lua_crypto.cc
@@ -325,7 +325,7 @@ ts_lua_hmac_md5(lua_State *L)
 
   key_bin = tsapi::malloc<unsigned char>((klen / 2) + 1);
   if (key_bin == nullptr) {
-    TSDebug(TS_LUA_DEBUG_TAG, "unable to allocate buffer for hex to binary conversion");
+    Dbg(dbg_ctl, "unable to allocate buffer for hex to binary conversion");
     return luaL_error(L, "unable to allocate buffer for hex to binary conversion");
   }
   if (ts_lua_hex_to_bin(key_bin, key, klen) == nullptr) {
@@ -380,7 +380,7 @@ ts_lua_hmac_sha1(lua_State *L)
 
   key_bin = tsapi::malloc<unsigned char>((klen / 2) + 1);
   if (key_bin == nullptr) {
-    TSDebug(TS_LUA_DEBUG_TAG, "unable to allocate buffer for hex to binary conversion");
+    Dbg(dbg_ctl, "unable to allocate buffer for hex to binary conversion");
     return luaL_error(L, "unable to allocate buffer for hex to binary conversion");
   }
   if (ts_lua_hex_to_bin(key_bin, key, klen) == nullptr) {
@@ -435,7 +435,7 @@ ts_lua_hmac_sha256(lua_State *L)
 
   key_bin = tsapi::malloc<unsigned char>((klen / 2) + 1);
   if (key_bin == nullptr) {
-    TSDebug(TS_LUA_DEBUG_TAG, "unable to allocate buffer for hex to binary conversion");
+    Dbg(dbg_ctl, "unable to allocate buffer for hex to binary conversion");
     return luaL_error(L, "unable to allocate buffer for hex to binary conversion");
   }
   if (ts_lua_hex_to_bin(key_bin, key, klen) == nullptr) {
diff --git a/plugins/lua/ts_lua_http.cc b/plugins/lua/ts_lua_http.cc
index 2b6a4960fb4..4259bbaa4ae 100644
--- a/plugins/lua/ts_lua_http.cc
+++ b/plugins/lua/ts_lua_http.cc
@@ -463,7 +463,7 @@ ts_lua_http_set_cache_lookup_url(lua_State *L)
     if (TSUrlCreate(http_ctx->client_request_bufp, &new_url_loc) == TS_SUCCESS &&
         TSUrlParse(http_ctx->client_request_bufp, new_url_loc, &start, end) == TS_PARSE_DONE &&
         TSHttpTxnCacheLookupUrlSet(http_ctx->txnp, http_ctx->client_request_bufp, new_url_loc) == TS_SUCCESS) {
-      TSDebug(TS_LUA_DEBUG_TAG, "Set cache lookup URL");
+      Dbg(dbg_ctl, "Set cache lookup URL");
     } else {
       TSError("[ts_lua][%s] Failed to set cache lookup URL", __FUNCTION__);
     }
@@ -596,7 +596,7 @@ ts_lua_http_set_parent_selection_url(lua_State *L)
     if (TSUrlCreate(http_ctx->client_request_bufp, &new_url_loc) == TS_SUCCESS &&
         TSUrlParse(http_ctx->client_request_bufp, new_url_loc, &start, end) == TS_PARSE_DONE &&
         TSHttpTxnParentSelectionUrlSet(http_ctx->txnp, http_ctx->client_request_bufp, new_url_loc) == TS_SUCCESS) {
-      TSDebug(TS_LUA_DEBUG_TAG, "Set parent selection URL");
+      Dbg(dbg_ctl, "Set parent selection URL");
     } else {
       TSError("[ts_lua][%s] Failed to set parent selection URL", __FUNCTION__);
     }
diff --git a/plugins/lua/ts_lua_http_config.cc b/plugins/lua/ts_lua_http_config.cc
index 744f7198bfb..01f54086aac 100644
--- a/plugins/lua/ts_lua_http_config.cc
+++ b/plugins/lua/ts_lua_http_config.cc
@@ -498,22 +498,22 @@ ts_lua_http_timeout_set(lua_State *L)
 
   switch (conf) {
   case TS_LUA_TIMEOUT_ACTIVE:
-    TSDebug(TS_LUA_DEBUG_TAG, "setting active timeout");
+    Dbg(dbg_ctl, "setting active timeout");
     TSHttpTxnActiveTimeoutSet(http_ctx->txnp, value);
     break;
 
   case TS_LUA_TIMEOUT_CONNECT:
-    TSDebug(TS_LUA_DEBUG_TAG, "setting connect timeout");
+    Dbg(dbg_ctl, "setting connect timeout");
     TSHttpTxnConnectTimeoutSet(http_ctx->txnp, value);
     break;
 
   case TS_LUA_TIMEOUT_DNS:
-    TSDebug(TS_LUA_DEBUG_TAG, "setting dns timeout");
+    Dbg(dbg_ctl, "setting dns timeout");
     TSHttpTxnDNSTimeoutSet(http_ctx->txnp, value);
     break;
 
   case TS_LUA_TIMEOUT_NO_ACTIVITY:
-    TSDebug(TS_LUA_DEBUG_TAG, "setting no activity timeout");
+    Dbg(dbg_ctl, "setting no activity timeout");
     TSHttpTxnNoActivityTimeoutSet(http_ctx->txnp, value);
     break;
 
@@ -535,7 +535,7 @@ ts_lua_http_client_packet_mark_set(lua_State *L)
 
   value = luaL_checkinteger(L, 1);
 
-  TSDebug(TS_LUA_DEBUG_TAG, "client packet mark set");
+  Dbg(dbg_ctl, "client packet mark set");
   TSHttpTxnClientPacketMarkSet(http_ctx->txnp, value);
 
   return 0;
@@ -551,7 +551,7 @@ ts_lua_http_server_packet_mark_set(lua_State *L)
 
   value = luaL_checkinteger(L, 1);
 
-  TSDebug(TS_LUA_DEBUG_TAG, "server packet mark set");
+  Dbg(dbg_ctl, "server packet mark set");
   TSHttpTxnServerPacketMarkSet(http_ctx->txnp, value);
 
   return 0;
@@ -568,7 +568,7 @@ ts_lua_http_enable_redirect(lua_State *L)
 
   value = luaL_checkinteger(L, 1);
 
-  TSDebug(TS_LUA_DEBUG_TAG, "enable redirect");
+  Dbg(dbg_ctl, "enable redirect");
   TSHttpTxnConfigIntSet(http_ctx->txnp, TS_CONFIG_HTTP_NUMBER_OF_REDIRECTIONS, value);
 
   return 0;
@@ -584,7 +584,7 @@ ts_lua_http_set_debug(lua_State *L)
 
   value = luaL_checkinteger(L, 1);
 
-  TSDebug(TS_LUA_DEBUG_TAG, "set debug");
+  Dbg(dbg_ctl, "set debug");
   TSHttpTxnCntlSet(http_ctx->txnp, TS_HTTP_CNTL_TXN_DEBUG, (value != 0));
 
   return 0;
@@ -600,7 +600,7 @@ ts_lua_http_client_packet_dscp_set(lua_State *L)
 
   value = luaL_checkinteger(L, 1);
 
-  TSDebug(TS_LUA_DEBUG_TAG, "client packet dscp set");
+  Dbg(dbg_ctl, "client packet dscp set");
   TSHttpTxnClientPacketDscpSet(http_ctx->txnp, value);
 
   return 0;
@@ -616,7 +616,7 @@ ts_lua_http_server_packet_dscp_set(lua_State *L)
 
   value = luaL_checkinteger(L, 1);
 
-  TSDebug(TS_LUA_DEBUG_TAG, "server packet dscp set");
+  Dbg(dbg_ctl, "server packet dscp set");
   TSHttpTxnServerPacketDscpSet(http_ctx->txnp, value);
 
   return 0;
diff --git a/plugins/lua/ts_lua_misc.cc b/plugins/lua/ts_lua_misc.cc
index 411cba53f4a..69b05612983 100644
--- a/plugins/lua/ts_lua_misc.cc
+++ b/plugins/lua/ts_lua_misc.cc
@@ -178,10 +178,11 @@ ts_lua_debug(lua_State *L)
   if (lua_gettop(L) == 2) {
     msg  = luaL_checklstring(L, 2, &msg_len);
     flag = luaL_checklstring(L, 1, &flag_len);
-    TSDebug(flag, "%.*s", (int)msg_len, msg);
+    DbgCtl dc{flag};
+    Dbg(dc, "%.*s", (int)msg_len, msg);
   } else {
     msg = luaL_checklstring(L, 1, &msg_len);
-    TSDebug(TS_LUA_DEBUG_TAG, "%.*s", (int)msg_len, msg);
+    Dbg(dbg_ctl, "%.*s", (int)msg_len, msg);
   }
 
   return 0;
@@ -196,9 +197,9 @@ ts_lua_is_debug_tag_set(lua_State *L)
 
   if (lua_gettop(L) == 1) {
     flag = luaL_checklstring(L, 1, &flag_len);
-    stat = TSIsDebugTagSet(flag);
+    stat = DbgCtl{flag}.on();
   } else {
-    stat = TSIsDebugTagSet(TS_LUA_DEBUG_TAG);
+    stat = dbg_ctl.on();
   }
 
   if (0 == stat) {
@@ -351,10 +352,10 @@ ts_lua_schedule_handler(TSCont contp, TSEvent ev, void *edata)
   ts_lua_main_ctx *main_ctx;
 
   event = (int)ev;
-  TSDebug(TS_LUA_DEBUG_TAG, "getting actx and other info");
+  Dbg(dbg_ctl, "getting actx and other info");
   actx = (ts_lua_http_ctx *)TSContDataGet(contp);
 
-  TSDebug(TS_LUA_DEBUG_TAG, "getting http_Ctx");
+  Dbg(dbg_ctl, "getting http_Ctx");
   ci  = &actx->cinfo;
   crt = &ci->routine;
 
@@ -365,11 +366,11 @@ ts_lua_schedule_handler(TSCont contp, TSEvent ev, void *edata)
   ts_lua_set_cont_info(L, ci);
 
   if (event == TS_LUA_EVENT_COROUTINE_CONT) {
-    TSDebug(TS_LUA_DEBUG_TAG, "event is coroutine_cont");
+    Dbg(dbg_ctl, "event is coroutine_cont");
     n   = (intptr_t)edata;
     ret = lua_resume(L, n);
   } else {
-    TSDebug(TS_LUA_DEBUG_TAG, "event is not coroutine_cont");
+    Dbg(dbg_ctl, "event is not coroutine_cont");
     n   = lua_gettop(L);
     ret = lua_resume(L, n - 1);
   }
diff --git a/plugins/lua/ts_lua_string.cc b/plugins/lua/ts_lua_string.cc
index c01c5d99807..86ae41d77b4 100644
--- a/plugins/lua/ts_lua_string.cc
+++ b/plugins/lua/ts_lua_string.cc
@@ -51,7 +51,7 @@ u_char *
 ts_lua_hex_to_bin(u_char *dst, u_char *src, size_t len)
 {
   if (len % 2 != 0) {
-    TSDebug(TS_LUA_DEBUG_TAG, "ts_lua_hex_to_bin(): not an even number of hex digits");
+    Dbg(dbg_ctl, "ts_lua_hex_to_bin(): not an even number of hex digits");
     return nullptr;
   }
 
@@ -59,7 +59,7 @@ ts_lua_hex_to_bin(u_char *dst, u_char *src, size_t len)
     unsigned char a = hex_to_int(src[x]);
     unsigned char b = hex_to_int(src[x + 1]);
     if (a == 255 || b == 255) {
-      TSDebug(TS_LUA_DEBUG_TAG, "ts_lua_hex_to_bin(): failure in hex to binary conversion");
+      Dbg(dbg_ctl, "ts_lua_hex_to_bin(): failure in hex to binary conversion");
       return nullptr;
     }
     unsigned char result = (a << 4) + b;
diff --git a/plugins/lua/ts_lua_transform.cc b/plugins/lua/ts_lua_transform.cc
index 8e51e54beb4..2c016650a4c 100644
--- a/plugins/lua/ts_lua_transform.cc
+++ b/plugins/lua/ts_lua_transform.cc
@@ -40,7 +40,7 @@ ts_lua_client_entry(TSCont contp, TSEvent ev, void *edata)
     break;
 
   case TS_EVENT_VCONN_WRITE_COMPLETE:
-    TSDebug(TS_LUA_DEBUG_TAG, "[%s] received TS_EVENT_VCONN_WRITE_COMPLETE", __FUNCTION__);
+    Dbg(dbg_ctl, "[%s] received TS_EVENT_VCONN_WRITE_COMPLETE", __FUNCTION__);
     break;
 
   case TS_LUA_EVENT_COROUTINE_CONT:
@@ -80,13 +80,12 @@ ts_lua_client_handler(TSCont contp, ts_lua_http_transform_ctx *transform_ctx, TS
 
   empty_input = 0;
   if (!TSVIOBufferGet(input_vio)) {
-    TSDebug(TS_LUA_DEBUG_TAG, "[%s] no input VIO and output VIO", __FUNCTION__);
+    Dbg(dbg_ctl, "[%s] no input VIO and output VIO", __FUNCTION__);
     empty_input = 1;
   } else { // input VIO exists
     input_wm_bytes = TSIOBufferWaterMarkGet(TSVIOBufferGet(input_vio));
     if (transform_ctx->upstream_watermark_bytes >= 0 && transform_ctx->upstream_watermark_bytes != input_wm_bytes) {
-      TSDebug(TS_LUA_DEBUG_TAG, "[%s] Setting input_vio watermark to %" PRId64 " bytes", __FUNCTION__,
-              transform_ctx->upstream_watermark_bytes);
+      Dbg(dbg_ctl, "[%s] Setting input_vio watermark to %" PRId64 " bytes", __FUNCTION__, transform_ctx->upstream_watermark_bytes);
       TSIOBufferWaterMarkSet(TSVIOBufferGet(input_vio), transform_ctx->upstream_watermark_bytes);
     }
   }
@@ -311,19 +310,18 @@ ts_lua_transform_handler(TSCont contp, ts_lua_http_transform_ctx *transform_ctx,
   empty_input = 0;
   if (!TSVIOBufferGet(input_vio)) {
     if (transform_ctx->output.vio) {
-      TSDebug(TS_LUA_DEBUG_TAG, "[%s] reenabling output VIO after input VIO does not exist", __FUNCTION__);
+      Dbg(dbg_ctl, "[%s] reenabling output VIO after input VIO does not exist", __FUNCTION__);
       TSVIONBytesSet(transform_ctx->output.vio, transform_ctx->total);
       TSVIOReenable(transform_ctx->output.vio);
       return 0;
     } else {
-      TSDebug(TS_LUA_DEBUG_TAG, "[%s] no input VIO and output VIO", __FUNCTION__);
+      Dbg(dbg_ctl, "[%s] no input VIO and output VIO", __FUNCTION__);
       empty_input = 1;
     }
   } else { // input VIO exists
     input_wm_bytes = TSIOBufferWaterMarkGet(TSVIOBufferGet(input_vio));
     if (transform_ctx->upstream_watermark_bytes >= 0 && transform_ctx->upstream_watermark_bytes != input_wm_bytes) {
-      TSDebug(TS_LUA_DEBUG_TAG, "[%s] Setting input_vio watermark to %" PRId64 " bytes", __FUNCTION__,
-              transform_ctx->upstream_watermark_bytes);
+      Dbg(dbg_ctl, "[%s] Setting input_vio watermark to %" PRId64 " bytes", __FUNCTION__, transform_ctx->upstream_watermark_bytes);
       TSIOBufferWaterMarkSet(TSVIOBufferGet(input_vio), transform_ctx->upstream_watermark_bytes);
     }
   }
diff --git a/plugins/lua/ts_lua_util.cc b/plugins/lua/ts_lua_util.cc
index 94150d9b09c..000b2d754e1 100644
--- a/plugins/lua/ts_lua_util.cc
+++ b/plugins/lua/ts_lua_util.cc
@@ -208,7 +208,7 @@ ts_lua_script_registered(lua_State *L, char *script)
   TSMgmtInt curr_time;
   ts_lua_instance_conf *conf = nullptr;
 
-  TSDebug(TS_LUA_DEBUG_TAG, "[%s] checking if script [%s] is registered", __FUNCTION__, script);
+  Dbg(dbg_ctl, "[%s] checking if script [%s] is registered", __FUNCTION__, script);
 
   // first check the reconfigure_time for the script. if it is not found, then it is new
   // if it matches the current reconfigure_time, then it is loaded already
@@ -219,7 +219,7 @@ ts_lua_script_registered(lua_State *L, char *script)
     lua_concat(L, 2);
     lua_rawget(L, LUA_REGISTRYINDEX);
     if (lua_isnil(L, -1)) {
-      TSDebug(TS_LUA_DEBUG_TAG, "[%s] failed to get script time for [%s]", __FUNCTION__, script);
+      Dbg(dbg_ctl, "[%s] failed to get script time for [%s]", __FUNCTION__, script);
       lua_pop(L, -1);
       return nullptr;
     } else {
@@ -232,7 +232,7 @@ ts_lua_script_registered(lua_State *L, char *script)
         lua_concat(L, 2);
         lua_rawget(L, LUA_REGISTRYINDEX);
         if (lua_isnil(L, -1)) {
-          TSDebug(TS_LUA_DEBUG_TAG, "[%s] failed to get script ptr for [%s]", __FUNCTION__, script);
+          Dbg(dbg_ctl, "[%s] failed to get script ptr for [%s]", __FUNCTION__, script);
           lua_pop(L, -1);
           return nullptr;
         } else {
@@ -241,7 +241,7 @@ ts_lua_script_registered(lua_State *L, char *script)
           return conf;
         }
       } else {
-        TSDebug(TS_LUA_DEBUG_TAG, "[%s] script time not matching for [%s]", __FUNCTION__, script);
+        Dbg(dbg_ctl, "[%s] script time not matching for [%s]", __FUNCTION__, script);
         return nullptr;
       }
     }
@@ -257,7 +257,7 @@ ts_lua_script_register(lua_State *L, char *script, ts_lua_instance_conf *conf)
 {
   TSMgmtInt time;
 
-  TSDebug(TS_LUA_DEBUG_TAG, "[%s] registering script [%s]", __FUNCTION__, script);
+  Dbg(dbg_ctl, "[%s] registering script [%s]", __FUNCTION__, script);
 
   // we recorded the script reconfigure_time and its conf pointer in registry
   if (TS_SUCCESS == TSMgmtIntGet("proxy.node.config.reconfigure_time", &time)) {
@@ -369,10 +369,10 @@ ts_lua_add_module(ts_lua_instance_conf *conf, ts_lua_main_ctx *arr, int n, int a
     lua_replace(L, LUA_GLOBALSINDEX); /* L[GLOBAL] = EMPTY */
 
     if (conf->ljgc > 0) {
-      TSDebug(TS_LUA_DEBUG_TAG, "ljgc = %d, running LuaJIT Garbage Collector...", conf->ljgc);
+      Dbg(dbg_ctl, "ljgc = %d, running LuaJIT Garbage Collector...", conf->ljgc);
       lua_gc(L, LUA_GCCOLLECT, 0);
     } else {
-      TSDebug(TS_LUA_DEBUG_TAG, "ljgc = %d, NOT running LuaJIT Garbage Collector...", conf->ljgc);
+      Dbg(dbg_ctl, "ljgc = %d, NOT running LuaJIT Garbage Collector...", conf->ljgc);
     }
 
     TSMutexUnlock(arr[i].mutexp);
@@ -411,11 +411,11 @@ ts_lua_del_module(ts_lua_instance_conf *conf, ts_lua_main_ctx *arr, int n)
     lua_pushlightuserdata(L, conf);
 
     if (conf->ref_count > 1) {
-      TSDebug(TS_LUA_DEBUG_TAG, "Reference Count = %d , NOT clearing registry...", conf->ref_count);
+      Dbg(dbg_ctl, "Reference Count = %d , NOT clearing registry...", conf->ref_count);
       lua_pushvalue(L, LUA_GLOBALSINDEX);
       lua_rawset(L, LUA_REGISTRYINDEX); /* L[REG][conf] = L[GLOBAL] */
     } else {
-      TSDebug(TS_LUA_DEBUG_TAG, "Reference Count = %d , clearing registry...", conf->ref_count);
+      Dbg(dbg_ctl, "Reference Count = %d , clearing registry...", conf->ref_count);
       lua_pushnil(L);
       lua_rawset(L, LUA_REGISTRYINDEX); /* L[REG][conf] = nil */
     }
@@ -424,10 +424,10 @@ ts_lua_del_module(ts_lua_instance_conf *conf, ts_lua_main_ctx *arr, int n)
     lua_replace(L, LUA_GLOBALSINDEX); /* L[GLOBAL] = EMPTY  */
 
     if (conf->ljgc > 0) {
-      TSDebug(TS_LUA_DEBUG_TAG, "ljgc = %d, running LuaJIT Garbage Collector...", conf->ljgc);
+      Dbg(dbg_ctl, "ljgc = %d, running LuaJIT Garbage Collector...", conf->ljgc);
       lua_gc(L, LUA_GCCOLLECT, 0);
     } else {
-      TSDebug(TS_LUA_DEBUG_TAG, "ljgc = %d, NOT running LuaJIT Garbage Collector...", conf->ljgc);
+      Dbg(dbg_ctl, "ljgc = %d, NOT running LuaJIT Garbage Collector...", conf->ljgc);
     }
 
     TSMutexUnlock(arr[i].mutexp);
@@ -492,10 +492,10 @@ ts_lua_reload_module(ts_lua_instance_conf *conf, ts_lua_main_ctx *arr, int n)
     lua_replace(L, LUA_GLOBALSINDEX); /* L[GLOBAL] = EMPTY */
 
     if (conf->ljgc > 0) {
-      TSDebug(TS_LUA_DEBUG_TAG, "ljgc = %d, running LuaJIT Garbage Collector...", conf->ljgc);
+      Dbg(dbg_ctl, "ljgc = %d, running LuaJIT Garbage Collector...", conf->ljgc);
       lua_gc(L, LUA_GCCOLLECT, 0);
     } else {
-      TSDebug(TS_LUA_DEBUG_TAG, "ljgc = %d, NOT running LuaJIT Garbage Collector...", conf->ljgc);
+      Dbg(dbg_ctl, "ljgc = %d, NOT running LuaJIT Garbage Collector...", conf->ljgc);
     }
 
     TSMutexUnlock(arr[i].mutexp);
@@ -1185,3 +1185,8 @@ ts_lua_http_cont_handler(TSCont contp, TSEvent ev, void *edata)
 
   return 0;
 }
+
+namespace ts_lua_ns
+{
+DbgCtl dbg_ctl{TS_LUA_DEBUG_TAG};
+}
diff --git a/plugins/multiplexer/ats-multiplexer.cc b/plugins/multiplexer/ats-multiplexer.cc
index e192c31a9c2..d684aab7ab7 100644
--- a/plugins/multiplexer/ats-multiplexer.cc
+++ b/plugins/multiplexer/ats-multiplexer.cc
@@ -52,7 +52,7 @@ TSRemapInit(TSRemapInterface *, char *, int)
     if (timeout < 1) {
       timeout = DEFAULT_TIMEOUT;
     }
-    TSDebug(PLUGIN_TAG, "timeout is set to: %zu", timeout);
+    Dbg(dbg_ctl, "timeout is set to: %zu", timeout);
   }
 
   statistics.failures = TSStatCreate(PLUGIN_TAG ".failures", TS_RECORDDATATYPE_INT, TS_STAT_NON_PERSISTENT, TS_STAT_SYNC_COUNT);
@@ -86,7 +86,7 @@ TSRemapNewInstance(int argc, char **argv, void **i, char *, int)
       return true;
     });
   }
-  TSDebug(PLUGIN_TAG, "skipPostPut is %s", (instance->skipPostPut ? "true" : "false"));
+  Dbg(dbg_ctl, "skipPostPut is %s", (instance->skipPostPut ? "true" : "false"));
 
   *i = static_cast<void *>(instance);
 
@@ -120,7 +120,7 @@ DoRemap(const Instance &i, TSHttpTxn t)
   int length;
   const char *const method = TSHttpHdrMethodGet(buffer, location, &length);
 
-  TSDebug(PLUGIN_TAG, "Method is %s.", std::string(method, length).c_str());
+  Dbg(dbg_ctl, "Method is %s.", std::string(method, length).c_str());
 
   if (i.skipPostPut && ((length == TS_HTTP_LEN_POST && memcmp(TS_HTTP_METHOD_POST, method, TS_HTTP_LEN_POST) == 0) ||
                         (length == TS_HTTP_LEN_PUT && memcmp(TS_HTTP_METHOD_PUT, method, TS_HTTP_LEN_PUT) == 0))) {
@@ -169,7 +169,7 @@ TSRemapDoRemap(void *i, TSHttpTxn t, TSRemapRequestInfo *r)
   if (!instance->origins.empty() && !TSHttpTxnIsInternal(t)) {
     DoRemap(*instance, t);
   } else {
-    TSDebug(PLUGIN_TAG, "Skipping transaction %p", t);
+    Dbg(dbg_ctl, "Skipping transaction %p", t);
   }
 
   return TSREMAP_NO_REMAP;
diff --git a/plugins/multiplexer/dispatch.cc b/plugins/multiplexer/dispatch.cc
index b636b9fe65f..cb7356f3949 100644
--- a/plugins/multiplexer/dispatch.cc
+++ b/plugins/multiplexer/dispatch.cc
@@ -169,12 +169,12 @@ class Handler
   void
   header(const TSMBuffer b, const TSMLoc l)
   {
-    if (TSIsDebugTagSet(PLUGIN_TAG) > 0) {
+    if (dbg_ctl.on()) {
       const TSIOBuffer buffer = TSIOBufferCreate();
       TSHttpHdrPrint(b, l, buffer);
       std::string buf;
       read(buffer, buf);
-      TSDebug(PLUGIN_TAG, "Response header for \"%s\" was:\n%s", url.c_str(), buf.c_str());
+      Dbg(dbg_ctl, "Response header for \"%s\" was:\n%s", url.c_str(), buf.c_str());
       TSIOBufferDestroy(buffer);
     }
   }
@@ -183,11 +183,11 @@ class Handler
   data(const TSIOBufferReader r, const int64_t l)
   {
     length += l;
-    if (TSIsDebugTagSet(PLUGIN_TAG) > 0) {
+    if (dbg_ctl.on()) {
       std::string buffer;
       const uint64_t length  = read(r, buffer, l);
       response              += buffer;
-      TSDebug(PLUGIN_TAG, "Receiving response chunk \"%s\" of %" PRIu64 " bytes", buffer.c_str(), length);
+      Dbg(dbg_ctl, "Receiving response chunk \"%s\" of %" PRIu64 " bytes", buffer.c_str(), length);
     }
   }
 
@@ -198,8 +198,8 @@ class Handler
 
     gettimeofday(&end, nullptr);
 
-    if (TSIsDebugTagSet(PLUGIN_TAG) > 0) {
-      TSDebug(PLUGIN_TAG, "Response for \"%s\" was:\n%s", url.c_str(), response.c_str());
+    if (dbg_ctl.on()) {
+      Dbg(dbg_ctl, "Response for \"%s\" was:\n%s", url.c_str(), response.c_str());
     }
 
     const long diff = (end.tv_sec - start.tv_sec) * 1000000 + (end.tv_usec - start.tv_usec);
@@ -259,12 +259,12 @@ dispatch(Requests &r, const int t)
   const Requests::iterator end = r.end();
   for (; iterator != end; ++iterator) {
     assert(iterator->io.get() != nullptr);
-    if (TSIsDebugTagSet(PLUGIN_TAG) > 0) {
-      TSDebug(PLUGIN_TAG, "Dispatching %i bytes to \"%s\"", iterator->length, iterator->host.c_str());
+    if (dbg_ctl.on()) {
+      Dbg(dbg_ctl, "Dispatching %i bytes to \"%s\"", iterator->length, iterator->host.c_str());
       std::string b;
       read(iterator->io->reader, b);
       assert(b.size() == static_cast<uint64_t>(iterator->length));
-      TSDebug(PLUGIN_TAG, "%s", b.c_str());
+      Dbg(dbg_ctl, "%s", b.c_str());
     }
     // forwarding iterator->io pointer ownership
     ats::get(iterator->io.release(), iterator->length, Handler(iterator->host), t);
diff --git a/plugins/multiplexer/fetcher.cc b/plugins/multiplexer/fetcher.cc
index cbc869af52e..a072ca026a8 100644
--- a/plugins/multiplexer/fetcher.cc
+++ b/plugins/multiplexer/fetcher.cc
@@ -50,7 +50,7 @@ HttpParser::parse(io::IO &io)
     TSIOBufferReaderConsume(io.reader, iterator - begin);
 
     if (parsed_) {
-      TSDebug(PLUGIN_TAG, "HttpParser: response parsing is complete (%u response status code)", statusCode());
+      Dbg(dbg_ctl, "HttpParser: response parsing is complete (%u response status code)", statusCode());
       assert(parser_ != nullptr);
       destroyParser();
       return true;
@@ -62,3 +62,8 @@ HttpParser::parse(io::IO &io)
 }
 
 } // namespace ats
+
+namespace multiplexer_ns
+{
+DbgCtl dbg_ctl{PLUGIN_TAG};
+}
diff --git a/plugins/multiplexer/fetcher.h b/plugins/multiplexer/fetcher.h
index 6d637ba5ee7..626468ee528 100644
--- a/plugins/multiplexer/fetcher.h
+++ b/plugins/multiplexer/fetcher.h
@@ -39,6 +39,12 @@
 
 #define unlikely(x) __builtin_expect((x), 0)
 
+namespace multiplexer_ns
+{
+extern DbgCtl dbg_ctl;
+}
+using namespace multiplexer_ns;
+
 namespace ats
 {
 struct HttpParser {
@@ -179,22 +185,22 @@ template <class T> struct HttpTransaction {
     assert(self != NULL);
     switch (e) {
     case TS_EVENT_ERROR:
-      TSDebug(PLUGIN_TAG, "HttpTransaction: ERROR");
+      Dbg(dbg_ctl, "HttpTransaction: ERROR");
       self->t_.error();
       self->abort();
       close(self);
       TSContDataSet(c, nullptr);
       break;
     case TS_EVENT_VCONN_EOS:
-      TSDebug(PLUGIN_TAG, "HttpTransaction: EOS");
+      Dbg(dbg_ctl, "HttpTransaction: EOS");
       goto here;
 
     case TS_EVENT_VCONN_READ_COMPLETE:
-      TSDebug(PLUGIN_TAG, "HttpTransaction: Read Complete");
+      Dbg(dbg_ctl, "HttpTransaction: Read Complete");
       goto here;
 
     case TS_EVENT_VCONN_READ_READY:
-      TSDebug(PLUGIN_TAG, "HttpTransaction: Read");
+      Dbg(dbg_ctl, "HttpTransaction: Read");
     here : {
       assert(self->in_ != NULL);
       assert(self->in_->reader != NULL);
@@ -245,7 +251,7 @@ template <class T> struct HttpTransaction {
       }
     } break;
     case TS_EVENT_VCONN_WRITE_COMPLETE:
-      TSDebug(PLUGIN_TAG, "HttpTransaction: Write Complete");
+      Dbg(dbg_ctl, "HttpTransaction: Write Complete");
       self->parsingHeaders_ = true;
       assert(self->in_ == NULL);
       self->in_ = io::IO::read(self->vconnection_, c);
@@ -256,15 +262,15 @@ template <class T> struct HttpTransaction {
       self->out_ = NULL;
       break;
     case TS_EVENT_VCONN_WRITE_READY:
-      TSDebug(PLUGIN_TAG, "HttpTransaction: Write Ready (Done: %" PRId64 " Todo: %" PRId64 ")", TSVIONDoneGet(self->out_->vio),
-              TSVIONTodoGet(self->out_->vio));
+      Dbg(dbg_ctl, "HttpTransaction: Write Ready (Done: %" PRId64 " Todo: %" PRId64 ")", TSVIONDoneGet(self->out_->vio),
+          TSVIONTodoGet(self->out_->vio));
       assert(self->out_ != NULL);
       TSVIOReenable(self->out_->vio);
       break;
     case 106:
     case TS_EVENT_TIMEOUT:
     case TS_EVENT_VCONN_INACTIVITY_TIMEOUT:
-      TSDebug(PLUGIN_TAG, "HttpTransaction: Timeout");
+      Dbg(dbg_ctl, "HttpTransaction: Timeout");
       self->t_.timeout();
       self->abort();
       close(self);
@@ -287,7 +293,7 @@ get(const std::string &a, io::IO *const i, const int64_t l, const T &t, const in
   socket.sin_family = AF_INET;
   socket.sin_port   = 80;
   if (!inet_pton(AF_INET, a.c_str(), &socket.sin_addr)) {
-    TSDebug(PLUGIN_TAG, "ats::get Invalid address provided \"%s\".", a.c_str());
+    Dbg(dbg_ctl, "ats::get Invalid address provided \"%s\".", a.c_str());
     return false;
   }
   TSVConn vconn = TSHttpConnect(reinterpret_cast<sockaddr *>(&socket));
@@ -297,7 +303,7 @@ get(const std::string &a, io::IO *const i, const int64_t l, const T &t, const in
   Transaction *transaction = new Transaction(vconn, contp, i, l, t);
   TSContDataSet(contp, transaction);
   if (ti > 0) {
-    TSDebug(PLUGIN_TAG, "ats::get Setting active timeout to: %" PRId64, ti);
+    Dbg(dbg_ctl, "ats::get Setting active timeout to: %" PRId64, ti);
     transaction->timeout(ti);
   }
   return true;
diff --git a/plugins/prefetch/common.cc b/plugins/prefetch/common.cc
index 4664eebc721..4f86e45b74d 100644
--- a/plugins/prefetch/common.cc
+++ b/plugins/prefetch/common.cc
@@ -38,6 +38,13 @@ PrintToStdErr(const char *fmt, ...)
   va_end(args);
 }
 
+#else /* PREFETCH_UNIT_TEST */
+
+namespace prefetch_ns
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 #endif /* PREFETCH_UNIT_TEST */
 
 size_t
diff --git a/plugins/prefetch/common.h b/plugins/prefetch/common.h
index 9f068d9030c..853fe007780 100644
--- a/plugins/prefetch/common.h
+++ b/plugins/prefetch/common.h
@@ -50,15 +50,21 @@ void PrintToStdErr(const char *fmt, ...);
 
 #include "ts/ts.h"
 
-#define PrefetchDebug(fmt, ...)                                                           \
-  do {                                                                                    \
-    TSDebug(PLUGIN_NAME, "%s:%d:%s() " fmt, __FILE__, __LINE__, __func__, ##__VA_ARGS__); \
+namespace prefetch_ns
+{
+extern DbgCtl dbg_ctl;
+}
+using namespace prefetch_ns;
+
+#define PrefetchDebug(fmt, ...)                                                   \
+  do {                                                                            \
+    Dbg(dbg_ctl, "%s:%d:%s() " fmt, __FILE__, __LINE__, __func__, ##__VA_ARGS__); \
   } while (0)
 
-#define PrefetchError(fmt, ...)                                                           \
-  do {                                                                                    \
-    TSError("(%s) " fmt, PLUGIN_NAME, ##__VA_ARGS__);                                     \
-    TSDebug(PLUGIN_NAME, "%s:%d:%s() " fmt, __FILE__, __LINE__, __func__, ##__VA_ARGS__); \
+#define PrefetchError(fmt, ...)                                                   \
+  do {                                                                            \
+    TSError("(%s) " fmt, PLUGIN_NAME, ##__VA_ARGS__);                             \
+    Dbg(dbg_ctl, "%s:%d:%s() " fmt, __FILE__, __LINE__, __func__, ##__VA_ARGS__); \
   } while (0)
 
 #define PrefetchAssert TSAssert
diff --git a/plugins/prefetch/configs.cc b/plugins/prefetch/configs.cc
index 7ce5524544b..8ddf439b0b6 100644
--- a/plugins/prefetch/configs.cc
+++ b/plugins/prefetch/configs.cc
@@ -28,6 +28,8 @@
 
 #include "configs.h"
 
+DbgCtl Bg_dbg_ctl{PLUGIN_NAME};
+
 template <typename ContainerType>
 static void
 commaSeparateString(ContainerType &c, const String &input)
diff --git a/plugins/prefetch/fetch.cc b/plugins/prefetch/fetch.cc
index d1a9b3e98b7..8b7fde1e374 100644
--- a/plugins/prefetch/fetch.cc
+++ b/plugins/prefetch/fetch.cc
@@ -33,6 +33,11 @@
 #include "fetch.h"
 #include "headers.h"
 
+namespace
+{
+DbgCtl dbg_ctl_log{PLUGIN_NAME "_log"};
+}
+
 const char *
 getPrefetchMetricsNames(int metric)
 {
@@ -637,7 +642,7 @@ BgFetch::logAndMetricUpdate(TSEvent event) const
     break;
   }
 
-  if (TSIsDebugTagSet(PLUGIN_NAME "_log")) {
+  if (dbg_ctl_log.on()) {
     TSHRTime now   = TShrtime();
     double elapsed = static_cast<double>(now - _startTime) / 1000000.0;
 
@@ -667,7 +672,7 @@ BgFetch::handler(TSCont contp, TSEvent event, void * /* edata ATS_UNUSED */)
   case TS_EVENT_IMMEDIATE:
   case TS_EVENT_TIMEOUT:
     // Debug info for this particular bg fetch (put all debug in here please)
-    if (TSIsDebugTagSet(PLUGIN_NAME)) {
+    if (dbg_ctl.on()) {
       char buf[INET6_ADDRSTRLEN];
       const sockaddr *sockaddress = reinterpret_cast<const sockaddr *>(&fetch->client_ip);
 
diff --git a/plugins/prefetch/headers.cc b/plugins/prefetch/headers.cc
index 25171fd54ba..72430ad668b 100644
--- a/plugins/prefetch/headers.cc
+++ b/plugins/prefetch/headers.cc
@@ -176,7 +176,7 @@ setHeader(TSMBuffer bufp, TSMLoc hdrLoc, const char *header, int headerlen, cons
 /**
  * @brief Dump a header on stderr
  *
- * Useful together with TSDebug().
+ * Useful together with Dbg().
  *
  * @param bufp request's buffer
  * @param hdrLoc request's header location
diff --git a/plugins/regex_remap/regex_remap.cc b/plugins/regex_remap/regex_remap.cc
index bee814c2e84..b1bf62ac689 100644
--- a/plugins/regex_remap/regex_remap.cc
+++ b/plugins/regex_remap/regex_remap.cc
@@ -71,6 +71,8 @@ enum ExtraSubstitutions {
   SUB_LOWER_PATH = 20,
 };
 
+static DbgCtl dbg_ctl{PLUGIN_NAME};
+
 ///////////////////////////////////////////////////////////////////////////////
 // Class holding one request URL's component, to simplify the code and
 // length calculations (we need all of them).
@@ -115,7 +117,7 @@ class RemapRegex
 public:
   ~RemapRegex()
   {
-    TSDebug(PLUGIN_NAME, "Calling destructor");
+    Dbg(dbg_ctl, "Calling destructor");
     TSfree(_rex_string);
     TSfree(_subst);
 
@@ -348,7 +350,7 @@ RemapRegex::initialize(const std::string &reg, const std::string &sub, const std
           TSError("[%s] configuration variable '%s' is of an unsupported type", PLUGIN_NAME, opt_name.c_str());
           return false;
         }
-        TSDebug(PLUGIN_NAME, "Overridable config %s=%s", opt_name.c_str(), opt_val.c_str());
+        Dbg(dbg_ctl, "Overridable config %s=%s", opt_name.c_str(), opt_val.c_str());
         cur->key  = key;
         cur->type = type;
         cur->next = nullptr;
@@ -646,7 +648,7 @@ TSReturnCode
 TSRemapInit(TSRemapInterface *api_info, char *errbuf, int errbuf_size)
 {
   CHECK_REMAP_API_COMPATIBILITY(api_info, errbuf, errbuf_size);
-  TSDebug(PLUGIN_NAME, "Plugin is successfully initialized");
+  Dbg(dbg_ctl, "Plugin is successfully initialized");
   return TS_SUCCESS;
 }
 
@@ -724,7 +726,7 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char * /* errbuf ATS_UNUSE
     TSError("[%s] unable to open %s", PLUGIN_NAME, (ri->filename).c_str());
     return TS_ERROR;
   }
-  TSDebug(PLUGIN_NAME, "Loading regular expressions from %s", (ri->filename).c_str());
+  Dbg(dbg_ctl, "Loading regular expressions from %s", (ri->filename).c_str());
 
   while (!f.eof()) {
     std::string line, regex, subst, options;
@@ -799,7 +801,7 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char * /* errbuf ATS_UNUSE
       }
       TSError("%s", oss.str().c_str());
     } else {
-      TSDebug(PLUGIN_NAME, "Added regex=%s with subs=%s and options `%s'", regex.c_str(), subst.c_str(), options.c_str());
+      Dbg(dbg_ctl, "Added regex=%s with subs=%s and options `%s'", regex.c_str(), subst.c_str(), options.c_str());
       cur->set_order(++count);
       auto tmp = cur.get();
       if (ri->first == nullptr) {
@@ -882,7 +884,7 @@ TSRemapStatus
 TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo *rri)
 {
   if (nullptr == ih) {
-    TSDebug(PLUGIN_NAME, "Falling back to default URL on regex remap without rules");
+    Dbg(dbg_ctl, "Falling back to default URL on regex remap without rules");
     return TSREMAP_NO_REMAP;
   }
   RemapInstance *ri = static_cast<RemapInstance *>(ih);
@@ -967,7 +969,7 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo *rri)
     match_len += (req_url.query_len + 1);
   }
   match_buf[match_len] = '\0'; // NULL terminate the match string
-  TSDebug(PLUGIN_NAME, "Target match string is `%s'", match_buf);
+  Dbg(dbg_ctl, "Target match string is `%s'", match_buf);
 
   // Apply the regular expressions, in order. First one wins.
   while (re) {
@@ -978,24 +980,24 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo *rri)
 
       // Set timeouts
       if (re->active_timeout_option() > (-1)) {
-        TSDebug(PLUGIN_NAME, "Setting active timeout to %d", re->active_timeout_option());
+        Dbg(dbg_ctl, "Setting active timeout to %d", re->active_timeout_option());
         TSHttpTxnActiveTimeoutSet(txnp, re->active_timeout_option());
       }
       if (re->no_activity_timeout_option() > (-1)) {
-        TSDebug(PLUGIN_NAME, "Setting no activity timeout to %d", re->no_activity_timeout_option());
+        Dbg(dbg_ctl, "Setting no activity timeout to %d", re->no_activity_timeout_option());
         TSHttpTxnNoActivityTimeoutSet(txnp, re->no_activity_timeout_option());
       }
       if (re->connect_timeout_option() > (-1)) {
-        TSDebug(PLUGIN_NAME, "Setting connect timeout to %d", re->connect_timeout_option());
+        Dbg(dbg_ctl, "Setting connect timeout to %d", re->connect_timeout_option());
         TSHttpTxnConnectTimeoutSet(txnp, re->connect_timeout_option());
       }
       if (re->dns_timeout_option() > (-1)) {
-        TSDebug(PLUGIN_NAME, "Setting DNS timeout to %d", re->dns_timeout_option());
+        Dbg(dbg_ctl, "Setting DNS timeout to %d", re->dns_timeout_option());
         TSHttpTxnDNSTimeoutSet(txnp, re->dns_timeout_option());
       }
       bool lowercase_substitutions = false;
       if (re->lowercase_substitutions_option() == true) {
-        TSDebug(PLUGIN_NAME, "Setting lowercasing substitutions on");
+        Dbg(dbg_ctl, "Setting lowercasing substitutions on");
         lowercase_substitutions = true;
       }
 
@@ -1005,15 +1007,15 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo *rri)
         switch (override->type) {
         case TS_RECORDDATATYPE_INT:
           TSHttpTxnConfigIntSet(txnp, override->key, override->data.rec_int);
-          TSDebug(PLUGIN_NAME, "Setting config id %d to `%" PRId64 "'", override->key, override->data.rec_int);
+          Dbg(dbg_ctl, "Setting config id %d to `%" PRId64 "'", override->key, override->data.rec_int);
           break;
         case TS_RECORDDATATYPE_FLOAT:
           TSHttpTxnConfigFloatSet(txnp, override->key, override->data.rec_float);
-          TSDebug(PLUGIN_NAME, "Setting config id %d to `%f'", override->key, override->data.rec_float);
+          Dbg(dbg_ctl, "Setting config id %d to `%f'", override->key, override->data.rec_float);
           break;
         case TS_RECORDDATATYPE_STRING:
           TSHttpTxnConfigStringSet(txnp, override->key, override->data.rec_string, override->data_len);
-          TSDebug(PLUGIN_NAME, "Setting config id %d to `%s'", override->key, override->data.rec_string);
+          Dbg(dbg_ctl, "Setting config id %d to `%s'", override->key, override->data.rec_string);
           break;
         default:
           break; // Error ?
@@ -1033,9 +1035,9 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo *rri)
         dest     = static_cast<char *>(alloca(new_len + 8));
         dest_len = re->substitute(dest, match_buf, ovector, lengths, txnp, rri, &req_url, lowercase_substitutions);
 
-        TSDebug(PLUGIN_NAME, "New URL is estimated to be %d bytes long, or less", new_len);
-        TSDebug(PLUGIN_NAME, "New URL is %s (length %d)", dest, dest_len);
-        TSDebug(PLUGIN_NAME, "    matched rule %d [%s]", re->order(), re->regex());
+        Dbg(dbg_ctl, "New URL is estimated to be %d bytes long, or less", new_len);
+        Dbg(dbg_ctl, "New URL is %s (length %d)", dest, dest_len);
+        Dbg(dbg_ctl, "    matched rule %d [%s]", re->order(), re->regex());
 
         // Check for a quick response, if the status option is set
         if (re->status_option() > 0) {
@@ -1047,7 +1049,7 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo *rri)
             break;
           }
 
-          TSDebug(PLUGIN_NAME, "Redirecting URL, status=%d", re->status_option());
+          Dbg(dbg_ctl, "Redirecting URL, status=%d", re->status_option());
           TSHttpTxnStatusSet(txnp, re->status_option());
           rri->redirect = 1;
         }
diff --git a/plugins/regex_revalidate/regex_revalidate.cc b/plugins/regex_revalidate/regex_revalidate.cc
index ace011f1ac1..db1833cc098 100644
--- a/plugins/regex_revalidate/regex_revalidate.cc
+++ b/plugins/regex_revalidate/regex_revalidate.cc
@@ -57,20 +57,22 @@ static char const *const stat_name_stale = "plugin.regex_revalidate.stale";
 static int stat_id_miss                  = TS_ERROR;
 static char const *const stat_name_miss  = "plugin.regex_revalidate.miss";
 
+static DbgCtl dbg_ctl{PLUGIN_NAME};
+
 static void
 create_stats()
 {
   if (TS_ERROR == stat_id_stale && TS_ERROR == TSStatFindName(stat_name_stale, &stat_id_stale)) {
     stat_id_stale = TSStatCreate(stat_name_stale, TS_RECORDDATATYPE_INT, TS_STAT_NON_PERSISTENT, TS_STAT_SYNC_COUNT);
     if (TS_ERROR != stat_id_stale) {
-      TSDebug(PLUGIN_NAME, "Created stat '%s'", stat_name_stale);
+      Dbg(dbg_ctl, "Created stat '%s'", stat_name_stale);
     }
   }
 
   if (TS_ERROR == stat_id_miss && TS_ERROR == TSStatFindName(stat_name_miss, &stat_id_miss)) {
     stat_id_miss = TSStatCreate(stat_name_miss, TS_RECORDDATATYPE_INT, TS_STAT_NON_PERSISTENT, TS_STAT_SYNC_COUNT);
     if (TS_ERROR != stat_id_miss) {
-      TSDebug(PLUGIN_NAME, "Created stat '%s'", stat_name_miss);
+      Dbg(dbg_ctl, "Created stat '%s'", stat_name_miss);
     }
   }
 }
@@ -82,13 +84,13 @@ increment_stat(TSCacheLookupResult const result)
   case TS_CACHE_LOOKUP_MISS:
     if (TS_ERROR != stat_id_miss) {
       TSStatIntIncrement(stat_id_miss, 1);
-      TSDebug(PLUGIN_NAME, "Incrementing stat '%s'", stat_name_miss);
+      Dbg(dbg_ctl, "Incrementing stat '%s'", stat_name_miss);
     }
     break;
   case TS_CACHE_LOOKUP_HIT_STALE:
     if (TS_ERROR != stat_id_stale) {
       TSStatIntIncrement(stat_id_stale, 1);
-      TSDebug(PLUGIN_NAME, "Incrementing stat '%s'", stat_name_stale);
+      Dbg(dbg_ctl, "Incrementing stat '%s'", stat_name_stale);
     }
     break;
   default:
@@ -258,8 +260,8 @@ prune_config(invalidate_t **i)
     ilast = nullptr;
     while (iptr) {
       if (iptr->expiry <= now) {
-        TSDebug(PLUGIN_NAME, "Removing %s expiry: %jd type: %s now: %jd", iptr->regex_text, (intmax_t)iptr->expiry,
-                strForResult(iptr->new_result), (intmax_t)now);
+        Dbg(dbg_ctl, "Removing %s expiry: %jd type: %s now: %jd", iptr->regex_text, (intmax_t)iptr->expiry,
+            strForResult(iptr->new_result), (intmax_t)now);
         if (ilast) {
           ilast->next = iptr->next;
           free_invalidate_t(iptr);
@@ -288,7 +290,7 @@ load_state(plugin_state_t *pstate, invalidate_t **ilist)
 
   FILE *const fs = fopen(pstate->state_path, "r");
   if (NULL == fs) {
-    TSDebug(PLUGIN_NAME, "Could not open state %s for reading", pstate->state_path);
+    Dbg(dbg_ctl, "Could not open state %s for reading", pstate->state_path);
     return false;
   }
 
@@ -303,7 +305,7 @@ load_state(plugin_state_t *pstate, invalidate_t **ilist)
   char line[LINE_MAX];
   int ln = 0;
   while (fgets(line, LINE_MAX, fs) != nullptr) {
-    TSDebug(PLUGIN_NAME, "state: processing: %d %s", ln, line);
+    Dbg(dbg_ctl, "state: processing: %d %s", ln, line);
     ++ln;
     int const rc = pcre_exec(config_re, nullptr, line, strlen(line), 0, 0, ovector, OVECTOR_SIZE);
 
@@ -316,7 +318,7 @@ load_state(plugin_state_t *pstate, invalidate_t **ilist)
       inv->expiry = atoi(line + ovector[6]);
 
       if (inv->expiry < now) {
-        TSDebug(PLUGIN_NAME, "state: skipping expired : '%s'", inv->regex_text);
+        Dbg(dbg_ctl, "state: skipping expired : '%s'", inv->regex_text);
         free_invalidate_t(inv);
         continue;
       }
@@ -325,12 +327,12 @@ load_state(plugin_state_t *pstate, invalidate_t **ilist)
       char const *const type = line + ovector[8];
 
       if (0 == strncasecmp(type, RESULT_STALE, len)) {
-        TSDebug(PLUGIN_NAME, "state: regex line set to result type %s: '%s'", RESULT_STALE, inv->regex_text);
+        Dbg(dbg_ctl, "state: regex line set to result type %s: '%s'", RESULT_STALE, inv->regex_text);
       } else if (0 == strncasecmp(type, RESULT_MISS, len)) {
-        TSDebug(PLUGIN_NAME, "state: regex line set to result type %s: '%s'", RESULT_MISS, inv->regex_text);
+        Dbg(dbg_ctl, "state: regex line set to result type %s: '%s'", RESULT_MISS, inv->regex_text);
         inv->new_result = TS_CACHE_LOOKUP_MISS;
       } else {
-        TSDebug(PLUGIN_NAME, "state: unknown regex line result type '%.*s', skipping '%s'", len, type, inv->regex_text);
+        Dbg(dbg_ctl, "state: unknown regex line result type '%.*s', skipping '%s'", len, type, inv->regex_text);
       }
 
       // iterate through the loaded config and try to merge
@@ -338,7 +340,7 @@ load_state(plugin_state_t *pstate, invalidate_t **ilist)
       do {
         if (0 == strcmp(inv->regex_text, iptr->regex_text)) {
           if (iptr->expiry == inv->expiry && iptr->new_result == inv->new_result) {
-            TSDebug(PLUGIN_NAME, "state: restoring epoch for %s", iptr->regex_text);
+            Dbg(dbg_ctl, "state: restoring epoch for %s", iptr->regex_text);
             iptr->epoch = inv->epoch;
           }
           break;
@@ -352,7 +354,7 @@ load_state(plugin_state_t *pstate, invalidate_t **ilist)
 
       free_invalidate_t(inv);
     } else {
-      TSDebug(PLUGIN_NAME, "state: invalid line '%s'", line);
+      Dbg(dbg_ctl, "state: invalid line '%s'", line);
     }
   }
 
@@ -377,13 +379,13 @@ load_config(plugin_state_t *pstate, invalidate_t **ilist)
 
   int const fd = open(path, O_RDONLY);
   if (fd < 0) {
-    TSDebug(PLUGIN_NAME, "Could not open %s for reading", path);
+    Dbg(dbg_ctl, "Could not open %s for reading", path);
     return false;
   }
 
   struct stat s;
   if (fstat(fd, &s) < 0) {
-    TSDebug(PLUGIN_NAME, "Could not stat %s", path);
+    Dbg(dbg_ctl, "Could not stat %s", path);
     close(fd);
     return false;
   }
@@ -394,12 +396,12 @@ load_config(plugin_state_t *pstate, invalidate_t **ilist)
 
     FILE *const fs = fdopen(fd, "r");
     if (NULL == fs) {
-      TSDebug(PLUGIN_NAME, "Could not open %s for reading", path);
+      Dbg(dbg_ctl, "Could not open %s for reading", path);
       close(fd);
       return false;
     }
 
-    TSDebug(PLUGIN_NAME, "Attempting to load rules from: '%s'", path);
+    Dbg(dbg_ctl, "Attempting to load rules from: '%s'", path);
     const char *errptr;
     int erroffset;
     int ovector[OVECTOR_SIZE];
@@ -411,7 +413,7 @@ load_config(plugin_state_t *pstate, invalidate_t **ilist)
     invalidate_t *iptr, *i;
 
     while (fgets(line, LINE_MAX, fs) != nullptr) {
-      TSDebug(PLUGIN_NAME, "Processing: %d %s", ln, line);
+      Dbg(dbg_ctl, "Processing: %d %s", ln, line);
       ++ln;
       int const rc = pcre_exec(config_re, nullptr, line, strlen(line), 0, 0, ovector, OVECTOR_SIZE);
 
@@ -428,38 +430,38 @@ load_config(plugin_state_t *pstate, invalidate_t **ilist)
           int const len          = ovector[9] - ovector[8];
           char const *const type = line + ovector[8];
           if (0 == strncasecmp(type, RESULT_MISS, len)) {
-            TSDebug(PLUGIN_NAME, "Regex line set to result type %s: '%s'", RESULT_MISS, i->regex_text);
+            Dbg(dbg_ctl, "Regex line set to result type %s: '%s'", RESULT_MISS, i->regex_text);
             i->new_result = TS_CACHE_LOOKUP_MISS;
           } else if (0 != strncasecmp(type, RESULT_STALE, len)) {
-            TSDebug(PLUGIN_NAME, "Unknown regex line result type '%s', using default '%s' '%s'", type, RESULT_STALE, i->regex_text);
+            Dbg(dbg_ctl, "Unknown regex line result type '%s', using default '%s' '%s'", type, RESULT_STALE, i->regex_text);
           }
         }
 
         if (i->expiry <= i->epoch) {
-          TSDebug(PLUGIN_NAME, "Rule is already expired!");
+          Dbg(dbg_ctl, "Rule is already expired!");
           free_invalidate_t(i);
           i = nullptr;
         } else if (i->regex == nullptr) {
-          TSDebug(PLUGIN_NAME, "%s did not compile", i->regex_text);
+          Dbg(dbg_ctl, "%s did not compile", i->regex_text);
           free_invalidate_t(i);
           i = nullptr;
         } else {
           i->regex_extra = pcre_study(i->regex, 0, &errptr);
           if (!*ilist) {
             *ilist = i;
-            TSDebug(PLUGIN_NAME, "Created new list and Loaded %s %jd %jd %s", i->regex_text, (intmax_t)i->epoch,
-                    (intmax_t)i->expiry, strForResult(i->new_result));
+            Dbg(dbg_ctl, "Created new list and Loaded %s %jd %jd %s", i->regex_text, (intmax_t)i->epoch, (intmax_t)i->expiry,
+                strForResult(i->new_result));
           } else {
             iptr = *ilist;
             while (1) {
               if (strcmp(i->regex_text, iptr->regex_text) == 0) {
                 if (iptr->expiry != i->expiry) {
-                  TSDebug(PLUGIN_NAME, "Updating duplicate %s", i->regex_text);
+                  Dbg(dbg_ctl, "Updating duplicate %s", i->regex_text);
                   iptr->epoch  = i->epoch;
                   iptr->expiry = i->expiry;
                 }
                 if (iptr->new_result != i->new_result) {
-                  TSDebug(PLUGIN_NAME, "Resetting duplicate due to type change %s", i->regex_text);
+                  Dbg(dbg_ctl, "Resetting duplicate due to type change %s", i->regex_text);
                   iptr->new_result = i->new_result;
                   iptr->epoch      = now;
                 }
@@ -474,13 +476,13 @@ load_config(plugin_state_t *pstate, invalidate_t **ilist)
             }
             if (i) {
               iptr->next = i;
-              TSDebug(PLUGIN_NAME, "Loaded %s %jd %jd %s", i->regex_text, (intmax_t)i->epoch, (intmax_t)i->expiry,
-                      strForResult(i->new_result));
+              Dbg(dbg_ctl, "Loaded %s %jd %jd %s", i->regex_text, (intmax_t)i->epoch, (intmax_t)i->expiry,
+                  strForResult(i->new_result));
             }
           }
         }
       } else {
-        TSDebug(PLUGIN_NAME, "Skipping line %d, too few fields", ln);
+        Dbg(dbg_ctl, "Skipping line %d, too few fields", ln);
       }
     }
     pcre_free(config_re);
@@ -488,8 +490,7 @@ load_config(plugin_state_t *pstate, invalidate_t **ilist)
     pstate->last_load = s.st_mtime;
     return true;
   } else {
-    TSDebug(PLUGIN_NAME, "File mod time is not newer: ftime: %jd <= last_load: %jd", (intmax_t)s.st_mtime,
-            (intmax_t)pstate->last_load);
+    Dbg(dbg_ctl, "File mod time is not newer: ftime: %jd <= last_load: %jd", (intmax_t)s.st_mtime, (intmax_t)pstate->last_load);
   }
   close(fd);
   return false;
@@ -500,7 +501,7 @@ list_config(plugin_state_t *pstate, invalidate_t *i)
 {
   invalidate_t *iptr;
 
-  TSDebug(PLUGIN_NAME, "Current config:");
+  Dbg(dbg_ctl, "Current config:");
   if (pstate->log) {
     TSTextLogObjectWrite(pstate->log, "Current config:");
   }
@@ -509,7 +510,7 @@ list_config(plugin_state_t *pstate, invalidate_t *i)
   if (pstate->state_path) {
     state_file = fopen(pstate->state_path, "w");
     if (nullptr == state_file) {
-      TSDebug(PLUGIN_NAME, "Unable to open state file %s\n", pstate->state_path);
+      Dbg(dbg_ctl, "Unable to open state file %s\n", pstate->state_path);
     }
   }
 
@@ -517,8 +518,8 @@ list_config(plugin_state_t *pstate, invalidate_t *i)
     iptr = i;
     while (iptr) {
       char const *const typestr = strForResult(iptr->new_result);
-      TSDebug(PLUGIN_NAME, "%s epoch: %jd expiry: %jd result: %s", iptr->regex_text, (intmax_t)iptr->epoch, (intmax_t)iptr->expiry,
-              typestr);
+      Dbg(dbg_ctl, "%s epoch: %jd expiry: %jd result: %s", iptr->regex_text, (intmax_t)iptr->epoch, (intmax_t)iptr->expiry,
+          typestr);
       if (pstate->log) {
         TSTextLogObjectWrite(pstate->log, "%s epoch: %jd expiry: %jd result: %s", iptr->regex_text, (intmax_t)iptr->epoch,
                              (intmax_t)iptr->expiry, typestr);
@@ -530,7 +531,7 @@ list_config(plugin_state_t *pstate, invalidate_t *i)
     }
 
   } else {
-    TSDebug(PLUGIN_NAME, "EMPTY");
+    Dbg(dbg_ctl, "EMPTY");
     if (pstate->log) {
       TSTextLogObjectWrite(pstate->log, "EMPTY");
     }
@@ -546,7 +547,7 @@ free_handler(TSCont cont, TSEvent event, void *edata)
 {
   invalidate_t *iptr;
 
-  TSDebug(PLUGIN_NAME, "Freeing old config");
+  Dbg(dbg_ctl, "Freeing old config");
   iptr = (invalidate_t *)TSContDataGet(cont);
   free_invalidate_t_list(iptr);
   TSContDestroy(cont);
@@ -562,7 +563,7 @@ config_handler(TSCont cont, TSEvent event, void *edata)
   bool updated;
   TSMutex mutex;
 
-  TSDebug(PLUGIN_NAME, "In config_handler");
+  Dbg(dbg_ctl, "In config_handler");
 
   mutex = TSContMutexGet(cont);
   TSMutexLock(mutex);
@@ -583,7 +584,7 @@ config_handler(TSCont cont, TSEvent event, void *edata)
       TSContScheduleOnPool(free_cont, FREE_TMOUT, TS_THREAD_POOL_TASK);
     }
   } else {
-    TSDebug(PLUGIN_NAME, "No Changes");
+    Dbg(dbg_ctl, "No Changes");
     if (i) {
       free_invalidate_t_list(i);
     }
@@ -631,14 +632,14 @@ add_header(TSHttpTxn txn, const char *const header, invalidate_t *const rule)
   TSReleaseAssert(header && rule);
 
   if (TS_SUCCESS != TSHttpTxnClientReqGet(txn, &bufp, &lochdr)) {
-    TSDebug(PLUGIN_NAME, "Unable to get client request from transaction");
+    Dbg(dbg_ctl, "Unable to get client request from transaction");
   }
 
   rulelen =
     snprintf(rulestr, sizeof(rulestr), "%s %jd %s", rule->regex_text, (intmax_t)rule->expiry, strForResult(rule->new_result));
 
   if (TS_SUCCESS != TSStringPercentEncode(rulestr, rulelen, encstr, sizeof(encstr), &enclen, NULL)) {
-    TSDebug(PLUGIN_NAME, "Unable to get encode matching rule '%s'", rulestr);
+    Dbg(dbg_ctl, "Unable to get encode matching rule '%s'", rulestr);
     return;
   }
 
@@ -648,7 +649,7 @@ add_header(TSHttpTxn txn, const char *const header, invalidate_t *const rule)
     if (TS_SUCCESS == TSMimeHdrFieldCreateNamed(bufp, lochdr, header, strlen(header), &locfield)) {
       if (TS_SUCCESS == TSMimeHdrFieldValueStringSet(bufp, lochdr, locfield, -1, encstr, enclen)) {
         TSMimeHdrFieldAppend(bufp, lochdr, locfield);
-        TSDebug(PLUGIN_NAME, "Added header %s: '%.*s'", header, (int)enclen, encstr);
+        Dbg(dbg_ctl, "Added header %s: '%.*s'", header, (int)enclen, encstr);
       }
     }
     TSHandleMLocRelease(bufp, lochdr, locfield);
@@ -659,7 +660,7 @@ add_header(TSHttpTxn txn, const char *const header, invalidate_t *const rule)
       if (first) {
         first = false;
         TSMimeHdrFieldValueStringSet(bufp, lochdr, locfield, -1, encstr, enclen);
-        TSDebug(PLUGIN_NAME, "Added header '%s': '%.*s'", header, (int)enclen, encstr);
+        Dbg(dbg_ctl, "Added header '%s': '%.*s'", header, (int)enclen, encstr);
       } else {
         TSMimeHdrFieldDestroy(bufp, lochdr, locfield);
       }
@@ -690,17 +691,17 @@ main_handler(TSCont cont, TSEvent event, void *edata)
         while (iptr) {
           if (!date) {
             date = get_date_from_cached_hdr(txn);
-            TSDebug(PLUGIN_NAME, "Cached Date header is: %jd", intmax_t(date));
+            Dbg(dbg_ctl, "Cached Date header is: %jd", intmax_t(date));
             now = time(nullptr);
           }
           if (date <= iptr->epoch && now < iptr->expiry) {
             if (!url) {
               url = TSHttpTxnEffectiveUrlStringGet(txn, &url_len);
-              TSDebug(PLUGIN_NAME, "Effective url is is '%.*s'", url_len, url);
+              Dbg(dbg_ctl, "Effective url is is '%.*s'", url_len, url);
             }
             if (pcre_exec(iptr->regex, iptr->regex_extra, url, url_len, 0, 0, nullptr, 0) >= 0) {
-              TSDebug(PLUGIN_NAME, "Forced revalidate, Match with rule regex: '%s' epoch: %jd, expiry: %jd, result: '%s'",
-                      iptr->regex_text, intmax_t(iptr->epoch), intmax_t(iptr->expiry), strForResult(iptr->new_result));
+              Dbg(dbg_ctl, "Forced revalidate, Match with rule regex: '%s' epoch: %jd, expiry: %jd, result: '%s'", iptr->regex_text,
+                  intmax_t(iptr->epoch), intmax_t(iptr->expiry), strForResult(iptr->new_result));
               TSHttpTxnCacheLookupStatusSet(txn, iptr->new_result);
               increment_stat(iptr->new_result);
 
@@ -752,7 +753,7 @@ TSPluginInit(int argc, const char *argv[])
   invalidate_t *iptr        = nullptr;
   bool disable_timed_reload = false;
 
-  TSDebug(PLUGIN_NAME, "Starting plugin init");
+  Dbg(dbg_ctl, "Starting plugin init");
 
   pstate = (plugin_state_t *)TSmalloc(sizeof(plugin_state_t));
   init_plugin_state_t(pstate);
@@ -799,16 +800,16 @@ TSPluginInit(int argc, const char *argv[])
   }
 
   if (!load_config(pstate, &iptr)) {
-    TSDebug(PLUGIN_NAME, "Problem loading config from file %s", pstate->config_path);
+    Dbg(dbg_ctl, "Problem loading config from file %s", pstate->config_path);
   } else {
     pstate->invalidate_list = iptr;
 
     /* Load and merge previous state if provided */
     if (nullptr != pstate->state_path) {
       if (!load_state(pstate, &iptr)) {
-        TSDebug(PLUGIN_NAME, "Problem loading state from file %s", pstate->state_path);
+        Dbg(dbg_ctl, "Problem loading state from file %s", pstate->state_path);
       } else {
-        TSDebug(PLUGIN_NAME, "Loaded state from file %s", pstate->state_path);
+        Dbg(dbg_ctl, "Loaded state from file %s", pstate->state_path);
       }
     }
 
@@ -825,7 +826,7 @@ TSPluginInit(int argc, const char *argv[])
     free_plugin_state_t(pstate);
     return;
   } else {
-    TSDebug(PLUGIN_NAME, "Plugin registration succeeded");
+    Dbg(dbg_ctl, "Plugin registration succeeded");
   }
 
   create_stats();
@@ -843,5 +844,5 @@ TSPluginInit(int argc, const char *argv[])
     TSContScheduleOnPool(config_cont, CONFIG_TMOUT, TS_THREAD_POOL_TASK);
   }
 
-  TSDebug(PLUGIN_NAME, "Plugin Init Complete");
+  Dbg(dbg_ctl, "Plugin Init Complete");
 }
diff --git a/plugins/remap_purge/remap_purge.cc b/plugins/remap_purge/remap_purge.cc
index f5941d662d2..8accafc2310 100644
--- a/plugins/remap_purge/remap_purge.cc
+++ b/plugins/remap_purge/remap_purge.cc
@@ -39,6 +39,8 @@
 static const char *PLUGIN_NAME = "remap_purge";
 static const char *DEFAULT_DIR = "var/trafficserver"; /* Not perfect, but no better API) */
 
+static DbgCtl dbg_ctl{PLUGIN_NAME};
+
 typedef struct PurgeInstance_t {
   char *id;
   char *secret;
@@ -82,7 +84,7 @@ init_purge_instance(PurgeInstance *purge)
 
   if (file) {
     if (fscanf(file, "%" PRId64 "", &purge->gen_id) > 0) {
-      TSDebug(PLUGIN_NAME, "Read genID from %s for %s", purge->state_file, purge->id);
+      Dbg(dbg_ctl, "Read genID from %s for %s", purge->state_file, purge->id);
     }
     fclose(file);
   } else {
@@ -115,10 +117,10 @@ update_purge_state(PurgeInstance *purge)
   TSMutexLock(purge->lock);
 
   ++purge->gen_id;
-  TSDebug(PLUGIN_NAME, "Bumping the Generation ID to %" PRId64 " for %s", purge->gen_id, purge->id);
+  Dbg(dbg_ctl, "Bumping the Generation ID to %" PRId64 " for %s", purge->gen_id, purge->id);
 
   if ((file = fopen(purge->state_file, "w"))) {
-    TSDebug(PLUGIN_NAME, "\tsaving state to %s", purge->state_file);
+    Dbg(dbg_ctl, "\tsaving state to %s", purge->state_file);
     fprintf(file, "%" PRId64 "", purge->gen_id);
     fclose(file);
   } else {
@@ -136,7 +138,7 @@ on_send_response_header(TSHttpTxn txnp, TSCont contp, PurgeInstance *purge)
   TSMBuffer bufp;
   TSMLoc hdr_loc;
 
-  TSDebug(PLUGIN_NAME, "Fixing up the response on the successful PURGE");
+  Dbg(dbg_ctl, "Fixing up the response on the successful PURGE");
   if (TS_SUCCESS == TSHttpTxnClientRespGet(txnp, &bufp, &hdr_loc)) {
     char response[1024];
     int len = snprintf(response, sizeof(response), "PURGED %s\r\n\r\n", purge->id);
@@ -169,7 +171,7 @@ purge_cont(TSCont contp, TSEvent event, void *edata)
     break;
 
   default:
-    TSDebug(PLUGIN_NAME, "Unexpected event: %d", event);
+    Dbg(dbg_ctl, "Unexpected event: %d", event);
     break;
   }
 
@@ -197,7 +199,7 @@ handle_purge(TSHttpTxn txnp, PurgeInstance *purge)
           int header_len;
 
           header = TSMimeHdrFieldValueStringGet(reqp, hdr_loc, field_loc, -1, &header_len);
-          TSDebug(PLUGIN_NAME, "Checking for %.*s == %s ?", header_len, header, purge->secret);
+          Dbg(dbg_ctl, "Checking for %.*s == %s ?", header_len, header, purge->secret);
           if (header && (header_len == purge->secret_len) && !memcmp(header, purge->secret, header_len)) {
             should_purge = true;
           }
@@ -209,7 +211,7 @@ handle_purge(TSHttpTxn txnp, PurgeInstance *purge)
           int path_len     = 0;
           const char *path = TSUrlPathGet(reqp, url_loc, &path_len);
 
-          TSDebug(PLUGIN_NAME, "Checking PATH = %.*s", path_len, path);
+          Dbg(dbg_ctl, "Checking PATH = %.*s", path_len, path);
           if (path && (path_len >= purge->secret_len)) {
             int s_path = path_len - 1;
 
@@ -234,12 +236,12 @@ handle_purge(TSHttpTxn txnp, PurgeInstance *purge)
   if (should_purge) {
     TSCont cont = TSContCreate(purge_cont, TSMutexCreate());
 
-    TSDebug(PLUGIN_NAME, "Setting up continuation for PURGE operation");
+    Dbg(dbg_ctl, "Setting up continuation for PURGE operation");
     TSContDataSet(cont, purge);
     TSHttpTxnHookAdd(txnp, TS_HTTP_SEND_RESPONSE_HDR_HOOK, cont);
     update_purge_state(purge);
   } else if (purge->gen_id > 0) {
-    TSDebug(PLUGIN_NAME, "Setting request gen_id to %" PRId64, purge->gen_id);
+    Dbg(dbg_ctl, "Setting request gen_id to %" PRId64, purge->gen_id);
     TSHttpTxnConfigIntSet(txnp, TS_CONFIG_HTTP_CACHE_GENERATION, purge->gen_id);
   }
 }
@@ -247,7 +249,7 @@ handle_purge(TSHttpTxn txnp, PurgeInstance *purge)
 TSReturnCode
 TSRemapInit(TSRemapInterface *api_info, char *errbuf, int errbuf_size)
 {
-  TSDebug(PLUGIN_NAME, "initialized");
+  Dbg(dbg_ctl, "initialized");
   return TS_SUCCESS;
 }
 
diff --git a/plugins/remap_stats/remap_stats.cc b/plugins/remap_stats/remap_stats.cc
index 27924404e34..bac8dcd9348 100644
--- a/plugins/remap_stats/remap_stats.cc
+++ b/plugins/remap_stats/remap_stats.cc
@@ -48,6 +48,8 @@ struct config_t {
 
 namespace
 {
+DbgCtl dbg_ctl{DEBUG_TAG};
+
 void
 stat_add(const char *name, TSMgmtInt amount, TSStatPersistence persist_type, TSMutex create_mutex)
 {
@@ -62,16 +64,16 @@ stat_add(const char *name, TSMgmtInt amount, TSStatPersistence persist_type, TSM
     if (TS_ERROR == TSStatFindName(name, &stat_id)) {
       stat_id = TSStatCreate(name, TS_RECORDDATATYPE_INT, persist_type, TS_STAT_SYNC_SUM);
       if (stat_id == TS_ERROR) {
-        TSDebug(DEBUG_TAG, "Error creating stat_name: %s", name);
+        Dbg(dbg_ctl, "Error creating stat_name: %s", name);
       } else {
-        TSDebug(DEBUG_TAG, "Created stat_name: %s stat_id: %d", name, stat_id);
+        Dbg(dbg_ctl, "Created stat_name: %s stat_id: %d", name, stat_id);
       }
     }
     TSMutexUnlock(create_mutex);
 
     if (stat_id >= 0) {
       hash.emplace(name, stat_id);
-      TSDebug(DEBUG_TAG, "Cached stat_name: %s stat_id: %d", name, stat_id);
+      Dbg(dbg_ctl, "Cached stat_name: %s stat_id: %d", name, stat_id);
     }
   } else {
     stat_id = hash.at(name);
@@ -80,7 +82,7 @@ stat_add(const char *name, TSMgmtInt amount, TSStatPersistence persist_type, TSM
   if (likely(stat_id >= 0)) {
     TSStatIntIncrement(stat_id, amount);
   } else {
-    TSDebug(DEBUG_TAG, "stat error! stat_name: %s stat_id: %d", name, stat_id);
+    Dbg(dbg_ctl, "stat error! stat_name: %s stat_id: %d", name, stat_id);
   }
 }
 
@@ -133,7 +135,7 @@ handle_post_remap(TSCont cont, TSEvent event ATS_UNUSED, void *edata)
   void *const txnd       = reinterpret_cast<void *>(0x01);
   TSUserArgSet(txn, config->txn_slot, txnd);
   TSHttpTxnReenable(txn, TS_EVENT_HTTP_CONTINUE);
-  TSDebug(DEBUG_TAG, "Post Remap Handler Finished");
+  Dbg(dbg_ctl, "Post Remap Handler Finished");
   return 0;
 }
 
@@ -205,11 +207,11 @@ handle_txn_close(TSCont cont, TSEvent event ATS_UNUSED, void *edata)
       stat_add(stat_name.data(), 1, config->persist_type, config->stat_creation_mutex);
     }
   } else {
-    TSDebug(DEBUG_TAG, "skipping unsuccessfully remapped transaction");
+    Dbg(dbg_ctl, "skipping unsuccessfully remapped transaction");
   }
 
   TSHttpTxnReenable(txn, TS_EVENT_HTTP_CONTINUE);
-  TSDebug(DEBUG_TAG, "Handler Finished");
+  Dbg(dbg_ctl, "Handler Finished");
   return 0;
 }
 
@@ -228,7 +230,7 @@ TSPluginInit(int argc, const char *argv[])
 
     return;
   } else {
-    TSDebug(DEBUG_TAG, "Plugin registration succeeded");
+    Dbg(dbg_ctl, "Plugin registration succeeded");
   }
 
   auto config                 = new config_t;
@@ -242,10 +244,10 @@ TSPluginInit(int argc, const char *argv[])
       std::string_view const arg(argv[ii]);
       if (arg == "-P" || arg == "--post-remap-host") {
         config->uri_type = REMAP;
-        TSDebug(DEBUG_TAG, "Using post remap hostname");
+        Dbg(dbg_ctl, "Using post remap hostname");
       } else if (arg == "-p" || arg == "--persistent") {
         config->persist_type = TS_STAT_PERSISTENT;
-        TSDebug(DEBUG_TAG, "Using persistent stats");
+        Dbg(dbg_ctl, "Using persistent stats");
       }
     }
   }
@@ -262,5 +264,5 @@ TSPluginInit(int argc, const char *argv[])
   TSContDataSet(global_cont, static_cast<void *>(config));
   TSHttpHookAdd(TS_HTTP_TXN_CLOSE_HOOK, global_cont);
 
-  TSDebug(DEBUG_TAG, "Init complete");
+  Dbg(dbg_ctl, "Init complete");
 }
diff --git a/plugins/s3_auth/s3_auth.cc b/plugins/s3_auth/s3_auth.cc
index cedc2e8e146..f43ce160066 100644
--- a/plugins/s3_auth/s3_auth.cc
+++ b/plugins/s3_auth/s3_auth.cc
@@ -59,6 +59,8 @@
 static const char PLUGIN_NAME[] = "s3_auth";
 static const char DATE_FMT[]    = "%a, %d %b %Y %H:%M:%S %z";
 
+static DbgCtl dbg_ctl{PLUGIN_NAME};
+
 /**
  * @brief Rebase a relative path onto the configuration directory.
  */
@@ -93,7 +95,7 @@ loadRegionMap(StringMap &m, const String &filename)
     return false;
   }
 
-  TSDebug(PLUGIN_NAME, "loading region mapping from '%s'", path.c_str());
+  Dbg(dbg_ctl, "loading region mapping from '%s'", path.c_str());
 
   m[""] = ""; /* set a default just in case if the user does not specify it */
 
@@ -120,21 +122,21 @@ loadRegionMap(StringMap &m, const String &filename)
     String region(trimWhiteSpaces(String(line, d + 1, String::npos)));
 
     if (region.empty()) {
-      TSDebug(PLUGIN_NAME, "<s3-region> in '%s' cannot be empty (skipped), expected format: '%s'", line.c_str(), EXPECTED_FORMAT);
+      Dbg(dbg_ctl, "<s3-region> in '%s' cannot be empty (skipped), expected format: '%s'", line.c_str(), EXPECTED_FORMAT);
       continue;
     }
 
     if (entrypoint.empty()) {
-      TSDebug(PLUGIN_NAME, "added default region %s", region.c_str());
+      Dbg(dbg_ctl, "added default region %s", region.c_str());
     } else {
-      TSDebug(PLUGIN_NAME, "added entry-point:%s, region:%s", entrypoint.c_str(), region.c_str());
+      Dbg(dbg_ctl, "added entry-point:%s, region:%s", entrypoint.c_str(), region.c_str());
     }
 
     m[entrypoint] = region;
   }
 
   if (m.at("").empty()) {
-    TSDebug(PLUGIN_NAME, "default region was not defined");
+    Dbg(dbg_ctl, "default region was not defined");
   }
 
   ifstr.close();
@@ -233,16 +235,16 @@ class S3Config
     /* Optional parameters, issue warning if v2 parameters are used with v4 and vice-versa (wrong parameters are ignored anyways) */
     if (2 == _version) {
       if (_v4includeHeaders_modified && !_v4includeHeaders.empty()) {
-        TSDebug("[%s] headers are not being signed with AWS auth v2, included headers parameter ignored", PLUGIN_NAME);
+        Dbg(dbg_ctl, "headers are not being signed with AWS auth v2, included headers parameter ignored");
       }
       if (_v4excludeHeaders_modified && !_v4excludeHeaders.empty()) {
-        TSDebug("[%s] headers are not being signed with AWS auth v2, excluded headers parameter ignored", PLUGIN_NAME);
+        Dbg(dbg_ctl, "headers are not being signed with AWS auth v2, excluded headers parameter ignored");
       }
       if (_region_map_modified && !_region_map.empty()) {
-        TSDebug("[%s] region map is not used with AWS auth v2, parameter ignored", PLUGIN_NAME);
+        Dbg(dbg_ctl, "region map is not used with AWS auth v2, parameter ignored");
       }
       if (nullptr != _token || _token_len > 0) {
-        TSDebug("[%s] session token support with AWS auth v2 is not implemented, parameter ignored", PLUGIN_NAME);
+        Dbg(dbg_ctl, "session token support with AWS auth v2 is not implemented, parameter ignored");
       }
     } else {
       /* 4 == _version */
@@ -613,7 +615,7 @@ ConfigCache::get(const char *fname)
     unsigned update_status = it->second.update_status;
     if (tv.tv_sec > (it->second.load_time + _ttl)) {
       if (!(update_status & 1) && it->second.update_status.compare_exchange_strong(update_status, update_status + 1)) {
-        TSDebug(PLUGIN_NAME, "Configuration from %s is stale, reloading", config_fname.c_str());
+        Dbg(dbg_ctl, "Configuration from %s is stale, reloading", config_fname.c_str());
         s3 = new S3Config(false); // false == this config does not get the continuation
 
         if (s3->parse_config(config_fname)) {
@@ -642,14 +644,14 @@ ConfigCache::get(const char *fname)
         s3 = it->second.config;
       }
     } else {
-      TSDebug(PLUGIN_NAME, "Configuration from %s is fresh, reusing", config_fname.c_str());
+      Dbg(dbg_ctl, "Configuration from %s is fresh, reusing", config_fname.c_str());
       s3 = it->second.config;
     }
   } else {
     // Create a new cached file.
     s3 = new S3Config(false); // false == this config does not get the continuation
 
-    TSDebug(PLUGIN_NAME, "Parsing and caching configuration from %s, version:%d", config_fname.c_str(), s3->version());
+    Dbg(dbg_ctl, "Parsing and caching configuration from %s, version:%d", config_fname.c_str(), s3->version());
     if (s3->parse_config(config_fname)) {
       s3->set_conf_fname(fname);
       _cache.emplace(config_fname, _ConfigData(s3, tv.tv_sec));
@@ -742,7 +744,7 @@ S3Request::set_header(const char *header, int header_len, const char *val, int v
   }
 
   if (ret) {
-    TSDebug(PLUGIN_NAME, "Set the header %.*s: %.*s", header_len, header, val_len, val);
+    Dbg(dbg_ctl, "Set the header %.*s: %.*s", header_len, header, val_len, val);
   }
 
   return ret;
@@ -894,19 +896,19 @@ S3Request::authorizeV2(S3Config *s3)
   }
 
   // For debugging, lets produce some nice output
-  if (TSIsDebugTagSet(PLUGIN_NAME)) {
-    TSDebug(PLUGIN_NAME, "Signature string is:");
+  if (dbg_ctl.on()) {
+    Dbg(dbg_ctl, "Signature string is:");
     // ToDo: This should include the Content-MD5 and Content-Type (for POST)
-    TSDebug(PLUGIN_NAME, "%.*s", method_len, method);
+    Dbg(dbg_ctl, "%.*s", method_len, method);
     if (con_md5) {
-      TSDebug(PLUGIN_NAME, "%.*s", con_md5_len, con_md5);
+      Dbg(dbg_ctl, "%.*s", con_md5_len, con_md5);
     }
 
     if (con_type) {
-      TSDebug(PLUGIN_NAME, "%.*s", con_type_len, con_type);
+      Dbg(dbg_ctl, "%.*s", con_type_len, con_type);
     }
 
-    TSDebug(PLUGIN_NAME, "%.*s", date_len, date);
+    Dbg(dbg_ctl, "%.*s", date_len, date);
 
     const size_t left_size   = 1024;
     char left[left_size + 1] = "/";
@@ -925,7 +927,7 @@ S3Request::authorizeV2(S3Config *s3)
       str_concat(&left[loff], (left_size - loff), param, param_len);
     }
 
-    TSDebug(PLUGIN_NAME, "%s", left);
+    Dbg(dbg_ctl, "%s", left);
   }
 
 // Produce the SHA1 MAC digest
@@ -1012,16 +1014,16 @@ event_handler(TSCont cont, TSEvent event, void *edata)
       }
 
       if (TS_HTTP_STATUS_OK == status) {
-        TSDebug(PLUGIN_NAME, "Successfully signed the AWS S3 URL");
+        Dbg(dbg_ctl, "Successfully signed the AWS S3 URL");
       } else {
-        TSDebug(PLUGIN_NAME, "Failed to sign the AWS S3 URL, status = %d", status);
+        Dbg(dbg_ctl, "Failed to sign the AWS S3 URL, status = %d", status);
         TSHttpTxnStatusSet(txnp, status);
         enable_event = TS_EVENT_HTTP_ERROR;
       }
       break;
     default:
       TSError("[%s] Unknown event for this plugin", PLUGIN_NAME);
-      TSDebug(PLUGIN_NAME, "unknown event for this plugin");
+      Dbg(dbg_ctl, "unknown event for this plugin");
       break;
     }
     // Most get S3Request out of scope in case the later plugins invalidate the TSAPI
@@ -1050,7 +1052,7 @@ cal_reload_delay(long time_diff)
 int
 config_reloader(TSCont cont, TSEvent event, void *edata)
 {
-  TSDebug(PLUGIN_NAME, "reloading configs");
+  Dbg(dbg_ctl, "reloading configs");
   S3Config *s3          = static_cast<S3Config *>(TSContDataGet(cont));
   S3Config *file_config = gConfCache.get(s3->conf_fname());
 
@@ -1066,18 +1068,18 @@ config_reloader(TSCont cont, TSEvent event, void *edata)
   }
 
   if (s3->expiration() == 0) {
-    TSDebug(PLUGIN_NAME, "disabling auto config reload");
+    Dbg(dbg_ctl, "disabling auto config reload");
   } else {
     // auto reload is scheduled to be 5 minutes before the expiration time to get some headroom
     long time_diff = s3->expiration() -
                      std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();
     if (time_diff > 0) {
       long delay = cal_reload_delay(time_diff);
-      TSDebug(PLUGIN_NAME, "scheduling config reload with %ld seconds delay", delay);
+      Dbg(dbg_ctl, "scheduling config reload with %ld seconds delay", delay);
       s3->reset_conf_reload_count();
       s3->schedule_conf_reload(delay);
     } else {
-      TSDebug(PLUGIN_NAME, "config expiration time is in the past, re-checking in 1 minute");
+      Dbg(dbg_ctl, "config expiration time is in the past, re-checking in 1 minute");
       if (s3->incr_conf_reload_count() == 10) {
         TSError("[%s] tried to reload config automatically but failed, please try manual reloading the config", PLUGIN_NAME);
       }
@@ -1095,7 +1097,7 @@ TSReturnCode
 TSRemapInit(TSRemapInterface *api_info, char *errbuf, int errbuf_size)
 {
   CHECK_REMAP_API_COMPATIBILITY(api_info, errbuf, errbuf_size);
-  TSDebug(PLUGIN_NAME, "plugin is successfully initialized");
+  Dbg(dbg_ctl, "plugin is successfully initialized");
   return TS_SUCCESS;
 }
 
@@ -1182,25 +1184,24 @@ TSRemapNewInstance(int argc, char *argv[], void **ih, char * /* errbuf ATS_UNUSE
   }
 
   if (s3->expiration() == 0) {
-    TSDebug(PLUGIN_NAME, "disabling auto config reload");
+    Dbg(dbg_ctl, "disabling auto config reload");
   } else {
     // auto reload is scheduled to be 5 minutes before the expiration time to get some headroom
     long time_diff = s3->expiration() -
                      std::chrono::duration_cast<std::chrono::seconds>(std::chrono::system_clock::now().time_since_epoch()).count();
     if (time_diff > 0) {
       long delay = cal_reload_delay(time_diff);
-      TSDebug(PLUGIN_NAME, "scheduling config reload with %ld seconds delay", delay);
+      Dbg(dbg_ctl, "scheduling config reload with %ld seconds delay", delay);
       s3->reset_conf_reload_count();
       s3->schedule_conf_reload(delay);
     } else {
-      TSDebug(PLUGIN_NAME, "config expiration time is in the past, re-checking in 1 minute");
+      Dbg(dbg_ctl, "config expiration time is in the past, re-checking in 1 minute");
       s3->schedule_conf_reload(60);
     }
   }
 
   *ih = static_cast<void *>(s3);
-  TSDebug(PLUGIN_NAME, "New rule: access_key=%s, virtual_host=%s, version=%d", s3->keyid(), s3->virt_host() ? "yes" : "no",
-          s3->version());
+  Dbg(dbg_ctl, "New rule: access_key=%s, virtual_host=%s, version=%d", s3->keyid(), s3->virt_host() ? "yes" : "no", s3->version());
 
   return TS_SUCCESS;
 }
@@ -1229,7 +1230,7 @@ TSRemapDoRemap(void *ih, TSHttpTxn txnp, TSRemapRequestInfo * /* rri */)
     // configs via a TXN argument.
     s3->schedule(txnp);
   } else {
-    TSDebug(PLUGIN_NAME, "Remap context is invalid");
+    Dbg(dbg_ctl, "Remap context is invalid");
     TSError("[%s] No remap context available, check code / config", PLUGIN_NAME);
     TSHttpTxnStatusSet(txnp, TS_HTTP_STATUS_INTERNAL_SERVER_ERROR);
   }
diff --git a/plugins/server_push_preload/server_push_preload.cc b/plugins/server_push_preload/server_push_preload.cc
index b869c242da6..0b97979a88e 100644
--- a/plugins/server_push_preload/server_push_preload.cc
+++ b/plugins/server_push_preload/server_push_preload.cc
@@ -43,6 +43,8 @@ namespace
 {
 GlobalPlugin *globalPlugin;
 RemapPlugin *remapPlugin;
+
+DbgCtl dbg_ctl{PLUGIN_NAME};
 } // namespace
 
 class ServerPushTransaction : public TransactionPlugin
@@ -80,12 +82,12 @@ class ServerPushTransaction : public TransactionPlugin
       for (header_field_value_iterator hit = field.begin(); hit != field.end(); ++hit) {
         const string &link = *hit;
 
-        TSDebug(PLUGIN_NAME, "Parsing link header: %s", link.c_str());
+        Dbg(dbg_ctl, "Parsing link header: %s", link.c_str());
         smatch matches;
 
         if (regex_search(link, matches, linkRegexp)) {
           string url = matches[1].str();
-          TSDebug(PLUGIN_NAME, "Found link header match: %s", url.c_str());
+          Dbg(dbg_ctl, "Found link header match: %s", url.c_str());
 
           set<string> params = split(matches[2].str(), ';');
           auto preload       = params.find(PRELOAD_PARAM);
@@ -95,7 +97,7 @@ class ServerPushTransaction : public TransactionPlugin
 
           auto noPush = params.find(NOPUSH_OPTION);
           if (noPush != params.end()) {
-            TSDebug(PLUGIN_NAME, "Skipping nopush link: %s", link.c_str());
+            Dbg(dbg_ctl, "Skipping nopush link: %s", link.c_str());
             continue;
           }
 
@@ -110,10 +112,10 @@ class ServerPushTransaction : public TransactionPlugin
             linkUrl.setPort(clientUrl.getPort());
           }
           string lu = linkUrl.getUrlString();
-          TSDebug(PLUGIN_NAME, "Push preloaded content: %s", lu.c_str());
+          Dbg(dbg_ctl, "Push preloaded content: %s", lu.c_str());
           TSHttpTxnServerPush(txnp, lu.c_str(), lu.length());
         } else {
-          TSDebug(PLUGIN_NAME, "No match found for link header: %s", link.c_str());
+          Dbg(dbg_ctl, "No match found for link header: %s", link.c_str());
         }
       }
     }
@@ -163,7 +165,7 @@ class ServerPushGlobal : public GlobalPlugin
 void
 TSPluginInit(int argc ATSCPPAPI_UNUSED, const char *argv[] ATSCPPAPI_UNUSED)
 {
-  TSDebug(PLUGIN_NAME, "Init");
+  Dbg(dbg_ctl, "Init");
   if (!RegisterGlobalPlugin("ServerPushPreloadPlugin", PLUGIN_NAME, "dev@trafficserver.apache.org")) {
     return;
   }
@@ -174,7 +176,7 @@ TSReturnCode
 TSRemapNewInstance(int argc ATSCPPAPI_UNUSED, char *argv[] ATSCPPAPI_UNUSED, void **instance_handle, char *errbuf ATSCPPAPI_UNUSED,
                    int errbuf_size ATSCPPAPI_UNUSED)
 {
-  TSDebug(PLUGIN_NAME, "New Instance");
+  Dbg(dbg_ctl, "New Instance");
   remapPlugin = new ServerPushRemap(instance_handle);
   return TS_SUCCESS;
 }
diff --git a/plugins/slice/client.cc b/plugins/slice/client.cc
index bfb036ccb87..3f67240586c 100644
--- a/plugins/slice/client.cc
+++ b/plugins/slice/client.cc
@@ -165,7 +165,7 @@ handle_client_resp(TSCont contp, TSEvent event, Data *const data)
     }
   } break;
   case TS_EVENT_VCONN_WRITE_COMPLETE: {
-    if (TSIsDebugTagSet(PLUGIN_NAME) && reader_avail_more_than(data->m_upstream.m_read.m_reader, 0)) {
+    if (dbg_ctl.on() && reader_avail_more_than(data->m_upstream.m_read.m_reader, 0)) {
       int64_t const left = TSIOBufferReaderAvail(data->m_upstream.m_read.m_reader);
       DEBUG_LOG("%p WRITE_COMPLETE called with %" PRId64 " bytes left", data, left);
     }
diff --git a/plugins/slice/prefetch.cc b/plugins/slice/prefetch.cc
index a83d25a6310..eb48f14d4f9 100644
--- a/plugins/slice/prefetch.cc
+++ b/plugins/slice/prefetch.cc
@@ -92,7 +92,7 @@ BgBlockFetch::fetch(Data *const data)
   m_stream.setupVioWrite(m_cont, hlen);
   TSHttpHdrPrint(header.m_buffer, header.m_lochdr, m_stream.m_write.m_iobuf);
 
-  if (TSIsDebugTagSet(PLUGIN_NAME)) {
+  if (dbg_ctl.on()) {
     std::string const headerstr(header.toString());
     DEBUG_LOG("Headers\n%s", headerstr.c_str());
   }
diff --git a/plugins/slice/server.cc b/plugins/slice/server.cc
index 98c5cb8ad64..4d4b0e78883 100644
--- a/plugins/slice/server.cc
+++ b/plugins/slice/server.cc
@@ -92,7 +92,7 @@ handleFirstServerHeader(Data *const data, TSCont const contp)
 {
   HttpHeader header(data->m_resp_hdrmgr.m_buffer, data->m_resp_hdrmgr.m_lochdr);
 
-  if (TSIsDebugTagSet(PLUGIN_NAME)) {
+  if (dbg_ctl.on()) {
     DEBUG_LOG("First header\n%s", header.toString().c_str());
   }
 
@@ -247,7 +247,7 @@ logSliceError(char const *const message, Data const *const data, HttpHeader cons
   bool const logToError = conf->canLogError();
 
   // always write block stitch errors while in debug mode
-  if (!logToError && !TSIsDebugTagSet(PLUGIN_NAME)) {
+  if (!logToError && !dbg_ctl.on()) {
     return;
   }
 
@@ -354,7 +354,7 @@ handleNextServerHeader(Data *const data, TSCont const contp)
 {
   // block response header
   HttpHeader header(data->m_resp_hdrmgr.m_buffer, data->m_resp_hdrmgr.m_lochdr);
-  if (TSIsDebugTagSet(PLUGIN_NAME)) {
+  if (dbg_ctl.on()) {
     DEBUG_LOG("Next Header:\n%s", header.toString().c_str());
   }
 
diff --git a/plugins/slice/slice.cc b/plugins/slice/slice.cc
index 87854c5ed53..9453e73a63a 100644
--- a/plugins/slice/slice.cc
+++ b/plugins/slice/slice.cc
@@ -166,7 +166,7 @@ read_request(TSHttpTxn txnp, Config *const config)
       data->m_buffer_index      = TSPluginVCIOBufferIndexGet(data->m_txnp);     // default of m_buffer_index = 32KB
       data->m_buffer_water_mark = TSPluginVCIOBufferWaterMarkGet(data->m_txnp); // default of m_buffer_water_mark = 0
 
-      if (TSIsDebugTagSet(PLUGIN_NAME)) {
+      if (dbg_ctl.on()) {
         int len            = 0;
         char *const urlstr = TSUrlStringGet(data->m_urlbuf, data->m_urlloc, &len);
         DEBUG_LOG("slice url: %.*s", len, urlstr);
@@ -208,6 +208,11 @@ global_read_request_hook(TSCont // contp
 
 } // namespace
 
+namespace slice_ns
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 ///// remap plugin engine
 
 TSRemapStatus
diff --git a/plugins/slice/slice.h b/plugins/slice/slice.h
index 6fe04601172..3a2d310d612 100644
--- a/plugins/slice/slice.h
+++ b/plugins/slice/slice.h
@@ -29,12 +29,18 @@
 
 #if !defined(UNITTEST)
 
+namespace slice_ns
+{
+extern DbgCtl dbg_ctl;
+}
+using namespace slice_ns;
+
 #define __FILENAME__        (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__)
-#define DEBUG_LOG(fmt, ...) TSDebug(PLUGIN_NAME, "[%s:% 4d] %s(): " fmt, __FILENAME__, __LINE__, __func__, ##__VA_ARGS__)
+#define DEBUG_LOG(fmt, ...) Dbg(dbg_ctl, "[%s:% 4d] %s(): " fmt, __FILENAME__, __LINE__, __func__, ##__VA_ARGS__)
 
 #define ERROR_LOG(fmt, ...)                                                                         \
   TSError("[%s/%s:% 4d] %s(): " fmt, PLUGIN_NAME, __FILENAME__, __LINE__, __func__, ##__VA_ARGS__); \
-  TSDebug(PLUGIN_NAME, "[%s:%04d] %s(): " fmt, __FILENAME__, __LINE__, __func__, ##__VA_ARGS__)
+  Dbg(dbg_ctl, "[%s:%04d] %s(): " fmt, __FILENAME__, __LINE__, __func__, ##__VA_ARGS__)
 
 #else
 
diff --git a/plugins/slice/util.cc b/plugins/slice/util.cc
index 71d99b98698..f6dce2c5032 100644
--- a/plugins/slice/util.cc
+++ b/plugins/slice/util.cc
@@ -118,7 +118,7 @@ request_block(TSCont contp, Data *const data)
   TSHttpHdrPrint(header.m_buffer, header.m_lochdr, data->m_upstream.m_write.m_iobuf);
   TSVIOReenable(data->m_upstream.m_write.m_vio);
 
-  if (TSIsDebugTagSet(PLUGIN_NAME)) {
+  if (dbg_ctl.on()) {
     std::string const headerstr(header.toString());
     DEBUG_LOG("Headers\n%s", headerstr.c_str());
   }
diff --git a/plugins/statichit/statichit.cc b/plugins/statichit/statichit.cc
index ddb2f8aa158..ac9ef9786b2 100644
--- a/plugins/statichit/statichit.cc
+++ b/plugins/statichit/statichit.cc
@@ -44,10 +44,12 @@
 
 constexpr char PLUGIN[] = "statichit";
 
-#define VDEBUG(fmt, ...) TSDebug(PLUGIN, fmt, ##__VA_ARGS__)
+static DbgCtl dbg_ctl{PLUGIN};
+
+#define VDEBUG(fmt, ...) Dbg(dbg_ctl, fmt, ##__VA_ARGS__)
 
 #if DEBUG
-#define VERROR(fmt, ...) TSDebug(PLUGIN, fmt, ##__VA_ARGS__)
+#define VERROR(fmt, ...) Dbg(dbg_ctl, fmt, ##__VA_ARGS__)
 #else
 #define VERROR(fmt, ...) TSError("[%s] %s: " fmt, PLUGIN, __FUNCTION__, ##__VA_ARGS__)
 #endif
diff --git a/plugins/stats_over_http/stats_over_http.cc b/plugins/stats_over_http/stats_over_http.cc
index 3681e59b01b..6c6e3829def 100644
--- a/plugins/stats_over_http/stats_over_http.cc
+++ b/plugins/stats_over_http/stats_over_http.cc
@@ -60,6 +60,8 @@
 #define SYSTEM_RECORD_TYPE   (0x100)
 #define DEFAULT_RECORD_TYPES (SYSTEM_RECORD_TYPE | TS_RECORDTYPE_PROCESS | TS_RECORDTYPE_PLUGIN)
 
+static DbgCtl dbg_ctl{PLUGIN_NAME};
+
 static const swoc::IP4Range DEFAULT_IP{swoc::IP4Addr::MIN, swoc::IP4Addr::MAX};
 static const swoc::IP6Range DEFAULT_IP6{swoc::IP6Addr::MIN, swoc::IP6Addr::MAX};
 
@@ -165,7 +167,7 @@ init_br(stats_state *my_state)
 
   my_state->bstrm.br = BrotliEncoderCreateInstance(nullptr, nullptr, nullptr);
   if (!my_state->bstrm.br) {
-    TSDebug(PLUGIN_NAME, "Brotli Encoder Instance Failed");
+    Dbg(dbg_ctl, "Brotli Encoder Instance Failed");
     return NONE;
   }
   BrotliEncoderSetParameter(my_state->bstrm.br, BROTLI_PARAM_QUALITY, BROTLI_COMPRESSION_LEVEL);
@@ -204,10 +206,10 @@ init_gzip(stats_state *my_state, int mode)
   my_state->zstrm.data_type = Z_ASCII;
   int err = deflateInit2(&my_state->zstrm, ZLIB_COMPRESSION_LEVEL, Z_DEFLATED, mode, ZLIB_MEMLEVEL, Z_DEFAULT_STRATEGY);
   if (err != Z_OK) {
-    TSDebug(PLUGIN_NAME, "gzip initialization failed");
+    Dbg(dbg_ctl, "gzip initialization failed");
     return NONE;
   } else {
-    TSDebug(PLUGIN_NAME, "gzip initialized successfully");
+    Dbg(dbg_ctl, "gzip initialized successfully");
     if (mode == GZIP_MODE) {
       return GZIP;
     } else if (mode == DEFLATE_MODE) {
@@ -305,7 +307,7 @@ stats_add_resp_header(stats_state *my_state)
 static void
 stats_process_read(TSCont contp, TSEvent event, stats_state *my_state)
 {
-  TSDebug(PLUGIN_NAME, "stats_process_read(%d)", event);
+  Dbg(dbg_ctl, "stats_process_read(%d)", event);
   if (event == TS_EVENT_VCONN_READ_READY) {
     my_state->output_bytes = stats_add_resp_header(my_state);
     TSVConnShutdown(my_state->net_vc, 1, 0);
@@ -389,7 +391,7 @@ json_out_stat(TSRecordType rec_type, void *edata, int registered, const char *na
     APPEND_STAT_JSON(name, "%s", datum->rec_string);
     break;
   default:
-    TSDebug(PLUGIN_NAME, "unknown type for %s: %d", name, data_type);
+    Dbg(dbg_ctl, "unknown type for %s: %d", name, data_type);
     break;
   }
 }
@@ -412,7 +414,7 @@ csv_out_stat(TSRecordType rec_type, void *edata, int registered, const char *nam
     APPEND_STAT_CSV(name, "%s", datum->rec_string);
     break;
   default:
-    TSDebug(PLUGIN_NAME, "unknown type for %s: %d", name, data_type);
+    Dbg(dbg_ctl, "unknown type for %s: %d", name, data_type);
     break;
   }
 }
@@ -456,7 +458,7 @@ br_out_stats(stats_state *my_state)
                                           &outputsize, outputbuf);
 
   if (err == BROTLI_FALSE) {
-    TSDebug(PLUGIN_NAME, "brotli compress error");
+    Dbg(dbg_ctl, "brotli compress error");
   }
   my_state->output_bytes += TSIOBufferWrite(my_state->resp_buffer, outputbuf, outputsize);
   BrotliEncoderDestroyInstance(my_state->bstrm.br);
@@ -487,12 +489,12 @@ gzip_out_stats(stats_state *my_state)
   my_state->zstrm.next_out   = (Bytef *)outputbuf;
   int err                    = deflate(&my_state->zstrm, Z_FINISH);
   if (err != Z_STREAM_END) {
-    TSDebug(PLUGIN_NAME, "deflate error: %d", err);
+    Dbg(dbg_ctl, "deflate error: %d", err);
   }
 
   err = deflateEnd(&my_state->zstrm);
   if (err != Z_OK) {
-    TSDebug(PLUGIN_NAME, "deflate end err: %d", err);
+    Dbg(dbg_ctl, "deflate end err: %d", err);
   }
 
   my_state->output_bytes += TSIOBufferWrite(my_state->resp_buffer, outputbuf, my_state->zstrm.total_out);
@@ -575,7 +577,7 @@ stats_origin(TSCont contp, TSEvent event, void *edata)
   int path_len     = 0;
   const char *path = nullptr;
 
-  TSDebug(PLUGIN_NAME, "in the read stuff");
+  Dbg(dbg_ctl, "in the read stuff");
   config = get_config(contp);
 
   if (TSHttpTxnClientReqGet(txnp, &reqp, &hdr_loc) != TS_SUCCESS) {
@@ -587,16 +589,16 @@ stats_origin(TSCont contp, TSEvent event, void *edata)
   }
 
   path = TSUrlPathGet(reqp, url_loc, &path_len);
-  TSDebug(PLUGIN_NAME, "Path: %.*s", path_len, path);
+  Dbg(dbg_ctl, "Path: %.*s", path_len, path);
 
   if (!(path_len != 0 && path_len == int(config->stats_path.length()) &&
         !memcmp(path, config->stats_path.c_str(), config->stats_path.length()))) {
-    TSDebug(PLUGIN_NAME, "not this plugins path, saw: %.*s, looking for: %s", path_len, path, config->stats_path.c_str());
+    Dbg(dbg_ctl, "not this plugins path, saw: %.*s, looking for: %s", path_len, path, config->stats_path.c_str());
     goto notforme;
   }
 
   if (auto addr = TSHttpTxnClientAddrGet(txnp); !is_ipmap_allowed(config, addr)) {
-    TSDebug(PLUGIN_NAME, "not right ip");
+    Dbg(dbg_ctl, "not right ip");
     TSHttpTxnStatusSet(txnp, TS_HTTP_STATUS_FORBIDDEN);
     reenable = TS_EVENT_HTTP_ERROR;
     goto notforme;
@@ -605,7 +607,7 @@ stats_origin(TSCont contp, TSEvent event, void *edata)
   TSHttpTxnCntlSet(txnp, TS_HTTP_CNTL_SKIP_REMAPPING, true); // not strictly necessary, but speed is everything these days
 
   /* This is us -- register our intercept */
-  TSDebug(PLUGIN_NAME, "Intercepting request");
+  Dbg(dbg_ctl, "Intercepting request");
 
   my_state = (stats_state *)TSmalloc(sizeof(*my_state));
   memset(my_state, 0, sizeof(*my_state));
@@ -633,15 +635,15 @@ stats_origin(TSCont contp, TSEvent event, void *edata)
     int len         = -1;
     const char *str = TSMimeHdrFieldValueStringGet(reqp, hdr_loc, accept_encoding_field, -1, &len);
     if (len >= TS_HTTP_LEN_DEFLATE && strstr(str, TS_HTTP_VALUE_DEFLATE) != nullptr) {
-      TSDebug(PLUGIN_NAME, "Saw deflate in accept encoding");
+      Dbg(dbg_ctl, "Saw deflate in accept encoding");
       my_state->encoding = init_gzip(my_state, DEFLATE_MODE);
     } else if (len >= TS_HTTP_LEN_GZIP && strstr(str, TS_HTTP_VALUE_GZIP) != nullptr) {
-      TSDebug(PLUGIN_NAME, "Saw gzip in accept encoding");
+      Dbg(dbg_ctl, "Saw gzip in accept encoding");
       my_state->encoding = init_gzip(my_state, GZIP_MODE);
     }
 #if HAVE_BROTLI_ENCODE_H
     else if (len >= TS_HTTP_LEN_BROTLI && strstr(str, TS_HTTP_VALUE_BROTLI) != nullptr) {
-      TSDebug(PLUGIN_NAME, "Saw br in accept encoding");
+      Dbg(dbg_ctl, "Saw br in accept encoding");
       my_state->encoding = init_br(my_state);
     }
 #endif
@@ -649,7 +651,7 @@ stats_origin(TSCont contp, TSEvent event, void *edata)
       my_state->encoding = NONE;
     }
   }
-  TSDebug(PLUGIN_NAME, "Finished AE check");
+  Dbg(dbg_ctl, "Finished AE check");
 
   TSContDataSet(icontp, my_state);
   TSHttpTxnIntercept(icontp, txnp);
@@ -738,7 +740,7 @@ TSPluginInit(int argc, const char *argv[])
   config_cont = TSContCreate(config_handler, TSMutexCreate());
   TSContDataSet(config_cont, (void *)config_holder);
   TSMgmtUpdateRegister(config_cont, PLUGIN_NAME);
-  TSDebug(PLUGIN_NAME, "stats module registered with path %s", config_holder->config->stats_path.c_str());
+  Dbg(dbg_ctl, "stats module registered with path %s", config_holder->config->stats_path.c_str());
 
 done:
   return;
@@ -764,7 +766,7 @@ parseIpMap(config_t *config, swoc::TextView txt)
   if (txt.empty()) {
     config->addrs.fill(DEFAULT_IP6);
     config->addrs.fill(DEFAULT_IP);
-    TSDebug(PLUGIN_NAME, "Empty allow settings, setting all IPs in allow list");
+    Dbg(dbg_ctl, "Empty allow settings, setting all IPs in allow list");
     return;
   }
 
@@ -772,7 +774,7 @@ parseIpMap(config_t *config, swoc::TextView txt)
     auto token{txt.take_prefix_at(',')};
     if (swoc::IPRange r; r.load(token)) {
       config->addrs.fill(r);
-      TSDebug(PLUGIN_NAME, "Added %.*s to allow ip list", int(token.length()), token.data());
+      Dbg(dbg_ctl, "Added %.*s to allow ip list", int(token.length()), token.data());
     }
   }
 }
@@ -787,7 +789,7 @@ new_config(std::fstream &fh)
   std::string cur_line;
 
   if (!fh) {
-    TSDebug(PLUGIN_NAME, "No config file, using defaults");
+    Dbg(dbg_ctl, "No config file, using defaults");
     return config;
   }
 
@@ -806,10 +808,10 @@ new_config(std::fstream &fh)
 
     if ((p = line.find(PATH_TAG)) != std::string::npos) {
       line.remove_prefix(p + PATH_TAG.size()).ltrim('/');
-      TSDebug(PLUGIN_NAME, "parsing path");
+      Dbg(dbg_ctl, "parsing path");
       config->stats_path = line;
     } else if ((p = line.find(RECORD_TAG)) != std::string::npos) {
-      TSDebug(PLUGIN_NAME, "parsing record types");
+      Dbg(dbg_ctl, "parsing record types");
       line.remove_prefix(p).remove_prefix(RECORD_TAG.size());
       config->recordTypes = swoc::svtou(line, nullptr, 16);
     } else if ((p = line.find(ADDR_TAG)) != std::string::npos) {
@@ -820,11 +822,11 @@ new_config(std::fstream &fh)
   }
 
   if (config->addrs.count() == 0) {
-    TSDebug(PLUGIN_NAME, "empty ip map found, setting defaults");
+    Dbg(dbg_ctl, "empty ip map found, setting defaults");
     parseIpMap(config, nullptr);
   }
 
-  TSDebug(PLUGIN_NAME, "config path=%s", config->stats_path.c_str());
+  Dbg(dbg_ctl, "config path=%s", config->stats_path.c_str());
 
   return config;
 }
@@ -832,7 +834,7 @@ new_config(std::fstream &fh)
 static void
 delete_config(config_t *config)
 {
-  TSDebug(PLUGIN_NAME, "Freeing config");
+  Dbg(dbg_ctl, "Freeing config");
   TSfree(config);
 }
 
@@ -861,20 +863,20 @@ load_config_file(config_holder_t *config_holder)
 
   // check date
   if ((config_holder->config_path == nullptr) || (stat(config_holder->config_path, &s) < 0)) {
-    TSDebug(PLUGIN_NAME, "Could not stat %s", config_holder->config_path);
+    Dbg(dbg_ctl, "Could not stat %s", config_holder->config_path);
     config_holder->config_path = nullptr;
     if (config_holder->config) {
       return;
     }
   } else {
-    TSDebug(PLUGIN_NAME, "s.st_mtime=%lu, last_load=%lu", s.st_mtime, config_holder->last_load);
+    Dbg(dbg_ctl, "s.st_mtime=%lu, last_load=%lu", s.st_mtime, config_holder->last_load);
     if (s.st_mtime < config_holder->last_load) {
       return;
     }
   }
 
   if (config_holder->config_path != nullptr) {
-    TSDebug(PLUGIN_NAME, "Opening config file: %s", config_holder->config_path);
+    Dbg(dbg_ctl, "Opening config file: %s", config_holder->config_path);
     fh.open(config_holder->config_path, std::ios::in);
   }
 
@@ -895,7 +897,7 @@ load_config_file(config_holder_t *config_holder)
     config_t **confp         = &(config_holder->config);
     oldconfig                = __sync_lock_test_and_set(confp, newconfig);
     if (oldconfig) {
-      TSDebug(PLUGIN_NAME, "scheduling free: %p (%p)", oldconfig, newconfig);
+      Dbg(dbg_ctl, "scheduling free: %p (%p)", oldconfig, newconfig);
       free_cont = TSContCreate(free_handler, TSMutexCreate());
       TSContDataSet(free_cont, (void *)oldconfig);
       TSContScheduleOnPool(free_cont, FREE_TMOUT, TS_THREAD_POOL_TASK);
diff --git a/plugins/tcpinfo/tcpinfo.cc b/plugins/tcpinfo/tcpinfo.cc
index d7e655de1a0..7943cac659a 100644
--- a/plugins/tcpinfo/tcpinfo.cc
+++ b/plugins/tcpinfo/tcpinfo.cc
@@ -68,6 +68,8 @@ static const char *tcpi_headers[] = {"timestamp event client server rtt",
 #endif
 };
 
+static DbgCtl dbg_ctl{"tcpinfo"};
+
 struct Config {
   int sample             = 1000;
   unsigned int log_level = 1;
@@ -117,16 +119,16 @@ log_tcp_info(Config *config, const char *event_name, TSHttpSsn ssnp)
   TSReleaseAssert(config->log != nullptr);
 
   if (ssnp != nullptr && (TSHttpSsnClientFdGet(ssnp, &fd) != TS_SUCCESS || fd <= 0)) {
-    TSDebug("tcpinfo", "error getting the client socket fd from ssn");
+    Dbg(dbg_ctl, "error getting the client socket fd from ssn");
     return;
   }
   if (ssnp == nullptr) {
-    TSDebug("tcpinfo", "ssn is not specified");
+    Dbg(dbg_ctl, "ssn is not specified");
     return;
   }
 
   if (getsockopt(fd, IPPROTO_TCP, TCP_INFO, &info, &tcp_info_len) != 0) {
-    TSDebug("tcpinfo", "getsockopt(%d, TCP_INFO) failed: %s", fd, strerror(errno));
+    Dbg(dbg_ctl, "getsockopt(%d, TCP_INFO) failed: %s", fd, strerror(errno));
     return;
   }
 
@@ -218,7 +220,7 @@ tcp_info_hook(TSCont contp, TSEvent event, void *edata)
     return 0;
   }
 
-  TSDebug("tcpinfo", "logging hook called for %s (%s) with log object %p", TSHttpEventNameLookup(event), event_name, config->log);
+  Dbg(dbg_ctl, "logging hook called for %s (%s) with log object %p", TSHttpEventNameLookup(event), event_name, config->log);
 
   if (config->log == nullptr) {
     goto done;
@@ -233,11 +235,11 @@ tcp_info_hook(TSCont contp, TSEvent event, void *edata)
   if (config->sample < 1000) {
     // coverity[dont_call]
     random = rand() % 1000;
-    TSDebug("tcpinfo", "random: %d, config->sample: %d", random, config->sample);
+    Dbg(dbg_ctl, "random: %d, config->sample: %d", random, config->sample);
   }
 
   if (random < config->sample) {
-    TSDebug("tcpinfo", "sampling TCP metrics for %s event", event_name);
+    Dbg(dbg_ctl, "sampling TCP metrics for %s event", event_name);
     log_tcp_info(config, event_name, ssnp);
   }
 
@@ -424,11 +426,11 @@ TSPluginInit(int argc, const char *argv[])
   TSError("[tcpinfo] TCP metrics are not supported on this platform");
 #endif
 
-  TSDebug("tcpinfo", "sample: %d", config->sample);
-  TSDebug("tcpinfo", "log filename: %s", filename);
-  TSDebug("tcpinfo", "log_level: %u", config->log_level);
-  TSDebug("tcpinfo", "rolling_enabled: %d", rolling_enabled);
-  TSDebug("tcpinfo", "hook mask: 0x%x", hooks);
+  Dbg(dbg_ctl, "sample: %d", config->sample);
+  Dbg(dbg_ctl, "log filename: %s", filename);
+  Dbg(dbg_ctl, "log_level: %u", config->log_level);
+  Dbg(dbg_ctl, "rolling_enabled: %d", rolling_enabled);
+  Dbg(dbg_ctl, "hook mask: 0x%x", hooks);
 
   if (TSTextLogObjectCreate(filename, TS_LOG_MODE_ADD_TIMESTAMP, &config->log) != TS_SUCCESS) {
     TSError("[tcpinfo] failed to create log file '%s'", filename);
@@ -437,7 +439,7 @@ TSPluginInit(int argc, const char *argv[])
   if (rolling_enabled == -1) {
     // The user either did not provide a value or the value they provided was
     // invalid.
-    TSDebug("tcpinfo", "Using system default value of proxy.config.log.rolling_enabled ");
+    Dbg(dbg_ctl, "Using system default value of proxy.config.log.rolling_enabled ");
   } else {
     if (TSTextLogObjectRollingEnabledSet(config->log, rolling_enabled) != TS_SUCCESS) {
       TSError("[tcpinfo] failed to enable log file rolling to: '%d'", rolling_enabled);
@@ -455,21 +457,21 @@ TSPluginInit(int argc, const char *argv[])
 
   if (hooks & TCPI_HOOK_SSN_START) {
     TSHttpHookAdd(TS_HTTP_SSN_START_HOOK, cont);
-    TSDebug("tcpinfo", "added hook to the start of the TCP connection");
+    Dbg(dbg_ctl, "added hook to the start of the TCP connection");
   }
 
   if (hooks & TCPI_HOOK_TXN_START) {
     TSHttpHookAdd(TS_HTTP_TXN_START_HOOK, cont);
-    TSDebug("tcpinfo", "added hook to the start of the transaction");
+    Dbg(dbg_ctl, "added hook to the start of the transaction");
   }
 
   if (hooks & TCPI_HOOK_SEND_RESPONSE) {
     TSHttpHookAdd(TS_HTTP_SEND_RESPONSE_HDR_HOOK, cont);
-    TSDebug("tcpinfo", "added hook to the sending of the headers");
+    Dbg(dbg_ctl, "added hook to the sending of the headers");
   }
 
   if (hooks & TCPI_HOOK_TXN_CLOSE) {
     TSHttpHookAdd(TS_HTTP_TXN_CLOSE_HOOK, cont);
-    TSDebug("tcpinfo", "added hook to the close of the transaction");
+    Dbg(dbg_ctl, "added hook to the close of the transaction");
   }
 }
diff --git a/plugins/traffic_dump/global_variables.h b/plugins/traffic_dump/global_variables.h
index 7d465088ca7..6a1cf1e3288 100644
--- a/plugins/traffic_dump/global_variables.h
+++ b/plugins/traffic_dump/global_variables.h
@@ -23,8 +23,11 @@
 
 #pragma once
 
+#include <ts/ts.h>
+
 namespace traffic_dump
 {
 constexpr char debug_tag[] = "traffic_dump";
 
+extern DbgCtl dbg_ctl;
 } // namespace traffic_dump
diff --git a/plugins/traffic_dump/session_data.cc b/plugins/traffic_dump/session_data.cc
index 17c793cccfd..335424cc4e7 100644
--- a/plugins/traffic_dump/session_data.cc
+++ b/plugins/traffic_dump/session_data.cc
@@ -204,13 +204,13 @@ SessionData::init(std::string_view log_directory, bool enforce_disk_limit, int64
   if (!ip_filter.empty()) {
     client_ip_filter.emplace();
     if (client_ip_filter->load(ip_filter)) {
-      TSDebug(debug_tag, "Problems parsing IP filter address argument: %.*s", static_cast<int>(ip_filter.size()), ip_filter.data());
+      Dbg(dbg_ctl, "Problems parsing IP filter address argument: %.*s", static_cast<int>(ip_filter.size()), ip_filter.data());
       TSError("[%s] Problems parsing IP filter address argument: %.*s", debug_tag, static_cast<int>(ip_filter.size()),
               ip_filter.data());
       client_ip_filter = std::nullopt;
       return false;
     } else {
-      TSDebug(debug_tag, "Filtering to only dump connections with ip: %.*s", static_cast<int>(ip_filter.size()), ip_filter.data());
+      Dbg(dbg_ctl, "Filtering to only dump connections with ip: %.*s", static_cast<int>(ip_filter.size()), ip_filter.data());
     }
   }
 
@@ -223,12 +223,12 @@ SessionData::init(std::string_view log_directory, bool enforce_disk_limit, int64
   TSHttpHookAdd(TS_HTTP_SSN_START_HOOK, ssncont);
   TSHttpHookAdd(TS_HTTP_SSN_CLOSE_HOOK, ssncont);
 
-  TSDebug(debug_tag, "Initialized with log directory: %s", SessionData::log_directory.c_str());
+  Dbg(dbg_ctl, "Initialized with log directory: %s", SessionData::log_directory.c_str());
   if (!SessionData::enforce_disk_limit) {
-    TSDebug(debug_tag, "Initialized with sample pool size of %" PRId64 " bytes and unlimited disk utilization", sample_size);
+    Dbg(dbg_ctl, "Initialized with sample pool size of %" PRId64 " bytes and unlimited disk utilization", sample_size);
   } else {
-    TSDebug(debug_tag, "Initialized with sample pool size of %" PRId64 " bytes and disk limit of %" PRId64 " bytes", sample_size,
-            max_disk_usage);
+    Dbg(dbg_ctl, "Initialized with sample pool size of %" PRId64 " bytes and disk limit of %" PRId64 " bytes", sample_size,
+        max_disk_usage);
   }
   return true;
 }
@@ -241,7 +241,7 @@ SessionData::init(std::string_view log_directory, bool enforce_disk_limit, int64
     return false;
   }
   SessionData::sni_filter = sni_filter;
-  TSDebug(debug_tag, "Filtering to only dump connections with SNI: %s", SessionData::sni_filter.c_str());
+  Dbg(dbg_ctl, "Filtering to only dump connections with SNI: %s", SessionData::sni_filter.c_str());
   return true;
 }
 
@@ -390,11 +390,11 @@ SessionData::is_filtered_out(const sockaddr *session_client_ip)
     return false;
   }
   if (session_client_ip == nullptr) {
-    TSDebug(debug_tag, "Found no client IP address for session. Abort.");
+    Dbg(dbg_ctl, "Found no client IP address for session. Abort.");
     return true;
   }
   if (session_client_ip->sa_family != AF_INET && session_client_ip->sa_family != AF_INET6) {
-    TSDebug(debug_tag, "IP family is not v4 nor v6. Abort.");
+    Dbg(dbg_ctl, "IP family is not v4 nor v6. Abort.");
     return true;
   }
 
@@ -411,7 +411,7 @@ SessionData::session_aio_handler(TSCont contp, TSEvent event, void *edata)
     TSAIOCallback cb     = static_cast<TSAIOCallback>(edata);
     SessionData *ssnData = static_cast<SessionData *>(TSContDataGet(contp));
     if (!ssnData) {
-      TSDebug(debug_tag, "session_aio_handler(): No valid ssnData. Abort.");
+      Dbg(dbg_ctl, "session_aio_handler(): No valid ssnData. Abort.");
       return TS_ERROR;
     }
     char *buf = TSAIOBufGet(cb);
@@ -428,7 +428,7 @@ SessionData::session_aio_handler(TSCont contp, TSEvent event, void *edata)
         swoc::file::file_status st = swoc::file::status(ssnData->log_name, ec);
         if (!ec) {
           disk_usage += swoc::file::file_size(st);
-          TSDebug(debug_tag, "Finish a session with log file of %" PRIuMAX " bytes", swoc::file::file_size(st));
+          Dbg(dbg_ctl, "Finish a session with log file of %" PRIuMAX " bytes", swoc::file::file_size(st));
         }
         delete ssnData;
         return TS_SUCCESS;
@@ -437,7 +437,7 @@ SessionData::session_aio_handler(TSCont contp, TSEvent event, void *edata)
     return TS_SUCCESS;
   }
   default:
-    TSDebug(debug_tag, "session_aio_handler(): unhandled events %d", event);
+    Dbg(dbg_ctl, "session_aio_handler(): unhandled events %d", event);
     return TS_ERROR;
   }
   return TS_SUCCESS;
@@ -463,32 +463,32 @@ SessionData::global_session_handler(TSCont contp, TSEvent event, void *edata)
       TSSslConnection ssl_conn = TSVConnSslConnectionGet(ssn_vc);
       SSL *ssl_obj             = reinterpret_cast<SSL *>(ssl_conn);
       if (ssl_obj == nullptr) {
-        TSDebug(debug_tag, "global_session_handler(): Ignore non-HTTPS session %" PRId64 "...", id);
+        Dbg(dbg_ctl, "global_session_handler(): Ignore non-HTTPS session %" PRId64 "...", id);
         break;
       }
       char const *sni_ptr = SSL_get_servername(ssl_obj, TLSEXT_NAMETYPE_host_name);
       if (sni_ptr == nullptr) {
-        TSDebug(debug_tag, "global_session_handler(): Ignore HTTPS session with non-existent SNI.");
+        Dbg(dbg_ctl, "global_session_handler(): Ignore HTTPS session with non-existent SNI.");
         break;
       } else {
         const std::string_view sni{sni_ptr};
         if (sni != sni_filter) {
-          TSDebug(debug_tag, "global_session_handler(): Ignore HTTPS session with non-filtered SNI: %s", sni_ptr);
+          Dbg(dbg_ctl, "global_session_handler(): Ignore HTTPS session with non-filtered SNI: %s", sni_ptr);
           break;
         }
       }
     }
     const auto this_session_count = session_counter++;
     if (this_session_count % sample_pool_size != 0) {
-      TSDebug(debug_tag, "Ignore session %" PRId64 " per the random sampling mechanism", id);
+      Dbg(dbg_ctl, "Ignore session %" PRId64 " per the random sampling mechanism", id);
       break;
     } else if (enforce_disk_limit && disk_usage >= max_disk_usage) {
-      TSDebug(debug_tag, "Ignore session %" PRId64 " due to disk usage %" PRId64 " bytes", id, disk_usage.load());
+      Dbg(dbg_ctl, "Ignore session %" PRId64 " due to disk usage %" PRId64 " bytes", id, disk_usage.load());
       break;
     } else {
       const sockaddr *client_ip = TSHttpSsnClientAddrGet(ssnp);
       if (SessionData::is_filtered_out(client_ip)) {
-        TSDebug(debug_tag, "Ignore session %" PRId64 " per the client's IP filter", id);
+        Dbg(dbg_ctl, "Ignore session %" PRId64 " per the client's IP filter", id);
         break;
       }
     }
@@ -521,7 +521,7 @@ SessionData::global_session_handler(TSCont contp, TSEvent event, void *edata)
     } else if (AF_INET6 == client_ip->sa_family) {
       inet_ntop(AF_INET6, &(reinterpret_cast<sockaddr_in6 const *>(client_ip)->sin6_addr), client_str, INET6_ADDRSTRLEN);
     } else {
-      TSDebug(debug_tag, "global_session_handler(): Unknown address family.");
+      Dbg(dbg_ctl, "global_session_handler(): Unknown address family.");
       snprintf(client_str, INET6_ADDRSTRLEN, "unknown");
     }
 
@@ -535,14 +535,14 @@ SessionData::global_session_handler(TSCont contp, TSEvent event, void *edata)
       std::error_code ec;
       swoc::file::status(log_p, ec);
       if (ec && mkdir(log_p.c_str(), 0755) == -1) {
-        TSDebug(debug_tag, "global_session_handler(): Failed to create dir %s", log_p.c_str());
+        Dbg(dbg_ctl, "global_session_handler(): Failed to create dir %s", log_p.c_str());
         TSError("[%s] Failed to create dir %s", debug_tag, log_p.c_str());
       }
 
       // Try to open log files for AIO
       ssnData->log_fd = open(log_f.c_str(), O_RDWR | O_CREAT, S_IRWXU);
       if (ssnData->log_fd < 0) {
-        TSDebug(debug_tag, "global_session_handler(): Failed to open log files %s. Abort.", log_f.c_str());
+        Dbg(dbg_ctl, "global_session_handler(): Failed to open log files %s. Abort.", log_f.c_str());
         TSHttpSsnReenable(ssnp, TS_EVENT_HTTP_CONTINUE);
         return TS_EVENT_HTTP_CONTINUE;
       }
@@ -558,12 +558,12 @@ SessionData::global_session_handler(TSCont contp, TSEvent event, void *edata)
   case TS_EVENT_HTTP_SSN_CLOSE: {
     // Write session and close the log file.
     int64_t id = TSHttpSsnIdGet(ssnp);
-    TSDebug(debug_tag, "global_session_handler(): Closing session %" PRId64 "...", id);
+    Dbg(dbg_ctl, "global_session_handler(): Closing session %" PRId64 "...", id);
     // Retrieve SessionData
     SessionData *ssnData = static_cast<SessionData *>(TSUserArgGet(ssnp, session_arg_index));
     // If no valid ssnData, continue transaction as if nothing happened
     if (!ssnData) {
-      TSDebug(debug_tag, "global_session_handler(): [TS_EVENT_HTTP_SSN_CLOSE] No ssnData found. Abort.");
+      Dbg(dbg_ctl, "global_session_handler(): [TS_EVENT_HTTP_SSN_CLOSE] No ssnData found. Abort.");
       TSHttpSsnReenable(ssnp, TS_EVENT_HTTP_CONTINUE);
       return TS_SUCCESS;
     }
diff --git a/plugins/traffic_dump/traffic_dump.cc b/plugins/traffic_dump/traffic_dump.cc
index 3111f3e36c1..ca9f8e19844 100644
--- a/plugins/traffic_dump/traffic_dump.cc
+++ b/plugins/traffic_dump/traffic_dump.cc
@@ -31,6 +31,8 @@
 
 namespace traffic_dump
 {
+DbgCtl dbg_ctl{debug_tag};
+
 /// Handle LIFECYCLE_MSG from traffic_ctl.
 static int
 global_message_handler(TSCont contp, TSEvent event, void *edata)
@@ -45,24 +47,24 @@ global_message_handler(TSCont contp, TSEvent event, void *edata)
       tag.remove_prefix(PLUGIN_PREFIX.size());
       if (tag == "sample" && msg->data_size) {
         const auto new_sample_size = static_cast<int64_t>(strtol(static_cast<char const *>(msg->data), nullptr, 0));
-        TSDebug(debug_tag, "TS_EVENT_LIFECYCLE_MSG: Received Msg to change sample size to %" PRId64 "bytes", new_sample_size);
+        Dbg(dbg_ctl, "TS_EVENT_LIFECYCLE_MSG: Received Msg to change sample size to %" PRId64 "bytes", new_sample_size);
         SessionData::set_sample_pool_size(new_sample_size);
       } else if (tag == "reset") {
-        TSDebug(debug_tag, "TS_EVENT_LIFECYCLE_MSG: Received Msg to reset disk usage counter");
+        Dbg(dbg_ctl, "TS_EVENT_LIFECYCLE_MSG: Received Msg to reset disk usage counter");
         SessionData::reset_disk_usage();
       } else if (tag == "unlimit") {
-        TSDebug(debug_tag, "TS_EVENT_LIFECYCLE_MSG: Received Msg to disable disk usage limit enforcement");
+        Dbg(dbg_ctl, "TS_EVENT_LIFECYCLE_MSG: Received Msg to disable disk usage limit enforcement");
         SessionData::disable_disk_limit_enforcement();
       } else if (tag == "limit" && msg->data_size) {
         const auto new_max_disk_usage = static_cast<int64_t>(strtol(static_cast<char const *>(msg->data), nullptr, 0));
-        TSDebug(debug_tag, "TS_EVENT_LIFECYCLE_MSG: Received Msg to change max disk usage to %" PRId64 "bytes", new_max_disk_usage);
+        Dbg(dbg_ctl, "TS_EVENT_LIFECYCLE_MSG: Received Msg to change max disk usage to %" PRId64 "bytes", new_max_disk_usage);
         SessionData::set_max_disk_usage(new_max_disk_usage);
       }
     }
     return TS_SUCCESS;
   }
   default:
-    TSDebug(debug_tag, "session_aio_handler(): unhandled events %d", event);
+    Dbg(dbg_ctl, "session_aio_handler(): unhandled events %d", event);
     return TS_ERROR;
   }
 }
@@ -72,7 +74,7 @@ global_message_handler(TSCont contp, TSEvent event, void *edata)
 void
 TSPluginInit(int argc, char const *argv[])
 {
-  TSDebug(traffic_dump::debug_tag, "initializing plugin");
+  Dbg(traffic_dump::dbg_ctl, "initializing plugin");
   TSPluginRegistrationInfo info;
 
   info.plugin_name   = "traffic_dump";
@@ -163,7 +165,7 @@ TSPluginInit(int argc, char const *argv[])
       break;
 
     default:
-      TSDebug(traffic_dump::debug_tag, "Unexpected options.");
+      Dbg(traffic_dump::dbg_ctl, "Unexpected options.");
       TSError("[%s] Unexpected options error.", traffic_dump::debug_tag);
       return;
     }
diff --git a/plugins/traffic_dump/transaction_data.cc b/plugins/traffic_dump/transaction_data.cc
index 04ff4b7efb7..a0c844b4b99 100644
--- a/plugins/traffic_dump/transaction_data.cc
+++ b/plugins/traffic_dump/transaction_data.cc
@@ -65,7 +65,7 @@ TransactionData::response_buffer_handler(TSCont contp, TSEvent event, void *edat
 
   switch (event) {
   case TS_EVENT_ERROR:
-    TSDebug(debug_tag, "Received an error event reading body data");
+    Dbg(dbg_ctl, "Received an error event reading body data");
     TSContCall(TSVIOContGet(input_vio), TS_EVENT_ERROR, input_vio);
     break;
   case TS_EVENT_VCONN_READ_COMPLETE:
@@ -84,7 +84,7 @@ TransactionData::response_buffer_handler(TSCont contp, TSEvent event, void *edat
 
         TSIOBufferReaderConsume(reader, read_avail);
         TSVIONDoneSet(input_vio, TSVIONDoneGet(input_vio) + read_avail);
-        TSDebug(debug_tag, "Consumed %" PRId64 " bytes of response body data", read_avail);
+        Dbg(dbg_ctl, "Consumed %" PRId64 " bytes of response body data", read_avail);
       }
       if (TSVIONTodoGet(input_vio) > 0) {
         // signal that we can accept more data.
@@ -97,7 +97,7 @@ TransactionData::response_buffer_handler(TSCont contp, TSEvent event, void *edat
     }
     break;
   default:
-    TSDebug(debug_tag, "unhandled event %d", event);
+    Dbg(dbg_ctl, "unhandled event %d", event);
     break;
   }
 
@@ -212,12 +212,12 @@ TransactionData::write_message_node_no_content(TSMBuffer &buffer, TSMLoc &hdr_lo
     TSAssert(TS_SUCCESS == TSHttpHdrUrlGet(buffer, hdr_loc, &url_loc));
     // 2. "scheme":
     cp = TSUrlSchemeGet(buffer, url_loc, &len);
-    TSDebug(debug_tag, "write_message_node(): found scheme %.*s ", len, cp);
+    Dbg(dbg_ctl, "write_message_node(): found scheme %.*s ", len, cp);
     result += traffic_dump::json_entry("scheme", cp, len);
 
     // 3. "method":(string)
     cp = TSHttpHdrMethodGet(buffer, hdr_loc, &len);
-    TSDebug(debug_tag, "write_message_node(): found method %.*s ", len, cp);
+    Dbg(dbg_ctl, "write_message_node(): found method %.*s ", len, cp);
     result += "," + traffic_dump::json_entry("method", cp, len);
 
     // 4. "url"
@@ -236,7 +236,7 @@ TransactionData::write_message_node_no_content(TSMBuffer &buffer, TSMLoc &hdr_lo
       url_string = remove_scheme_prefix(url_string);
     }
 
-    TSDebug(debug_tag, "write_message_node(): found host target %.*s", static_cast<int>(url_string.size()), url_string.data());
+    Dbg(dbg_ctl, "write_message_node(): found host target %.*s", static_cast<int>(url_string.size()), url_string.data());
     result += ',' + traffic_dump::json_entry("url", url_string);
     TSfree(url);
     TSHandleMLocRelease(buffer, hdr_loc, url_loc);
@@ -305,10 +305,10 @@ bool
 TransactionData::init_helper(bool dump_body)
 {
   _dump_body = dump_body;
-  TSDebug(debug_tag, "Dumping body bytes: %s", _dump_body ? "true" : "false");
+  Dbg(dbg_ctl, "Dumping body bytes: %s", _dump_body ? "true" : "false");
   initialize_default_sensitive_field();
   const std::string sensitive_fields_string = get_sensitive_field_description();
-  TSDebug(debug_tag, "Sensitive fields for which generic values will be dumped: %s", sensitive_fields_string.c_str());
+  Dbg(dbg_ctl, "Sensitive fields for which generic values will be dumped: %s", sensitive_fields_string.c_str());
 
   if (TS_SUCCESS !=
       TSUserArgIndexReserve(TS_USER_ARGS_TXN, traffic_dump::debug_tag, "Track transaction related data", &transaction_arg_index)) {
@@ -407,7 +407,7 @@ TransactionData::global_transaction_handler(TSCont contp, TSEvent event, void *e
   // If no valid ssnData, continue transaction as if nothing happened. This transaction
   // must be filtered out by our filter criteria.
   if (!ssnData) {
-    TSDebug(debug_tag, "session_txn_handler(): No ssnData found. Abort.");
+    Dbg(dbg_ctl, "session_txn_handler(): No ssnData found. Abort.");
     TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
     return TS_SUCCESS;
   }
@@ -458,7 +458,7 @@ TransactionData::global_transaction_handler(TSCont contp, TSEvent event, void *e
     TSMBuffer buffer;
     TSMLoc hdr_loc;
     if (TS_SUCCESS == TSHttpTxnClientReqGet(txnp, &buffer, &hdr_loc)) {
-      TSDebug(debug_tag, "Found client request");
+      Dbg(dbg_ctl, "Found client request");
       // We don't have an accurate view of the body size until TXN_CLOSE so we hold
       // off on writing the content:size node until then.
       txnData->write_client_request_node_no_content(buffer, hdr_loc);
@@ -500,19 +500,19 @@ TransactionData::global_transaction_handler(TSCont contp, TSEvent event, void *e
       buffer = nullptr;
     }
     if (TS_SUCCESS == TSHttpTxnServerReqGet(txnp, &buffer, &hdr_loc)) {
-      TSDebug(debug_tag, "Found proxy request");
+      Dbg(dbg_ctl, "Found proxy request");
       txnData->write_proxy_request_node(buffer, hdr_loc);
       TSHandleMLocRelease(buffer, TS_NULL_MLOC, hdr_loc);
       buffer = nullptr;
     }
     if (TS_SUCCESS == TSHttpTxnServerRespGet(txnp, &buffer, &hdr_loc)) {
-      TSDebug(debug_tag, "Found server response");
+      Dbg(dbg_ctl, "Found server response");
       txnData->write_server_response_node(buffer, hdr_loc);
       TSHandleMLocRelease(buffer, TS_NULL_MLOC, hdr_loc);
       buffer = nullptr;
     }
     if (TS_SUCCESS == TSHttpTxnClientRespGet(txnp, &buffer, &hdr_loc)) {
-      TSDebug(debug_tag, "Found proxy response");
+      Dbg(dbg_ctl, "Found proxy response");
       txnData->write_proxy_response_node(buffer, hdr_loc);
       TSHandleMLocRelease(buffer, TS_NULL_MLOC, hdr_loc);
       buffer = nullptr;
@@ -524,7 +524,7 @@ TransactionData::global_transaction_handler(TSCont contp, TSEvent event, void *e
     break;
   }
   default:
-    TSDebug(debug_tag, "session_txn_handler(): Unhandled events %d", event);
+    Dbg(dbg_ctl, "session_txn_handler(): Unhandled events %d", event);
     TSHttpTxnReenable(txnp, TS_EVENT_HTTP_ERROR);
     return TS_ERROR;
   }
diff --git a/plugins/webp_transform/ImageTransform.cc b/plugins/webp_transform/ImageTransform.cc
index a8ef0bd6ed3..3cad3d4185b 100644
--- a/plugins/webp_transform/ImageTransform.cc
+++ b/plugins/webp_transform/ImageTransform.cc
@@ -91,7 +91,7 @@ class ImageTransform : public TransformationPlugin
 
     transaction.getServerResponse().getHeaders()["Vary"] = "Accept"; // to have a separate cache entry
 
-    TS_DEBUG(TAG, "url %s", transaction.getServerRequest().getUrl().getUrlString().c_str());
+    Dbg(webp_dbg_ctl, "url %s", transaction.getServerRequest().getUrl().getUrlString().c_str());
     transaction.resume();
   }
 
diff --git a/plugins/xdebug/xdebug.cc b/plugins/xdebug/xdebug.cc
index 321961669e4..e6229a2c6a2 100644
--- a/plugins/xdebug/xdebug.cc
+++ b/plugins/xdebug/xdebug.cc
@@ -40,6 +40,8 @@
 
 namespace
 {
+DbgCtl dbg_ctl{"xdebug"};
+
 struct BodyBuilder {
   atscppapi::TSContUniqPtr transform_connp;
   atscppapi::TSIOBufferUniqPtr output_buffer;
@@ -182,7 +184,7 @@ InjectCacheKeyHeader(TSHttpTxn txn, TSMBuffer buffer, TSMLoc hdr)
     int len;
   } strval = {nullptr, 0};
 
-  TSDebug("xdebug", "attempting to inject X-Cache-Key header");
+  Dbg(dbg_ctl, "attempting to inject X-Cache-Key header");
 
   if (TSUrlCreate(buffer, &url) != TS_SUCCESS) {
     goto done;
@@ -225,7 +227,7 @@ InjectCacheInfoHeader(TSHttpTxn txn, TSMBuffer buffer, TSMLoc hdr)
   TSMgmtInt volume;
   const char *path;
 
-  TSDebug("xdebug", "attempting to inject X-Cache-Info header");
+  Dbg(dbg_ctl, "attempting to inject X-Cache-Info header");
 
   if ((path = TSHttpTxnCacheDiskPathGet(txn, nullptr)) == nullptr) {
     goto done;
@@ -266,7 +268,7 @@ InjectCacheHeader(TSHttpTxn txn, TSMBuffer buffer, TSMLoc hdr)
     "skipped"    // TS_CACHE_LOOKUP_SKIPPED
   };
 
-  TSDebug("xdebug", "attempting to inject X-Cache header");
+  Dbg(dbg_ctl, "attempting to inject X-Cache header");
 
   // Create a new response header field.
   dst = FindOrMakeHdrField(buffer, hdr, "X-Cache", lengthof("X-Cache"));
@@ -426,7 +428,7 @@ InjectEffectiveURLHeader(TSHttpTxn txn, TSMBuffer buffer, TSMLoc hdr)
     int len;
   } strval = {nullptr, 0};
 
-  TSDebug("xdebug", "attempting to inject X-Effective-URL header");
+  Dbg(dbg_ctl, "attempting to inject X-Effective-URL header");
 
   strval.ptr = TSHttpTxnEffectiveUrlStringGet(txn, &strval.len);
 
@@ -494,7 +496,7 @@ InjectParentSelectionKeyHeader(TSHttpTxn txn, TSMBuffer buffer, TSMLoc hdr)
     int len;
   } strval = {nullptr, 0};
 
-  TSDebug("xdebug", "attempting to inject X-ParentSelection-Key header");
+  Dbg(dbg_ctl, "attempting to inject X-ParentSelection-Key header");
 
   if (TSUrlCreate(buffer, &url) != TS_SUCCESS) {
     goto done;
@@ -589,7 +591,7 @@ XInjectResponseHeaders(TSCont /* contp */, TSEvent event, void *edata)
   if (xheaders & XHEADER_X_PROBE_HEADERS) {
     InjectOriginalContentTypeHeader(txn, buffer, hdr);
     BodyBuilder *data = AuxDataMgr::data(txn).body_builder.get();
-    TSDebug("xdebug_transform", "XInjectResponseHeaders(): client resp header ready");
+    Dbg(dbg_ctl_xform, "XInjectResponseHeaders(): client resp header ready");
     if (data == nullptr) {
       TSHttpTxnReenable(txn, TS_EVENT_HTTP_ERROR);
       return TS_ERROR;
@@ -676,7 +678,7 @@ XScanRequestHeaders(TSCont /* contp */, TSEvent event, void *edata)
     return TS_EVENT_NONE;
   }
 
-  TSDebug("xdebug", "scanning for %s header values", xDebugHeader.str);
+  Dbg(dbg_ctl, "scanning for %s header values", xDebugHeader.str);
 
   // Walk the X-Debug header values and determine what to inject into the response.
   field = TSMimeHdrFieldFind(buffer, hdr, xDebugHeader.str, xDebugHeader.len);
@@ -691,7 +693,7 @@ XScanRequestHeaders(TSCont /* contp */, TSEvent event, void *edata)
       if (value == nullptr || vsize == 0) {
         continue;
       }
-      TSDebug("xdebug", "Validating value: '%.*s'", vsize, value);
+      Dbg(dbg_ctl, "Validating value: '%.*s'", vsize, value);
 
 #define header_field_eq(name, vptr, vlen) (((int)name.size() == vlen) && (strncasecmp(name.data(), vptr, vlen) == 0))
 
@@ -750,7 +752,7 @@ XScanRequestHeaders(TSCont /* contp */, TSEvent event, void *edata)
       } else if (header_field_eq(HEADER_NAME_X_EFFECTIVE_URL, value, vsize)) {
         xheaders |= XHEADER_X_EFFECTIVE_URL & allowedHeaders;
       } else {
-        TSDebug("xdebug", "ignoring unrecognized debug tag '%.*s'", vsize, value);
+        Dbg(dbg_ctl, "ignoring unrecognized debug tag '%.*s'", vsize, value);
       }
     }
 
@@ -767,8 +769,7 @@ XScanRequestHeaders(TSCont /* contp */, TSEvent event, void *edata)
   }
 
   if (xheaders) {
-    TSDebug("xdebug", "adding response hook for header mask %p and forward count %" PRIiMAX, reinterpret_cast<void *>(xheaders),
-            fwdCnt);
+    Dbg(dbg_ctl, "adding response hook for header mask %p and forward count %" PRIiMAX, reinterpret_cast<void *>(xheaders), fwdCnt);
     TSHttpTxnHookAdd(txn, TS_HTTP_SEND_RESPONSE_HDR_HOOK, XInjectHeadersCont);
     AuxDataMgr::data(txn).xheaders = xheaders;
 
@@ -827,10 +828,10 @@ updateAllowedHeaders(const char *optarg)
     const auto ite = std::find_if(std::begin(header_flags), std::end(header_flags),
                                   [token](const struct XHeader &x) { return x.name.compare(token) == 0; });
     if (ite != std::end(header_flags)) {
-      TSDebug("xdebug", "Enabled allowed header name: %s", token);
+      Dbg(dbg_ctl, "Enabled allowed header name: %s", token);
       allowedHeaders |= ite->flag;
     } else {
-      TSDebug("xdebug", "Unknown header name: %s", token);
+      Dbg(dbg_ctl, "Unknown header name: %s", token);
       TSError("[xdebug] Unknown header name: %s", token);
     }
   }
@@ -840,7 +841,7 @@ updateAllowedHeaders(const char *optarg)
 void
 TSPluginInit(int argc, const char *argv[])
 {
-  TSDebug("xdebug", "initializing plugin");
+  Dbg(dbg_ctl, "initializing plugin");
 
   static const struct option longopt[] = {
     {const_cast<char *>("header"), required_argument, nullptr, 'h' },
@@ -863,7 +864,7 @@ TSPluginInit(int argc, const char *argv[])
 
     switch (opt) {
     case 'h':
-      TSDebug("xdebug", "Setting header: %s", optarg);
+      Dbg(dbg_ctl, "Setting header: %s", optarg);
       xDebugHeader.str = TSstrdup(optarg);
       break;
     case 'e':
diff --git a/plugins/xdebug/xdebug_headers.cc b/plugins/xdebug/xdebug_headers.cc
index 003658f76a5..e689e458ffa 100644
--- a/plugins/xdebug/xdebug_headers.cc
+++ b/plugins/xdebug/xdebug_headers.cc
@@ -28,6 +28,11 @@
 
 #define DEBUG_TAG_LOG_HEADERS "xdebug.headers"
 
+namespace
+{
+DbgCtl dbg_ctl_hdrs{DEBUG_TAG_LOG_HEADERS};
+}
+
 class EscapeCharForJson
 {
 public:
@@ -112,7 +117,7 @@ class EscapeCharForJson
 };
 
 ///////////////////////////////////////////////////////////////////////////
-// Dump a header on stderr, useful together with TSDebug().
+// Dump a header on stderr, useful together with Dbg().
 void
 print_headers(TSHttpTxn txn, TSMBuffer bufp, TSMLoc hdr_loc, std::stringstream &ss)
 {
@@ -147,16 +152,16 @@ print_headers(TSHttpTxn txn, TSMBuffer bufp, TSMLoc hdr_loc, std::stringstream &
   TSIOBufferReaderFree(reader);
   TSIOBufferDestroy(output_buffer);
 
-  TSDebug(DEBUG_TAG_LOG_HEADERS, "%.*s", static_cast<int>(ss.tellp()), ss.str().data());
+  Dbg(dbg_ctl_hdrs, "%.*s", static_cast<int>(ss.tellp()), ss.str().data());
 }
 
 void
 log_headers(TSHttpTxn txn, TSMBuffer bufp, TSMLoc hdr_loc, char const *type_msg)
 {
-  if (TSIsDebugTagSet(DEBUG_TAG_LOG_HEADERS)) {
+  if (dbg_ctl_hdrs.on()) {
     std::stringstream output;
     print_headers(txn, bufp, hdr_loc, output);
-    TSDebug(DEBUG_TAG_LOG_HEADERS, "\n=============\n %s headers are... \n %s", type_msg, output.str().c_str());
+    Dbg(dbg_ctl_hdrs, "\n=============\n %s headers are... \n %s", type_msg, output.str().c_str());
   }
 }
 
diff --git a/plugins/xdebug/xdebug_transforms.cc b/plugins/xdebug/xdebug_transforms.cc
index 41a24880136..7398db28135 100644
--- a/plugins/xdebug/xdebug_transforms.cc
+++ b/plugins/xdebug/xdebug_transforms.cc
@@ -28,6 +28,8 @@ static const std::string_view MultipartBoundary{"\r\n--- ATS xDebug Probe Inject
 
 static char Hostname[1024];
 
+static DbgCtl dbg_ctl_xform{"xdebug_transform"};
+
 static std::string
 getPreBody(TSHttpTxn txn)
 {
@@ -54,7 +56,7 @@ static void
 writePostBody(TSHttpTxn txn, BodyBuilder *data)
 {
   if (data->wrote_body && data->hdr_ready && !data->wrote_postbody.test_and_set()) {
-    TSDebug("xdebug_transform", "body_transform(): Writing postbody headers...");
+    Dbg(dbg_ctl_xform, "body_transform(): Writing postbody headers...");
     std::string postbody = getPostBody(txn);
     TSIOBufferWrite(data->output_buffer.get(), postbody.data(), postbody.length());
     data->nbytes += postbody.length();
@@ -89,7 +91,7 @@ body_transform(TSCont contp, TSEvent event, void *edata)
     return 0;
   }
   case TS_EVENT_VCONN_WRITE_READY:
-    TSDebug("xdebug_transform", "body_transform(): Event is TS_EVENT_VCONN_WRITE_READY");
+    Dbg(dbg_ctl_xform, "body_transform(): Event is TS_EVENT_VCONN_WRITE_READY");
   // fall through
   default:
     if (!data->output_buffer.get()) {
@@ -99,7 +101,7 @@ body_transform(TSCont contp, TSEvent event, void *edata)
     }
 
     if (data->wrote_prebody == false) {
-      TSDebug("xdebug_transform", "body_transform(): Writing prebody headers...");
+      Dbg(dbg_ctl_xform, "body_transform(): Writing prebody headers...");
       std::string prebody = getPreBody(txn);
       TSIOBufferWrite(data->output_buffer.get(), prebody.data(), prebody.length()); // write prebody
       data->wrote_prebody  = true;
@@ -116,14 +118,14 @@ body_transform(TSCont contp, TSEvent event, void *edata)
     }
 
     int64_t towrite = TSVIONTodoGet(src_vio);
-    TSDebug("xdebug_transform", "body_transform(): %" PRId64 " bytes of body is expected", towrite);
+    Dbg(dbg_ctl_xform, "body_transform(): %" PRId64 " bytes of body is expected", towrite);
     int64_t avail = TSIOBufferReaderAvail(TSVIOReaderGet(src_vio));
     towrite       = towrite > avail ? avail : towrite;
     if (towrite > 0) {
       TSIOBufferCopy(TSVIOBufferGet(data->output_vio), TSVIOReaderGet(src_vio), towrite, 0);
       TSIOBufferReaderConsume(TSVIOReaderGet(src_vio), towrite);
       TSVIONDoneSet(src_vio, TSVIONDoneGet(src_vio) + towrite);
-      TSDebug("xdebug_transform", "body_transform(): writing %" PRId64 " bytes of body", towrite);
+      Dbg(dbg_ctl_xform, "body_transform(): writing %" PRId64 " bytes of body", towrite);
     }
 
     if (TSVIONTodoGet(src_vio) > 0) {
diff --git a/src/api/InkAPI.cc b/src/api/InkAPI.cc
index 59c4ae95046..0fecc81b337 100644
--- a/src/api/InkAPI.cc
+++ b/src/api/InkAPI.cc
@@ -7448,40 +7448,6 @@ tsapi::c::TSStatFindName(const char *name, int *idp)
   }
 }
 
-/**************************   Tracing API   ****************************/
-// returns 1 or 0 to indicate whether TS is being run with a debug tag.
-int
-tsapi::c::TSIsDebugTagSet(const char *t)
-{
-  return diags()->on_for_TSDebug(t);
-}
-
-void
-tsapi::c::TSDebugSpecific(int debug_flag, const char *tag, const char *format_str, ...)
-{
-  if ((debug_flag && diags()->on_for_TSDebug()) || diags()->on_for_TSDebug(tag)) {
-    va_list ap;
-
-    va_start(ap, format_str);
-    diags()->print_va(tag, DL_Diag, nullptr, format_str, ap);
-    va_end(ap);
-  }
-}
-
-// Plugins would use TSDebug just as the TS internal uses Debug
-// e.g. TSDebug("plugin-cool", "Snoopy is a cool guy even after %d requests.", num_reqs);
-void
-tsapi::c::TSDebug(const char *tag, const char *format_str, ...)
-{
-  if (diags()->on_for_TSDebug() && diags()->tag_activated(tag)) {
-    va_list ap;
-
-    va_start(ap, format_str);
-    diags()->print_va(tag, DL_Diag, nullptr, format_str, ap);
-    va_end(ap);
-  }
-}
-
 /**************************   Logging API   ****************************/
 
 TSReturnCode
diff --git a/src/api/InkAPITest.cc b/src/api/InkAPITest.cc
index e922c132beb..8d8ddb375a6 100644
--- a/src/api/InkAPITest.cc
+++ b/src/api/InkAPITest.cc
@@ -53,8 +53,8 @@
 #include "tscore/TestBox.h"
 
 // This used to be in InkAPITestTool.cc, which we'd just #include here... But that seemed silly.
-#define SDBG_TAG "SockServer"
-#define CDBG_TAG "SockClient"
+DbgCtl dbg_ctl_SockServer{"SockServer"};
+DbgCtl dbg_ctl_SockClient{"SockClient"};
 
 #define IP(a, b, c, d) htonl((a) << 24 | (b) << 16 | (c) << 8 | (d))
 
@@ -525,7 +525,7 @@ synclient_txn_create()
   txn->status     = REQUEST_INPROGRESS;
   txn->magic      = MAGIC_ALIVE;
 
-  TSDebug(CDBG_TAG, "Connecting to proxy 127.0.0.1 on port %d", txn->connect_port);
+  Dbg(dbg_ctl_SockClient, "Connecting to proxy 127.0.0.1 on port %d", txn->connect_port);
   return txn;
 }
 
@@ -563,7 +563,7 @@ synclient_txn_close(ClientTxn *txn)
       txn->resp_buffer = nullptr;
     }
 
-    TSDebug(CDBG_TAG, "Client Txn destroyed");
+    Dbg(dbg_ctl_SockClient, "Client Txn destroyed");
   }
 }
 
@@ -623,7 +623,7 @@ synclient_txn_read_response(TSCont contp)
   }
 
   txn->response[txn->response_len] = '\0';
-  TSDebug(CDBG_TAG, "Response = |%s|, req len = %d", txn->response, txn->response_len);
+  Dbg(dbg_ctl_SockClient, "Response = |%s|, req len = %d", txn->response, txn->response_len);
 
   return 1;
 }
@@ -640,13 +640,13 @@ synclient_txn_read_response_handler(TSCont contp, TSEvent event, void * /* data
   case TS_EVENT_VCONN_READ_READY:
   case TS_EVENT_VCONN_READ_COMPLETE:
     if (event == TS_EVENT_VCONN_READ_READY) {
-      TSDebug(CDBG_TAG, "READ_READY");
+      Dbg(dbg_ctl_SockClient, "READ_READY");
     } else {
-      TSDebug(CDBG_TAG, "READ_COMPLETE");
+      Dbg(dbg_ctl_SockClient, "READ_COMPLETE");
     }
 
     avail = TSIOBufferReaderAvail(txn->resp_reader);
-    TSDebug(CDBG_TAG, "%" PRId64 " bytes available in buffer", avail);
+    Dbg(dbg_ctl_SockClient, "%" PRId64 " bytes available in buffer", avail);
 
     if (avail > 0) {
       synclient_txn_read_response(contp);
@@ -657,7 +657,7 @@ synclient_txn_read_response_handler(TSCont contp, TSEvent event, void * /* data
     break;
 
   case TS_EVENT_VCONN_EOS:
-    TSDebug(CDBG_TAG, "READ_EOS");
+    Dbg(dbg_ctl_SockClient, "READ_EOS");
     // Connection closed. In HTTP/1.0 it means we're done for this request.
     txn->status = REQUEST_SUCCESS;
     synclient_txn_close(static_cast<ClientTxn *>(TSContDataGet(contp)));
@@ -665,7 +665,7 @@ synclient_txn_read_response_handler(TSCont contp, TSEvent event, void * /* data
     return 1;
 
   case TS_EVENT_ERROR:
-    TSDebug(CDBG_TAG, "READ_ERROR");
+    Dbg(dbg_ctl_SockClient, "READ_ERROR");
     txn->status = REQUEST_FAILURE;
     synclient_txn_close(static_cast<ClientTxn *>(TSContDataGet(contp)));
     TSContDestroy(contp);
@@ -703,7 +703,7 @@ synclient_txn_write_request(TSCont contp)
   }
 
   /* Start writing the response */
-  TSDebug(CDBG_TAG, "Writing |%s| (%" PRId64 ") bytes", txn->request, len);
+  Dbg(dbg_ctl_SockClient, "Writing |%s| (%" PRId64 ") bytes", txn->request, len);
   txn->write_vio = TSVConnWrite(txn->vconn, contp, txn->req_reader, len);
 
   return 1;
@@ -717,12 +717,12 @@ synclient_txn_write_request_handler(TSCont contp, TSEvent event, void * /* data
 
   switch (event) {
   case TS_EVENT_VCONN_WRITE_READY:
-    TSDebug(CDBG_TAG, "WRITE_READY");
+    Dbg(dbg_ctl_SockClient, "WRITE_READY");
     TSVIOReenable(txn->write_vio);
     break;
 
   case TS_EVENT_VCONN_WRITE_COMPLETE:
-    TSDebug(CDBG_TAG, "WRITE_COMPLETE");
+    Dbg(dbg_ctl_SockClient, "WRITE_COMPLETE");
     // Weird: synclient should not close the write part of vconn.
     // Otherwise some strangeness...
 
@@ -732,14 +732,14 @@ synclient_txn_write_request_handler(TSCont contp, TSEvent event, void * /* data
     break;
 
   case TS_EVENT_VCONN_EOS:
-    TSDebug(CDBG_TAG, "WRITE_EOS");
+    Dbg(dbg_ctl_SockClient, "WRITE_EOS");
     txn->status = REQUEST_FAILURE;
     synclient_txn_close(static_cast<ClientTxn *>(TSContDataGet(contp)));
     TSContDestroy(contp);
     break;
 
   case TS_EVENT_ERROR:
-    TSDebug(CDBG_TAG, "WRITE_ERROR");
+    Dbg(dbg_ctl_SockClient, "WRITE_ERROR");
     txn->status = REQUEST_FAILURE;
     synclient_txn_close(static_cast<ClientTxn *>(TSContDataGet(contp)));
     TSContDestroy(contp);
@@ -761,7 +761,7 @@ synclient_txn_connect_handler(TSCont contp, TSEvent event, void *data)
   TSAssert(txn->magic == MAGIC_ALIVE);
 
   if (event == TS_EVENT_NET_CONNECT) {
-    TSDebug(CDBG_TAG, "NET_CONNECT");
+    Dbg(dbg_ctl_SockClient, "NET_CONNECT");
 
     txn->req_buffer  = TSIOBufferCreate();
     txn->req_reader  = TSIOBufferReaderAlloc(txn->req_buffer);
@@ -783,7 +783,7 @@ synclient_txn_connect_handler(TSCont contp, TSEvent event, void *data)
 
     return TS_EVENT_IMMEDIATE;
   } else {
-    TSDebug(CDBG_TAG, "NET_CONNECT_FAILED");
+    Dbg(dbg_ctl_SockClient, "NET_CONNECT_FAILED");
     txn->status = REQUEST_FAILURE;
     synclient_txn_close(static_cast<ClientTxn *>(TSContDataGet(contp)));
     TSContDestroy(contp);
@@ -852,9 +852,9 @@ synserver_stop(SocketServer *s)
   if (s->accept_action && !TSActionDone(s->accept_action)) {
     TSActionCancel(s->accept_action);
     s->accept_action = nullptr;
-    TSDebug(SDBG_TAG, "Had to cancel action");
+    Dbg(dbg_ctl_SockServer, "Had to cancel action");
   }
-  TSDebug(SDBG_TAG, "stopped");
+  Dbg(dbg_ctl_SockServer, "stopped");
   return 1;
 }
 
@@ -868,12 +868,12 @@ synserver_delete(SocketServer *s)
     if (s->accept_cont) {
       TSContDestroy(s->accept_cont);
       s->accept_cont = nullptr;
-      TSDebug(SDBG_TAG, "destroyed accept cont");
+      Dbg(dbg_ctl_SockServer, "destroyed accept cont");
     }
 
     s->magic = MAGIC_DEAD;
     TSfree(s);
-    TSDebug(SDBG_TAG, "deleted server");
+    Dbg(dbg_ctl_SockServer, "deleted server");
   }
 
   return 1;
@@ -887,12 +887,12 @@ synserver_vc_refuse(TSCont contp, TSEvent event, void *data)
   SocketServer *s = static_cast<SocketServer *>(TSContDataGet(contp));
   TSAssert(s->magic == MAGIC_ALIVE);
 
-  TSDebug(SDBG_TAG, "%s: NET_ACCEPT", __func__);
+  Dbg(dbg_ctl_SockServer, "%s: NET_ACCEPT", __func__);
 
   if (event == TS_EVENT_NET_ACCEPT_FAILED) {
     Warning("Synserver failed to bind to port %d.", ntohs(s->accept_port));
     ink_release_assert(!"Synserver must be able to bind to a port, check system netstat");
-    TSDebug(SDBG_TAG, "%s: NET_ACCEPT_FAILED", __func__);
+    Dbg(dbg_ctl_SockServer, "%s: NET_ACCEPT_FAILED", __func__);
     return TS_EVENT_IMMEDIATE;
   }
 
@@ -911,11 +911,11 @@ synserver_vc_accept(TSCont contp, TSEvent event, void *data)
   if (event == TS_EVENT_NET_ACCEPT_FAILED) {
     Warning("Synserver failed to bind to port %d.", ntohs(s->accept_port));
     ink_release_assert(!"Synserver must be able to bind to a port, check system netstat");
-    TSDebug(SDBG_TAG, "%s: NET_ACCEPT_FAILED", __func__);
+    Dbg(dbg_ctl_SockServer, "%s: NET_ACCEPT_FAILED", __func__);
     return TS_EVENT_IMMEDIATE;
   }
 
-  TSDebug(SDBG_TAG, "%s: NET_ACCEPT", __func__);
+  Dbg(dbg_ctl_SockServer, "%s: NET_ACCEPT", __func__);
 
   /* Create a new transaction */
   ServerTxn *txn = static_cast<ServerTxn *>(TSmalloc(sizeof(ServerTxn)));
@@ -965,7 +965,7 @@ synserver_txn_close(TSCont contp)
   TSfree(txn);
   TSContDestroy(contp);
 
-  TSDebug(SDBG_TAG, "Server Txn destroyed");
+  Dbg(dbg_ctl_SockServer, "Server Txn destroyed");
   return TS_EVENT_IMMEDIATE;
 }
 
@@ -998,7 +998,7 @@ synserver_txn_write_response(TSCont contp)
   }
 
   /* Start writing the response */
-  TSDebug(SDBG_TAG, "Writing response: |%s| (%" PRId64 ") bytes)", response, len);
+  Dbg(dbg_ctl_SockServer, "Writing response: |%s| (%" PRId64 ") bytes)", response, len);
   txn->write_vio = TSVConnWrite(txn->vconn, contp, txn->resp_reader, len);
 
   /* Now that response is in IOBuffer, free up response */
@@ -1015,23 +1015,23 @@ synserver_txn_write_response_handler(TSCont contp, TSEvent event, void * /* data
 
   switch (event) {
   case TS_EVENT_VCONN_WRITE_READY:
-    TSDebug(SDBG_TAG, "WRITE_READY");
+    Dbg(dbg_ctl_SockServer, "WRITE_READY");
     TSVIOReenable(txn->write_vio);
     break;
 
   case TS_EVENT_VCONN_WRITE_COMPLETE:
-    TSDebug(SDBG_TAG, "WRITE_COMPLETE");
+    Dbg(dbg_ctl_SockServer, "WRITE_COMPLETE");
     TSVConnShutdown(txn->vconn, 0, 1);
     return synserver_txn_close(contp);
     break;
 
   case TS_EVENT_VCONN_EOS:
-    TSDebug(SDBG_TAG, "WRITE_EOS");
+    Dbg(dbg_ctl_SockServer, "WRITE_EOS");
     return synserver_txn_close(contp);
     break;
 
   case TS_EVENT_ERROR:
-    TSDebug(SDBG_TAG, "WRITE_ERROR");
+    Dbg(dbg_ctl_SockServer, "WRITE_ERROR");
     return synserver_txn_close(contp);
     break;
 
@@ -1066,10 +1066,10 @@ synserver_txn_read_request(TSCont contp)
   }
 
   txn->request[txn->request_len] = '\0';
-  TSDebug(SDBG_TAG, "Request = |%s|, req len = %d", txn->request, txn->request_len);
+  Dbg(dbg_ctl_SockServer, "Request = |%s|, req len = %d", txn->request, txn->request_len);
 
   end = (strstr(txn->request, HTTP_REQUEST_END) != nullptr);
-  TSDebug(SDBG_TAG, "End of request = %d", end);
+  Dbg(dbg_ctl_SockServer, "End of request = %d", end);
 
   return end;
 }
@@ -1086,9 +1086,9 @@ synserver_txn_read_request_handler(TSCont contp, TSEvent event, void * /* data A
   switch (event) {
   case TS_EVENT_VCONN_READ_READY:
   case TS_EVENT_VCONN_READ_COMPLETE:
-    TSDebug(SDBG_TAG, (event == TS_EVENT_VCONN_READ_READY) ? "READ_READY" : "READ_COMPLETE");
+    Dbg(dbg_ctl_SockServer, (event == TS_EVENT_VCONN_READ_READY) ? "READ_READY" : "READ_COMPLETE");
     avail = TSIOBufferReaderAvail(txn->req_reader);
-    TSDebug(SDBG_TAG, "%" PRId64 " bytes available in buffer", avail);
+    Dbg(dbg_ctl_SockServer, "%" PRId64 " bytes available in buffer", avail);
 
     if (avail > 0) {
       end_of_request = synserver_txn_read_request(contp);
@@ -1104,12 +1104,12 @@ synserver_txn_read_request_handler(TSCont contp, TSEvent event, void * /* data A
     break;
 
   case TS_EVENT_VCONN_EOS:
-    TSDebug(SDBG_TAG, "READ_EOS");
+    Dbg(dbg_ctl_SockServer, "READ_EOS");
     return synserver_txn_close(contp);
     break;
 
   case TS_EVENT_ERROR:
-    TSDebug(SDBG_TAG, "READ_ERROR");
+    Dbg(dbg_ctl_SockServer, "READ_ERROR");
     return synserver_txn_close(contp);
     break;
 
@@ -1135,7 +1135,11 @@ synserver_txn_main_handler(TSCont contp, TSEvent event, void *data)
 #define TC_PASS 1
 #define TC_FAIL 0
 
-#define UTDBG_TAG "sdk_ut"
+DbgCtl dbg_ctl_sdk_ut{"sdk_ut"};
+DbgCtl dbg_ctl_sdk_ut_cache_event{"sdk_ut_cache_event"};
+DbgCtl dbg_ctl_sdk_ut_cache_read{"sdk_ut_cache_read"};
+DbgCtl dbg_ctl_sdk_ut_cache_write{"sdk_ut_cache_write"};
+DbgCtl dbg_ctl_sdk_ut_transform{"sdk_ut_transform"};
 
 // Since there's no way to unregister global hooks, tests that register a hook
 // have to co-operate once they are complete by re-enabling and transactions
@@ -1627,7 +1631,7 @@ cache_handler(TSCont contp, TSEvent event, void *data)
 
   switch (event) {
   case TS_EVENT_CACHE_OPEN_WRITE:
-    Debug(UTDBG_TAG "_cache_event", "TS_EVENT_CACHE_OPEN_WRITE %d %p", event, data);
+    Dbg(dbg_ctl_sdk_ut_cache_event, "TS_EVENT_CACHE_OPEN_WRITE %d %p", event, data);
     SDK_RPRINT(SDK_Cache_test, "TSCacheWrite", "TestCase1", TC_PASS, "ok");
 
     // data is write_vc
@@ -1657,7 +1661,7 @@ cache_handler(TSCont contp, TSEvent event, void *data)
     return 1;
 
   case TS_EVENT_CACHE_OPEN_WRITE_FAILED:
-    Debug(UTDBG_TAG "_cache_event", "TS_EVENT_CACHE_OPEN_WRITE_FAILED %d %p", event, data);
+    Dbg(dbg_ctl_sdk_ut_cache_event, "TS_EVENT_CACHE_OPEN_WRITE_FAILED %d %p", event, data);
     SDK_RPRINT(SDK_Cache_test, "TSCacheWrite", "TestCase1", TC_FAIL, "can't open cache vc, edtata = %p", data);
     TSReleaseAssert(!"cache");
 
@@ -1666,7 +1670,7 @@ cache_handler(TSCont contp, TSEvent event, void *data)
     return 1;
 
   case TS_EVENT_CACHE_OPEN_READ:
-    Debug(UTDBG_TAG "_cache_event", "TS_EVENT_CACHE_OPEN_READ %d %p", event, data);
+    Dbg(dbg_ctl_sdk_ut_cache_event, "TS_EVENT_CACHE_OPEN_READ %d %p", event, data);
     if (read_counter == 2) {
       SDK_RPRINT(SDK_Cache_test, "TSCacheRead", "TestCase2", TC_FAIL, "shouldn't open cache vc");
 
@@ -1679,7 +1683,7 @@ cache_handler(TSCont contp, TSEvent event, void *data)
 
     cache_vconn->read_vconnp = static_cast<TSVConn>(data);
     content_length           = TSVConnCacheObjectSizeGet(cache_vconn->read_vconnp);
-    Debug(UTDBG_TAG "_cache_read", "In cache open read [Content-Length: %" PRId64 "]", content_length);
+    Dbg(dbg_ctl_sdk_ut_cache_read, "In cache open read [Content-Length: %" PRId64 "]", content_length);
     if (content_length != OBJECT_SIZE) {
       SDK_RPRINT(SDK_Cache_test, "TSVConnCacheObjectSizeGet", "TestCase1", TC_FAIL, "cached data size is incorrect");
 
@@ -1693,7 +1697,7 @@ cache_handler(TSCont contp, TSEvent event, void *data)
     return 1;
 
   case TS_EVENT_CACHE_OPEN_READ_FAILED:
-    Debug(UTDBG_TAG "_cache_event", "TS_EVENT_CACHE_OPEN_READ_FAILED %d %p", event, data);
+    Dbg(dbg_ctl_sdk_ut_cache_event, "TS_EVENT_CACHE_OPEN_READ_FAILED %d %p", event, data);
     if (read_counter == 1) {
       SDK_RPRINT(SDK_Cache_test, "TSCacheRead", "TestCase1", TC_FAIL, "can't open cache vc");
 
@@ -1707,7 +1711,7 @@ cache_handler(TSCont contp, TSEvent event, void *data)
     break;
 
   case TS_EVENT_CACHE_REMOVE:
-    Debug(UTDBG_TAG "_cache_event", "TS_EVENT_CACHE_REMOVE %d %p", event, data);
+    Dbg(dbg_ctl_sdk_ut_cache_event, "TS_EVENT_CACHE_REMOVE %d %p", event, data);
     SDK_RPRINT(SDK_Cache_test, "TSCacheRemove", "TestCase1", TC_PASS, "ok");
 
     // read the data which has been removed
@@ -1716,7 +1720,7 @@ cache_handler(TSCont contp, TSEvent event, void *data)
     return 1;
 
   case TS_EVENT_CACHE_REMOVE_FAILED:
-    Debug(UTDBG_TAG "_cache_event", "TS_EVENT_CACHE_REMOVE_FAILED %d %p", event, data);
+    Dbg(dbg_ctl_sdk_ut_cache_event, "TS_EVENT_CACHE_REMOVE_FAILED %d %p", event, data);
     SDK_RPRINT(SDK_Cache_test, "TSCacheRemove", "TestCase1", TC_FAIL, "can't remove cached item");
 
     // no need to continue, return
@@ -1724,26 +1728,26 @@ cache_handler(TSCont contp, TSEvent event, void *data)
     return 1;
 
   case TS_EVENT_VCONN_WRITE_COMPLETE:
-    Debug(UTDBG_TAG "_cache_event", "TS_EVENT_VCONN_WRITE_COMPLETE %d %p", event, data);
+    Dbg(dbg_ctl_sdk_ut_cache_event, "TS_EVENT_VCONN_WRITE_COMPLETE %d %p", event, data);
 
     // VConn/VIO APIs
     nbytes = TSVIONBytesGet(cache_vconn->write_vio);
     ndone  = TSVIONDoneGet(cache_vconn->write_vio);
     ntodo  = TSVIONTodoGet(cache_vconn->write_vio);
-    Debug(UTDBG_TAG "_cache_write", "Nbytes=%" PRId64 " Ndone=%" PRId64 " Ntodo=%" PRId64 "", nbytes, ndone, ntodo);
+    Dbg(dbg_ctl_sdk_ut_cache_write, "Nbytes=%" PRId64 " Ndone=%" PRId64 " Ntodo=%" PRId64 "", nbytes, ndone, ntodo);
 
     if (ndone == (OBJECT_SIZE / 2)) {
       TSVIONBytesSet(cache_vconn->write_vio, (OBJECT_SIZE - 100));
       TSVIOReenable(cache_vconn->write_vio);
-      Debug(UTDBG_TAG "_cache_write", "Increment write_counter in write_complete [a]");
+      Dbg(dbg_ctl_sdk_ut_cache_write, "Increment write_counter in write_complete [a]");
       return 1;
     } else if (ndone == (OBJECT_SIZE - 100)) {
       TSVIONBytesSet(cache_vconn->write_vio, OBJECT_SIZE);
       TSVIOReenable(cache_vconn->write_vio);
-      Debug(UTDBG_TAG "_cache_write", "Increment write_counter in write_complete [b]");
+      Dbg(dbg_ctl_sdk_ut_cache_write, "Increment write_counter in write_complete [b]");
       return 1;
     } else if (ndone == OBJECT_SIZE) {
-      Debug(UTDBG_TAG "_cache_write", "finishing up [c]");
+      Dbg(dbg_ctl_sdk_ut_cache_write, "finishing up [c]");
 
       SDK_RPRINT(SDK_Cache_test, "TSVIOReenable", "TestCase2", TC_PASS, "ok");
       SDK_RPRINT(SDK_Cache_test, "TSVIONBytesSet", "TestCase1", TC_PASS, "ok");
@@ -1761,7 +1765,7 @@ cache_handler(TSCont contp, TSEvent event, void *data)
       *SDK_Cache_pstatus = REGRESSION_TEST_FAILED;
       return 1;
     }
-    Debug(UTDBG_TAG "_cache_write", "finishing up [d]");
+    Dbg(dbg_ctl_sdk_ut_cache_write, "finishing up [d]");
 
     if (TSVIOBufferGet(cache_vconn->write_vio) != cache_vconn->bufp) {
       SDK_RPRINT(SDK_Cache_test, "TSVIOBufferGet", "TestCase1", TC_FAIL, "write_vio corrupted");
@@ -1779,7 +1783,7 @@ cache_handler(TSCont contp, TSEvent event, void *data)
       SDK_RPRINT(SDK_Cache_test, "TSVIOContGet", "TestCase1", TC_PASS, "ok");
     }
 
-    Debug(UTDBG_TAG "_cache_write", "finishing up [f]");
+    Dbg(dbg_ctl_sdk_ut_cache_write, "finishing up [f]");
 
     if (TSVIOMutexGet(cache_vconn->write_vio) != TSContMutexGet(contp)) {
       SDK_RPRINT(SDK_Cache_test, "TSVIOMutexGet", "TestCase1", TC_FAIL, "write_vio corrupted");
@@ -1797,7 +1801,7 @@ cache_handler(TSCont contp, TSEvent event, void *data)
       SDK_RPRINT(SDK_Cache_test, "TSVIOVConnGet", "TestCase1", TC_PASS, "ok");
     }
 
-    Debug(UTDBG_TAG "_cache_write", "finishing up [g]");
+    Dbg(dbg_ctl_sdk_ut_cache_write, "finishing up [g]");
 
     if (TSVIOReaderGet(cache_vconn->write_vio) != cache_vconn->readerp) {
       SDK_RPRINT(SDK_Cache_test, "TSVIOReaderGet", "TestCase1", TC_FAIL, "write_vio corrupted");
@@ -1811,16 +1815,16 @@ cache_handler(TSCont contp, TSEvent event, void *data)
     TSVConnClose(cache_vconn->write_vconnp);
     cache_vconn->write_vconnp = nullptr;
 
-    Debug(UTDBG_TAG "_cache_write", "finishing up [h]");
+    Dbg(dbg_ctl_sdk_ut_cache_write, "finishing up [h]");
 
     // start to read data out of cache
     read_counter++;
     TSCacheRead(contp, cache_vconn->key);
-    Debug(UTDBG_TAG "_cache_read", "starting read [i]");
+    Dbg(dbg_ctl_sdk_ut_cache_read, "starting read [i]");
     return 1;
 
   case TS_EVENT_VCONN_WRITE_READY:
-    Debug(UTDBG_TAG "_cache_event", "TS_EVENT_VCONN_WRITE_READY %d %p", event, data);
+    Dbg(dbg_ctl_sdk_ut_cache_event, "TS_EVENT_VCONN_WRITE_READY %d %p", event, data);
     if (static_cast<TSVIO>(data) != cache_vconn->write_vio) {
       SDK_RPRINT(SDK_Cache_test, "TSVConnWrite", "TestCase1", TC_FAIL, "write_vio corrupted");
       *SDK_Cache_pstatus = REGRESSION_TEST_FAILED;
@@ -1830,13 +1834,13 @@ cache_handler(TSCont contp, TSEvent event, void *data)
     nbytes = TSVIONBytesGet(cache_vconn->write_vio);
     ndone  = TSVIONDoneGet(cache_vconn->write_vio);
     ntodo  = TSVIONTodoGet(cache_vconn->write_vio);
-    Debug(UTDBG_TAG "_cache_write", "Nbytes=%" PRId64 " Ndone=%" PRId64 " Ntodo=%" PRId64 "", nbytes, ndone, ntodo);
+    Dbg(dbg_ctl_sdk_ut_cache_write, "Nbytes=%" PRId64 " Ndone=%" PRId64 " Ntodo=%" PRId64 "", nbytes, ndone, ntodo);
 
     TSVIOReenable(cache_vconn->write_vio);
     return 1;
 
   case TS_EVENT_VCONN_READ_COMPLETE:
-    Debug(UTDBG_TAG "_cache_event", "TS_EVENT_VCONN_READ_COMPLETE %d %p", event, data);
+    Dbg(dbg_ctl_sdk_ut_cache_event, "TS_EVENT_VCONN_READ_COMPLETE %d %p", event, data);
     if (static_cast<TSVIO>(data) != cache_vconn->read_vio) {
       SDK_RPRINT(SDK_Cache_test, "TSVConnRead", "TestCase1", TC_FAIL, "read_vio corrupted");
 
@@ -1848,7 +1852,7 @@ cache_handler(TSCont contp, TSEvent event, void *data)
     nbytes = TSVIONBytesGet(cache_vconn->read_vio);
     ntodo  = TSVIONTodoGet(cache_vconn->read_vio);
     ndone  = TSVIONDoneGet(cache_vconn->read_vio);
-    Debug(UTDBG_TAG "_cache_read", "Nbytes=%" PRId64 " Ndone=%" PRId64 " Ntodo=%" PRId64 "", nbytes, ndone, ntodo);
+    Dbg(dbg_ctl_sdk_ut_cache_read, "Nbytes=%" PRId64 " Ndone=%" PRId64 " Ntodo=%" PRId64 "", nbytes, ndone, ntodo);
 
     if (nbytes != (ndone + ntodo)) {
       SDK_RPRINT(SDK_Cache_test, "TSVIONBytesGet", "TestCase1", TC_FAIL, "read_vio corrupted");
@@ -1874,7 +1878,7 @@ cache_handler(TSCont contp, TSEvent event, void *data)
         SDK_RPRINT(SDK_Cache_test, "TSVIONDoneSet", "TestCase1", TC_PASS, "ok");
       }
 
-      Debug(UTDBG_TAG "_cache_write", "finishing up [i]");
+      Dbg(dbg_ctl_sdk_ut_cache_write, "finishing up [i]");
 
       // now waiting for 100ms to make sure the key is
       // written in directory remove the content
@@ -1884,7 +1888,7 @@ cache_handler(TSCont contp, TSEvent event, void *data)
     return 1;
 
   case TS_EVENT_VCONN_READ_READY:
-    Debug(UTDBG_TAG "_cache_event", "TS_EVENT_VCONN_READ_READY %d %p", event, data);
+    Dbg(dbg_ctl_sdk_ut_cache_event, "TS_EVENT_VCONN_READ_READY %d %p", event, data);
     if (static_cast<TSVIO>(data) != cache_vconn->read_vio) {
       SDK_RPRINT(SDK_Cache_test, "TSVConnRead", "TestCase1", TC_FAIL, "read_vio corrupted");
 
@@ -1896,7 +1900,7 @@ cache_handler(TSCont contp, TSEvent event, void *data)
     nbytes = TSVIONBytesGet(cache_vconn->read_vio);
     ntodo  = TSVIONTodoGet(cache_vconn->read_vio);
     ndone  = TSVIONDoneGet(cache_vconn->read_vio);
-    Debug(UTDBG_TAG "_cache_read", "Nbytes=%" PRId64 " Ndone=%" PRId64 " Ntodo=%" PRId64 "", nbytes, ndone, ntodo);
+    Dbg(dbg_ctl_sdk_ut_cache_read, "Nbytes=%" PRId64 " Ndone=%" PRId64 " Ntodo=%" PRId64 "", nbytes, ndone, ntodo);
 
     if (nbytes != (ndone + ntodo)) {
       SDK_RPRINT(SDK_Cache_test, "TSVIONBytesGet", "TestCase1", TC_FAIL, "read_vio corrupted");
@@ -1915,14 +1919,14 @@ cache_handler(TSCont contp, TSEvent event, void *data)
     // Fix for bug INKqa12276: Must consume data from iobuffer
     nbytes = TSIOBufferReaderAvail(cache_vconn->out_readerp);
     TSIOBufferReaderConsume(cache_vconn->out_readerp, nbytes);
-    TSDebug(UTDBG_TAG "_cache_read", "Consuming %" PRId64 " bytes from cache read VC", nbytes);
+    Dbg(dbg_ctl_sdk_ut_cache_read, "Consuming %" PRId64 " bytes from cache read VC", nbytes);
 
     TSVIOReenable(cache_vconn->read_vio);
-    Debug(UTDBG_TAG "_cache_read", "finishing up [j]");
+    Dbg(dbg_ctl_sdk_ut_cache_read, "finishing up [j]");
     return 1;
 
   case TS_EVENT_TIMEOUT:
-    Debug(UTDBG_TAG "_cache_event", "TS_EVENT_TIMEOUT %d %p", event, data);
+    Dbg(dbg_ctl_sdk_ut_cache_event, "TS_EVENT_TIMEOUT %d %p", event, data);
     // do remove cached doc
     TSCacheRemove(contp, cache_vconn->key);
     return 1;
@@ -1931,10 +1935,10 @@ cache_handler(TSCont contp, TSEvent event, void *data)
     TSReleaseAssert(!"Test SDK_API_TSCache: unexpected event");
   }
 
-  Debug(UTDBG_TAG "_cache_event", "DONE DONE DONE");
+  Dbg(dbg_ctl_sdk_ut_cache_event, "DONE DONE DONE");
 
   // destroy the data structure
-  Debug(UTDBG_TAG "_cache_write", "all tests passed [z]");
+  Dbg(dbg_ctl_sdk_ut_cache_write, "all tests passed [z]");
   TSIOBufferDestroy(cache_vconn->bufp);
   TSIOBufferDestroy(cache_vconn->out_bufp);
   TSCacheKeyDestroy(cache_vconn->key);
@@ -3284,7 +3288,7 @@ checkHttpTxnIncomingAddrGet(SocketTest *test, void *data)
   }
   port = ats_ip_port_host_order(ptr);
 
-  TSDebug(UTDBG_TAG, "TS HTTP port = %x, Txn incoming client port %x", proxy_port->m_port, port);
+  Dbg(dbg_ctl_sdk_ut, "TS HTTP port = %x, Txn incoming client port %x", proxy_port->m_port, port);
 
   if (port == proxy_port->m_port) {
     SDK_RPRINT(test->regtest, "TSHttpTxnIncomingAddrGet", "TestCase1", TC_PASS, "ok");
@@ -3315,7 +3319,7 @@ checkHttpTxnClientAddrGet(SocketTest *test, void *data)
   }
 
   port = ats_ip_port_host_order(ptr);
-  TSDebug(UTDBG_TAG, "Browser port = %x, Txn remote port = %x", browser_port, port);
+  Dbg(dbg_ctl_sdk_ut, "Browser port = %x, Txn remote port = %x", browser_port, port);
 
   if (port == browser_port) {
     SDK_RPRINT(test->regtest, "TSHttpTxnClientAddrGet", "TestCase1", TC_PASS, "ok");
@@ -8044,7 +8048,7 @@ transform_hook_handler(TSCont contp, TSEvent event, void *edata)
         return 0;
       }
       data->req_no++;
-      Debug(UTDBG_TAG "_transform", "Running Browser 2");
+      Dbg(dbg_ctl_sdk_ut_transform, "Running Browser 2");
       synclient_txn_send_request(data->browser2, data->request2);
       TSContScheduleOnPool(contp, 25, TS_THREAD_POOL_NET);
       return 0;
@@ -8054,7 +8058,7 @@ transform_hook_handler(TSCont contp, TSEvent event, void *edata)
         return 0;
       }
       data->req_no++;
-      Debug(UTDBG_TAG "_transform", "Running Browser 3");
+      Dbg(dbg_ctl_sdk_ut_transform, "Running Browser 3");
       synclient_txn_send_request(data->browser3, data->request1);
       TSContScheduleOnPool(contp, 25, TS_THREAD_POOL_NET);
       return 0;
@@ -8064,7 +8068,7 @@ transform_hook_handler(TSCont contp, TSEvent event, void *edata)
         return 0;
       }
       data->req_no++;
-      Debug(UTDBG_TAG "_transform", "Running Browser 4");
+      Dbg(dbg_ctl_sdk_ut_transform, "Running Browser 4");
       synclient_txn_send_request(data->browser4, data->request2);
       TSContScheduleOnPool(contp, 25, TS_THREAD_POOL_NET);
       return 0;
@@ -8165,7 +8169,7 @@ EXCLUSIVE_REGRESSION_TEST(SDK_API_HttpTxnTransform)(RegressionTest *test, int /*
 {
   *pstatus = REGRESSION_TEST_INPROGRESS;
 
-  Debug(UTDBG_TAG "_transform", "Starting test");
+  Dbg(dbg_ctl_sdk_ut_transform, "Starting test");
 
   TSCont cont = TSContCreate(transform_hook_handler, TSMutexCreate());
   if (cont == nullptr) {
@@ -8204,7 +8208,7 @@ EXCLUSIVE_REGRESSION_TEST(SDK_API_HttpTxnTransform)(RegressionTest *test, int /*
   socktest->browser4 = synclient_txn_create();
   socktest->request1 = generate_request(4);
   socktest->request2 = generate_request(5);
-  Debug(UTDBG_TAG "_transform", "Running Browser 1");
+  Dbg(dbg_ctl_sdk_ut_transform, "Running Browser 1");
   synclient_txn_send_request(socktest->browser1, socktest->request1);
   // synclient_txn_send_request(socktest->browser2, socktest->request2);
 
@@ -8480,30 +8484,30 @@ cont_test_handler(TSCont contp, TSEvent event, void *edata)
   TSReleaseAssert(data->magic == MAGIC_ALIVE);
   TSReleaseAssert((data->test_case == TEST_CASE_CONNECT_ID1) || (data->test_case == TEST_CASE_CONNECT_ID2));
 
-  TSDebug(UTDBG_TAG, "Calling cont_test_handler with event %s (%d)", TSHttpEventNameLookup(event), event);
+  Dbg(dbg_ctl_sdk_ut, "Calling cont_test_handler with event %s (%d)", TSHttpEventNameLookup(event), event);
 
   switch (event) {
   case TS_EVENT_HTTP_READ_REQUEST_HDR:
-    TSDebug(UTDBG_TAG, "cont_test_handler: event READ_REQUEST");
+    Dbg(dbg_ctl_sdk_ut, "cont_test_handler: event READ_REQUEST");
 
     // First make sure we're getting called for either request 9 or txn 10
     // Otherwise, this is a request sent by another test. do nothing.
     request_id = get_request_id(txnp);
     TSReleaseAssert(request_id != -1);
 
-    TSDebug(UTDBG_TAG, "cont_test_handler: Request id = %d", request_id);
+    Dbg(dbg_ctl_sdk_ut, "cont_test_handler: Request id = %d", request_id);
 
     if ((request_id != TEST_CASE_CONNECT_ID1) && (request_id != TEST_CASE_CONNECT_ID2)) {
-      TSDebug(UTDBG_TAG, "This is not an event for this test !");
+      Dbg(dbg_ctl_sdk_ut, "This is not an event for this test !");
       TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
       goto done;
     }
 
     if ((request_id == TEST_CASE_CONNECT_ID1) && (data->test_case == TEST_CASE_CONNECT_ID1)) {
-      TSDebug(UTDBG_TAG, "Calling TSHttpTxnIntercept");
+      Dbg(dbg_ctl_sdk_ut, "Calling TSHttpTxnIntercept");
       TSHttpTxnIntercept(data->os->accept_cont, txnp);
     } else if ((request_id == TEST_CASE_CONNECT_ID2) && (data->test_case == TEST_CASE_CONNECT_ID2)) {
-      TSDebug(UTDBG_TAG, "Calling TSHttpTxnServerIntercept");
+      Dbg(dbg_ctl_sdk_ut, "Calling TSHttpTxnServerIntercept");
       TSHttpTxnServerIntercept(data->os->accept_cont, txnp);
     }
 
@@ -8513,7 +8517,7 @@ cont_test_handler(TSCont contp, TSEvent event, void *edata)
   case TS_EVENT_TIMEOUT:
     /* Browser still waiting the response ? */
     if (data->browser->status == REQUEST_INPROGRESS) {
-      TSDebug(UTDBG_TAG, "Browser still waiting response...");
+      Dbg(dbg_ctl_sdk_ut, "Browser still waiting response...");
       TSContScheduleOnPool(contp, 25, TS_THREAD_POOL_NET);
     }
     /* Browser got the response */
@@ -8526,7 +8530,8 @@ cont_test_handler(TSCont contp, TSEvent event, void *edata)
       } else {
         body_expected = "Body for response 10";
       }
-      TSDebug(UTDBG_TAG, "Body Response = \n|%s|\nBody Expected = \n|%s|", body_response ? body_response : "*NULL*", body_expected);
+      Dbg(dbg_ctl_sdk_ut, "Body Response = \n|%s|\nBody Expected = \n|%s|", body_response ? body_response : "*NULL*",
+          body_expected);
 
       if (!body_response || strncmp(body_response, body_expected, strlen(body_expected)) != 0) {
         if (data->test_case == TEST_CASE_CONNECT_ID1) {
@@ -8573,7 +8578,7 @@ EXCLUSIVE_REGRESSION_TEST(SDK_API_TSHttpConnectIntercept)(RegressionTest *test,
 {
   *pstatus = REGRESSION_TEST_INPROGRESS;
 
-  TSDebug(UTDBG_TAG, "Starting test TSHttpConnectIntercept");
+  Dbg(dbg_ctl_sdk_ut, "Starting test TSHttpConnectIntercept");
 
   TSCont cont_test      = TSContCreate(cont_test_handler, TSMutexCreate());
   ConnectTestData *data = static_cast<ConnectTestData *>(TSmalloc(sizeof(ConnectTestData)));
@@ -8620,7 +8625,7 @@ EXCLUSIVE_REGRESSION_TEST(SDK_API_TSHttpConnectServerIntercept)(RegressionTest *
   // failover period to a very large value.
   dns_failover_period = 1000;
 
-  TSDebug(UTDBG_TAG, "Starting test TSHttpConnectServerIntercept");
+  Dbg(dbg_ctl_sdk_ut, "Starting test TSHttpConnectServerIntercept");
 
   TSCont cont_test      = TSContCreate(cont_test_handler, TSMutexCreate());
   ConnectTestData *data = static_cast<ConnectTestData *>(TSmalloc(sizeof(ConnectTestData)));
diff --git a/src/tscore/DbgCtl.cc b/src/tscore/DbgCtl.cc
index 0c5cad85fd6..f4992ac6fc0 100644
--- a/src/tscore/DbgCtl.cc
+++ b/src/tscore/DbgCtl.cc
@@ -32,16 +32,16 @@
 
 DbgCtl::DbgCtl(DbgCtl &&src)
 {
-  ink_release_assert(src._ptr != &_No_tag_dummy);
+  ink_release_assert(src._ptr != &_No_tag_dummy());
 
   _ptr     = src._ptr;
-  src._ptr = &_No_tag_dummy;
+  src._ptr = &_No_tag_dummy();
 }
 
 DbgCtl &
 DbgCtl::operator=(DbgCtl &&src)
 {
-  ink_release_assert(&_No_tag_dummy == _ptr);
+  ink_release_assert(&_No_tag_dummy() == _ptr);
 
   new (this) DbgCtl{std::move(src)};
 
@@ -223,5 +223,3 @@ DbgCtl::_override_global_on()
 {
   return diags()->get_override();
 }
-
-DbgCtl::_TagData const DbgCtl::_No_tag_dummy{nullptr, false};
diff --git a/src/tscore/Diags.cc b/src/tscore/Diags.cc
index fa4646d62ab..326e42f4c34 100644
--- a/src/tscore/Diags.cc
+++ b/src/tscore/Diags.cc
@@ -47,8 +47,7 @@
 #include "tscore/Diags.h"
 #include "ts/ts.h"
 
-int tsapi::c::diags_on_for_plugins = 0;
-int DiagsConfigState::_enabled[2]  = {0, 0};
+int DiagsConfigState::_enabled[2] = {0, 0};
 
 using namespace swoc::literals;
 
@@ -62,7 +61,6 @@ DiagsConfigState::enabled(DiagsTagType dtt, int new_value)
 
   if (DiagsTagType_Debug == dtt) {
     DbgCtl::_config_mode.store(new_value, std::memory_order_relaxed);
-    diags_on_for_plugins = (1 & new_value) != 0;
   }
 }
 
diff --git a/src/tscpp/api/Logger.cc b/src/tscpp/api/Logger.cc
index 3ed269de4c3..d574045b5e7 100644
--- a/src/tscpp/api/Logger.cc
+++ b/src/tscpp/api/Logger.cc
@@ -35,6 +35,8 @@
 using std::vector;
 using std::string;
 
+DbgCtl atscppapi::dbg_ctl{"atscppapi"};
+
 using atscppapi::Logger;
 
 /**
diff --git a/src/tscpp/api/logging_internal.h b/src/tscpp/api/logging_internal.h
index 9c0e32e3c26..9ecb3656909 100644
--- a/src/tscpp/api/logging_internal.h
+++ b/src/tscpp/api/logging_internal.h
@@ -36,5 +36,10 @@
 #undef LOG_ERROR
 #endif
 
-#define LOG_DEBUG(fmt, ...) TS_DEBUG("atscppapi", fmt, ##__VA_ARGS__)
+namespace atscppapi
+{
+extern DbgCtl dbg_ctl;
+}
+
+#define LOG_DEBUG(fmt, ...) Dbg(atscppapi::dbg_ctl, fmt, ##__VA_ARGS__)
 #define LOG_ERROR(fmt, ...) TS_ERROR("atscppapi", fmt, ##__VA_ARGS__)
diff --git a/tests/gold_tests/continuations/plugins/session_id_verify.cc b/tests/gold_tests/continuations/plugins/session_id_verify.cc
index 4a3b5e3377e..fcc407e8ff3 100644
--- a/tests/gold_tests/continuations/plugins/session_id_verify.cc
+++ b/tests/gold_tests/continuations/plugins/session_id_verify.cc
@@ -31,6 +31,8 @@ static char plugin_name[]   = PLUGIN_NAME;
 static char vendor_name[]   = "Apache";
 static char support_email[] = "bneradt@apache.org";
 
+static DbgCtl dbg_ctl{plugin_name};
+
 int
 global_handler(TSCont continuation, TSEvent event, void *data)
 {
@@ -38,7 +40,7 @@ global_handler(TSCont continuation, TSEvent event, void *data)
 
   switch (event) {
   case TS_EVENT_HTTP_SSN_START: {
-    TSDebug(PLUGIN_NAME, " -- global_handler :: TS_EVENT_HTTP_SSN_START");
+    Dbg(dbg_ctl, " -- global_handler :: TS_EVENT_HTTP_SSN_START");
     int64_t id = TSHttpSsnIdGet(session);
 
     static std::unordered_set<int64_t> seen_ids;
@@ -47,7 +49,7 @@ global_handler(TSCont continuation, TSEvent event, void *data)
     } else {
       seen_ids.insert(id);
     }
-    TSDebug(PLUGIN_NAME, "session id: %" PRId64, id);
+    Dbg(dbg_ctl, "session id: %" PRId64, id);
   } break;
 
   default:
@@ -62,7 +64,7 @@ global_handler(TSCont continuation, TSEvent event, void *data)
 void
 TSPluginInit(int argc, const char *argv[])
 {
-  TSDebug(PLUGIN_NAME, "initializing plugin");
+  Dbg(dbg_ctl, "initializing plugin");
 
   TSPluginRegistrationInfo info;
 
diff --git a/tests/gold_tests/jsonrpc/plugins/jsonrpc_plugin_handler_test.cc b/tests/gold_tests/jsonrpc/plugins/jsonrpc_plugin_handler_test.cc
index 8a8dbe52bf2..96b1bc713fb 100644
--- a/tests/gold_tests/jsonrpc/plugins/jsonrpc_plugin_handler_test.cc
+++ b/tests/gold_tests/jsonrpc/plugins/jsonrpc_plugin_handler_test.cc
@@ -38,6 +38,8 @@ namespace
 {
 constexpr char PLUGIN_NAME[] = "jsonrpc_plugin_handler_test";
 
+DbgCtl dbg_ctl{PLUGIN_NAME};
+
 const std::string MY_YAML_VERSION{"0.8.0"};
 const std::string RPC_PROVIDER_NAME{"RPC Plugin test"};
 } // namespace
@@ -47,7 +49,7 @@ namespace
 void
 test_join_hosts_method(const char *id, TSYaml p)
 {
-  TSDebug(PLUGIN_NAME, "Got a call! id: %s", id);
+  Dbg(dbg_ctl, "Got a call! id: %s", id);
   YAML::Node params = *reinterpret_cast<YAML::Node *>(p);
 
   // This handler errors.
@@ -77,7 +79,7 @@ test_join_hosts_method(const char *id, TSYaml p)
     // All done. Notify the RPC manager.
     TSRPCHandlerDone(reinterpret_cast<TSYaml>(&resp));
   } catch (YAML::Exception const &ex) {
-    TSDebug(PLUGIN_NAME, "Oops, something went wrong: %s", ex.what());
+    Dbg(dbg_ctl, "Oops, something went wrong: %s", ex.what());
     std::string descr{ex.what()};
     TSRPCHandlerError(UNKNOWN_ERROR, descr.c_str(), descr.size());
   }
@@ -87,7 +89,7 @@ test_join_hosts_method(const char *id, TSYaml p)
 void
 test_join_hosts_notification(TSYaml p)
 {
-  TSDebug(PLUGIN_NAME, "Got a call!");
+  Dbg(dbg_ctl, "Got a call!");
   try {
     YAML::Node params = *reinterpret_cast<YAML::Node *>(p);
 
@@ -96,14 +98,14 @@ test_join_hosts_notification(TSYaml p)
       hosts = hosts.as<std::vector<std::string>>();
     }
     if (0 == hosts.size()) {
-      TSDebug(PLUGIN_NAME, "No hosts field provided. Nothing we can do. No response back.");
+      Dbg(dbg_ctl, "No hosts field provided. Nothing we can do. No response back.");
       return;
     }
     std::string join;
     std::for_each(std ::begin(hosts), std::end(hosts), [&join](auto &&s) { join += s; });
-    TSDebug(PLUGIN_NAME, "Notification properly handled: %s", join.c_str());
+    Dbg(dbg_ctl, "Notification properly handled: %s", join.c_str());
   } catch (YAML::Exception const &ex) {
-    TSDebug(PLUGIN_NAME, "Oops, something went wrong: %s", ex.what());
+    Dbg(dbg_ctl, "Oops, something went wrong: %s", ex.what());
   }
 }
 } // namespace
@@ -120,7 +122,7 @@ CB_handle_rpc_io_call(TSCont contp, TSEvent event, void *data)
 {
   namespace fs = swoc::file;
 
-  TSDebug(PLUGIN_NAME, "Working on the update now");
+  Dbg(dbg_ctl, "Working on the update now");
   YAML::Node params = *static_cast<YAML::Node *>(TSContDataGet(contp));
 
   // This handler errors.
@@ -232,7 +234,7 @@ CB_handle_rpc_io_call(TSCont contp, TSEvent event, void *data)
 
   // clean up the temp file if possible.
   if (fs::remove(tmpFile, ec); ec) {
-    TSDebug(PLUGIN_NAME, "Temp file could not be removed: %s", tmpFile.c_str());
+    Dbg(dbg_ctl, "Temp file could not be removed: %s", tmpFile.c_str());
   }
 
   // make the response. For complex structures YAML::convert<T>::encode() would be the preferred way.
@@ -285,18 +287,18 @@ TSPluginInit(int argc, const char *argv[])
   std::string method_name{"test_join_hosts_method"};
   if (TSRPCRegisterMethodHandler(method_name.c_str(), method_name.size(), test_join_hosts_method, rpcRegistrationInfo, &opt) ==
       TS_ERROR) {
-    TSDebug(PLUGIN_NAME, "%s failed to register", method_name.c_str());
+    Dbg(dbg_ctl, "%s failed to register", method_name.c_str());
   } else {
-    TSDebug(PLUGIN_NAME, "%s successfully registered", method_name.c_str());
+    Dbg(dbg_ctl, "%s successfully registered", method_name.c_str());
   }
 
   // TASK thread.
   method_name = "test_io_on_et_task";
   if (TSRPCRegisterMethodHandler(method_name.c_str(), method_name.size(), test_io_on_et_task, rpcRegistrationInfo, &opt) ==
       TS_ERROR) {
-    TSDebug(PLUGIN_NAME, "%s failed to register", method_name.c_str());
+    Dbg(dbg_ctl, "%s failed to register", method_name.c_str());
   } else {
-    TSDebug(PLUGIN_NAME, "%s successfully registered", method_name.c_str());
+    Dbg(dbg_ctl, "%s successfully registered", method_name.c_str());
   }
 
   // Notification
@@ -304,10 +306,10 @@ TSPluginInit(int argc, const char *argv[])
   method_name = "test_join_hosts_notification";
   if (TSRPCRegisterNotificationHandler(method_name.c_str(), method_name.size(), test_join_hosts_notification, rpcRegistrationInfo,
                                        &nOpt) == TS_ERROR) {
-    TSDebug(PLUGIN_NAME, "%s failed to register", method_name.c_str());
+    Dbg(dbg_ctl, "%s failed to register", method_name.c_str());
   } else {
-    TSDebug(PLUGIN_NAME, "%s successfully registered", method_name.c_str());
+    Dbg(dbg_ctl, "%s successfully registered", method_name.c_str());
   }
 
-  TSDebug(PLUGIN_NAME, "Test Plugin Initialized.");
+  Dbg(dbg_ctl, "Test Plugin Initialized.");
 }
diff --git a/tests/gold_tests/null_transform/null_transform.test.py b/tests/gold_tests/null_transform/null_transform.test.py
index 25cd653e39f..867b388b104 100644
--- a/tests/gold_tests/null_transform/null_transform.test.py
+++ b/tests/gold_tests/null_transform/null_transform.test.py
@@ -47,6 +47,7 @@
 server.addResponse("sessionfile.log", request_header, response_header)
 ts.Disk.records_config.update({
     'proxy.config.diags.debug.enabled': 1,
+    'proxy.config.diags.show_location': 0,
     'proxy.config.diags.debug.tags': 'null_transform'
 })
 ts.Disk.remap_config.AddLine(
diff --git a/tests/gold_tests/pluginTest/header_rewrite/header_rewrite.test.py b/tests/gold_tests/pluginTest/header_rewrite/header_rewrite.test.py
index c25b1841cea..a4d4120899a 100644
--- a/tests/gold_tests/pluginTest/header_rewrite/header_rewrite.test.py
+++ b/tests/gold_tests/pluginTest/header_rewrite/header_rewrite.test.py
@@ -34,6 +34,7 @@
 server.addResponse("sessionfile.log", request_header, response_header)
 ts.Disk.records_config.update({
     'proxy.config.diags.debug.enabled': 1,
+    'proxy.config.diags.show_location': 0,
     'proxy.config.diags.debug.tags': 'header.*',
 })
 # The following rule changes the status code returned from origin server to 303
diff --git a/tests/gold_tests/pluginTest/header_rewrite/header_rewrite_cond_method.test.py b/tests/gold_tests/pluginTest/header_rewrite/header_rewrite_cond_method.test.py
index 2e6ae69f37e..9dad2392f83 100644
--- a/tests/gold_tests/pluginTest/header_rewrite/header_rewrite_cond_method.test.py
+++ b/tests/gold_tests/pluginTest/header_rewrite/header_rewrite_cond_method.test.py
@@ -37,6 +37,7 @@
 server.addResponse(session_file, request_delete, response)
 ts.Disk.records_config.update({
     'proxy.config.diags.debug.enabled': 1,
+    'proxy.config.diags.show_location': 0,
     'proxy.config.diags.debug.tags': 'header.*',
     'proxy.config.http.insert_response_via_str': 0,
 })
diff --git a/tests/gold_tests/pluginTest/header_rewrite/header_rewrite_l_value.test.py b/tests/gold_tests/pluginTest/header_rewrite/header_rewrite_l_value.test.py
index ead0a2323d4..a4ece4a53b2 100644
--- a/tests/gold_tests/pluginTest/header_rewrite/header_rewrite_l_value.test.py
+++ b/tests/gold_tests/pluginTest/header_rewrite/header_rewrite_l_value.test.py
@@ -36,6 +36,7 @@
 server.addResponse("sessionfile.log", request_header, response_header)
 ts.Disk.records_config.update({
     'proxy.config.diags.debug.enabled': 1,
+    'proxy.config.diags.show_location': 0,
     'proxy.config.diags.debug.tags': 'header.*',
 })
 
diff --git a/tests/gold_tests/pluginTest/header_rewrite/header_rewrite_url.test.py b/tests/gold_tests/pluginTest/header_rewrite/header_rewrite_url.test.py
index 25ce462fc3b..876c965e206 100644
--- a/tests/gold_tests/pluginTest/header_rewrite/header_rewrite_url.test.py
+++ b/tests/gold_tests/pluginTest/header_rewrite/header_rewrite_url.test.py
@@ -36,6 +36,7 @@
 
 ts.Disk.records_config.update({
     'proxy.config.diags.debug.enabled': 1,
+    'proxy.config.diags.show_location': 0,
     'proxy.config.diags.debug.tags': 'header.*',
 })
 # The following rule changes the status code returned from origin server to 303
diff --git a/tests/gold_tests/pluginTest/s3_auth/s3_auth_config.test.py b/tests/gold_tests/pluginTest/s3_auth/s3_auth_config.test.py
index ffcdc3bc341..c21966e5809 100644
--- a/tests/gold_tests/pluginTest/s3_auth/s3_auth_config.test.py
+++ b/tests/gold_tests/pluginTest/s3_auth/s3_auth_config.test.py
@@ -42,6 +42,7 @@
 
 ts.Disk.records_config.update({
     'proxy.config.diags.debug.enabled': 1,
+    'proxy.config.diags.show_location': 0,
     'proxy.config.diags.debug.tags': 's3_auth',
 })
 
diff --git a/tests/gold_tests/pluginTest/test_hooks/hook_add.test.py b/tests/gold_tests/pluginTest/test_hooks/hook_add.test.py
index d908c8e884f..394dbbeb63b 100644
--- a/tests/gold_tests/pluginTest/test_hooks/hook_add.test.py
+++ b/tests/gold_tests/pluginTest/test_hooks/hook_add.test.py
@@ -34,6 +34,7 @@
 
 ts.Disk.records_config.update({
     'proxy.config.diags.debug.tags': 'test',
+    'proxy.config.diags.show_location': 0,
     'proxy.config.diags.debug.enabled': 1,
     'proxy.config.url_remap.remap_required': 0,
 })
diff --git a/tests/gold_tests/pluginTest/test_hooks/ssn_start_delay_hook.test.py b/tests/gold_tests/pluginTest/test_hooks/ssn_start_delay_hook.test.py
index d0aa6b63f55..88a4211e06b 100644
--- a/tests/gold_tests/pluginTest/test_hooks/ssn_start_delay_hook.test.py
+++ b/tests/gold_tests/pluginTest/test_hooks/ssn_start_delay_hook.test.py
@@ -34,6 +34,7 @@
 
 ts.Disk.records_config.update({
     'proxy.config.diags.debug.tags': 'test',
+    'proxy.config.diags.show_location': 0,
     'proxy.config.diags.debug.enabled': 1,
     'proxy.config.http.cache.http': 0,
     'proxy.config.url_remap.remap_required': 0,
diff --git a/tests/gold_tests/pluginTest/tsapi/test_TSHttpTxnServerAddrSet.cc b/tests/gold_tests/pluginTest/tsapi/test_TSHttpTxnServerAddrSet.cc
index 96217ec9f39..a10aba96bd1 100644
--- a/tests/gold_tests/pluginTest/tsapi/test_TSHttpTxnServerAddrSet.cc
+++ b/tests/gold_tests/pluginTest/tsapi/test_TSHttpTxnServerAddrSet.cc
@@ -33,6 +33,8 @@ namespace
 
 std::string_view PNAME = "test_plugin";
 
+DbgCtl dbg_ctl{PNAME.data()};
+
 /** Represents the origin address and port that the user specified to which to
  * redirect requests. */
 class TargetAddress
@@ -145,8 +147,8 @@ set_origin(TSCont cont, TSEvent event, void *edata)
     TSHttpTxnReenable(txnp, TS_EVENT_HTTP_ERROR);
     return TS_ERROR;
   }
-  TSDebug(PNAME.data(), "Successfully set a transaction's origin to %s:%d", g_target_address->get_address().data(),
-          g_target_address->get_port());
+  Dbg(dbg_ctl, "Successfully set a transaction's origin to %s:%d", g_target_address->get_address().data(),
+      g_target_address->get_port());
   TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
   return TS_SUCCESS;
 }
@@ -156,7 +158,7 @@ set_origin(TSCont cont, TSEvent event, void *edata)
 void
 TSPluginInit(int argc, char const *argv[])
 {
-  TSDebug(PNAME.data(), "Initializing plugin.");
+  Dbg(dbg_ctl, "Initializing plugin.");
 
   TSPluginRegistrationInfo info;
   info.plugin_name   = PNAME.data();
@@ -169,7 +171,7 @@ TSPluginInit(int argc, char const *argv[])
     return;
   }
 
-  TSDebug(PNAME.data(), "Redirecting all requests to %s:%s", argv[1], argv[2]);
+  Dbg(dbg_ctl, "Redirecting all requests to %s:%s", argv[1], argv[2]);
 
   TSCont contp = TSContCreate(set_origin, nullptr);
   TSHttpHookAdd(TS_HTTP_CACHE_LOOKUP_COMPLETE_HOOK, contp);
diff --git a/tests/gold_tests/pluginTest/tsapi/test_tsapi.cc b/tests/gold_tests/pluginTest/tsapi/test_tsapi.cc
index d6c83c8fc66..5691d8af114 100644
--- a/tests/gold_tests/pluginTest/tsapi/test_tsapi.cc
+++ b/tests/gold_tests/pluginTest/tsapi/test_tsapi.cc
@@ -178,8 +178,6 @@ transactionContFunc(TSCont, TSEvent event, void *eventData)
 
   Dbg(dbg_ctl, "Transaction: event=%s(%d) eventData=%p", TSHttpEventNameLookup(event), event, eventData);
 
-  TSDebug(PIName, "Should not see this, enabled set to 3");
-
   Dbg(off_dbg_ctl, "Should not see this, tag does not match regular expression");
 
   switch (event) {
@@ -257,6 +255,10 @@ TSRemapInit(TSRemapInterface *api_info, char *errbuf, int errbuf_size)
 {
   Dbg(dbg_ctl, "TSRemapInit()");
 
+  SpecificDbg(true, off_dbg_ctl, "Should see this");
+  SpecificDbg(false, dbg_ctl, "Should see this");
+  SpecificDbg(false, off_dbg_ctl, "Should NOT see this");
+
   TSReleaseAssert(api_info != nullptr);
   TSReleaseAssert(api_info->size == sizeof(TSRemapInterface));
   TSReleaseAssert(api_info->tsremap_version == TSREMAP_VERSION);
diff --git a/tests/gold_tests/tls_hooks/tls_hooks.test.py b/tests/gold_tests/tls_hooks/tls_hooks.test.py
index 29762e5c0f8..8419263f0cc 100644
--- a/tests/gold_tests/tls_hooks/tls_hooks.test.py
+++ b/tests/gold_tests/tls_hooks/tls_hooks.test.py
@@ -35,6 +35,7 @@
 
 ts.Disk.records_config.update({
     'proxy.config.diags.debug.enabled': 1,
+    'proxy.config.diags.show_location': 0,
     'proxy.config.diags.debug.tags': 'ssl_hook_test',
     'proxy.config.ssl.server.cert.path': '{0}'.format(ts.Variables.SSLDir),
     'proxy.config.ssl.server.private_key.path': '{0}'.format(ts.Variables.SSLDir),
diff --git a/tests/gold_tests/tls_hooks/tls_hooks10.test.py b/tests/gold_tests/tls_hooks/tls_hooks10.test.py
index 7bdd6c5b3ab..8d79d802794 100644
--- a/tests/gold_tests/tls_hooks/tls_hooks10.test.py
+++ b/tests/gold_tests/tls_hooks/tls_hooks10.test.py
@@ -33,6 +33,7 @@
 ts.addDefaultSSLFiles()
 
 ts.Disk.records_config.update({'proxy.config.diags.debug.enabled': 1,
+                               'proxy.config.diags.show_location': 0,
                                'proxy.config.diags.debug.tags': 'ssl_hook_test',
                                'proxy.config.ssl.server.cert.path': '{0}'.format(ts.Variables.SSLDir),
                                'proxy.config.ssl.server.private_key.path': '{0}'.format(ts.Variables.SSLDir),
diff --git a/tests/gold_tests/tls_hooks/tls_hooks11.test.py b/tests/gold_tests/tls_hooks/tls_hooks11.test.py
index 596d8b95e02..c737fb9fd99 100644
--- a/tests/gold_tests/tls_hooks/tls_hooks11.test.py
+++ b/tests/gold_tests/tls_hooks/tls_hooks11.test.py
@@ -34,6 +34,7 @@
 ts.addDefaultSSLFiles()
 
 ts.Disk.records_config.update({'proxy.config.diags.debug.enabled': 1,
+                               'proxy.config.diags.show_location': 0,
                                'proxy.config.diags.debug.tags': 'ssl_hook_test',
                                'proxy.config.ssl.server.cert.path': '{0}'.format(ts.Variables.SSLDir),
                                'proxy.config.ssl.server.private_key.path': '{0}'.format(ts.Variables.SSLDir),
diff --git a/tests/gold_tests/tls_hooks/tls_hooks12.test.py b/tests/gold_tests/tls_hooks/tls_hooks12.test.py
index 2cdf6bb4242..f4f10340d01 100644
--- a/tests/gold_tests/tls_hooks/tls_hooks12.test.py
+++ b/tests/gold_tests/tls_hooks/tls_hooks12.test.py
@@ -33,6 +33,7 @@
 ts.addDefaultSSLFiles()
 
 ts.Disk.records_config.update({'proxy.config.diags.debug.enabled': 1,
+                               'proxy.config.diags.show_location': 0,
                                'proxy.config.diags.debug.tags': 'ssl_hook_test',
                                'proxy.config.ssl.server.cert.path': '{0}'.format(ts.Variables.SSLDir),
                                'proxy.config.ssl.server.private_key.path': '{0}'.format(ts.Variables.SSLDir),
diff --git a/tests/gold_tests/tls_hooks/tls_hooks13.test.py b/tests/gold_tests/tls_hooks/tls_hooks13.test.py
index c3d2ef76149..66efcc8c07e 100644
--- a/tests/gold_tests/tls_hooks/tls_hooks13.test.py
+++ b/tests/gold_tests/tls_hooks/tls_hooks13.test.py
@@ -33,6 +33,7 @@
 ts.addDefaultSSLFiles()
 
 ts.Disk.records_config.update({'proxy.config.diags.debug.enabled': 1,
+                               'proxy.config.diags.show_location': 0,
                                'proxy.config.diags.debug.tags': 'ssl_hook_test',
                                'proxy.config.ssl.server.cert.path': '{0}'.format(ts.Variables.SSLDir),
                                'proxy.config.ssl.server.private_key.path': '{0}'.format(ts.Variables.SSLDir),
diff --git a/tests/gold_tests/tls_hooks/tls_hooks14.test.py b/tests/gold_tests/tls_hooks/tls_hooks14.test.py
index 446a861cb7f..1c9d394ec36 100644
--- a/tests/gold_tests/tls_hooks/tls_hooks14.test.py
+++ b/tests/gold_tests/tls_hooks/tls_hooks14.test.py
@@ -33,6 +33,7 @@
 ts.addDefaultSSLFiles()
 
 ts.Disk.records_config.update({'proxy.config.diags.debug.enabled': 1,
+                               'proxy.config.diags.show_location': 0,
                                'proxy.config.diags.debug.tags': 'ssl_hook_test',
                                'proxy.config.ssl.server.cert.path': '{0}'.format(ts.Variables.SSLDir),
                                'proxy.config.ssl.server.private_key.path': '{0}'.format(ts.Variables.SSLDir),
diff --git a/tests/gold_tests/tls_hooks/tls_hooks15.test.py b/tests/gold_tests/tls_hooks/tls_hooks15.test.py
index 55fdb1ea400..e973e374e3e 100644
--- a/tests/gold_tests/tls_hooks/tls_hooks15.test.py
+++ b/tests/gold_tests/tls_hooks/tls_hooks15.test.py
@@ -33,6 +33,7 @@
 ts.addDefaultSSLFiles()
 
 ts.Disk.records_config.update({'proxy.config.diags.debug.enabled': 1,
+                               'proxy.config.diags.show_location': 0,
                                'proxy.config.diags.debug.tags': 'ssl_hook_test',
                                'proxy.config.ssl.server.cert.path': '{0}'.format(ts.Variables.SSLDir),
                                'proxy.config.ssl.server.private_key.path': '{0}'.format(ts.Variables.SSLDir),
diff --git a/tests/gold_tests/tls_hooks/tls_hooks16.test.py b/tests/gold_tests/tls_hooks/tls_hooks16.test.py
index 92e925411db..58da26def94 100644
--- a/tests/gold_tests/tls_hooks/tls_hooks16.test.py
+++ b/tests/gold_tests/tls_hooks/tls_hooks16.test.py
@@ -38,6 +38,7 @@
 ts.addDefaultSSLFiles()
 
 ts.Disk.records_config.update({'proxy.config.diags.debug.enabled': 1,
+                               'proxy.config.diags.show_location': 0,
                                'proxy.config.diags.debug.tags': 'ssl_hook_test',
                                'proxy.config.ssl.server.cert.path': '{0}'.format(ts.Variables.SSLDir),
                                'proxy.config.ssl.server.private_key.path': '{0}'.format(ts.Variables.SSLDir),
diff --git a/tests/gold_tests/tls_hooks/tls_hooks17.test.py b/tests/gold_tests/tls_hooks/tls_hooks17.test.py
index 98fb6dd85c5..90af83621d7 100644
--- a/tests/gold_tests/tls_hooks/tls_hooks17.test.py
+++ b/tests/gold_tests/tls_hooks/tls_hooks17.test.py
@@ -38,6 +38,7 @@
 ts.addDefaultSSLFiles()
 
 ts.Disk.records_config.update({'proxy.config.diags.debug.enabled': 1,
+                               'proxy.config.diags.show_location': 0,
                                'proxy.config.diags.debug.tags': 'ssl_hook_test',
                                'proxy.config.ssl.server.cert.path': '{0}'.format(ts.Variables.SSLDir),
                                'proxy.config.ssl.server.private_key.path': '{0}'.format(ts.Variables.SSLDir),
diff --git a/tests/gold_tests/tls_hooks/tls_hooks18.test.py b/tests/gold_tests/tls_hooks/tls_hooks18.test.py
index d3c7d588068..38fb889b8d9 100644
--- a/tests/gold_tests/tls_hooks/tls_hooks18.test.py
+++ b/tests/gold_tests/tls_hooks/tls_hooks18.test.py
@@ -38,6 +38,7 @@
 ts.addDefaultSSLFiles()
 
 ts.Disk.records_config.update({'proxy.config.diags.debug.enabled': 1,
+                               'proxy.config.diags.show_location': 0,
                                'proxy.config.diags.debug.tags': 'ssl_hook_test',
                                'proxy.config.ssl.server.cert.path': '{0}'.format(ts.Variables.SSLDir),
                                'proxy.config.ssl.server.private_key.path': '{0}'.format(ts.Variables.SSLDir),
diff --git a/tests/gold_tests/tls_hooks/tls_hooks2.test.py b/tests/gold_tests/tls_hooks/tls_hooks2.test.py
index 2bbe917c293..f4c15d43280 100644
--- a/tests/gold_tests/tls_hooks/tls_hooks2.test.py
+++ b/tests/gold_tests/tls_hooks/tls_hooks2.test.py
@@ -34,6 +34,7 @@
 ts.addDefaultSSLFiles()
 
 ts.Disk.records_config.update({'proxy.config.diags.debug.enabled': 1,
+                               'proxy.config.diags.show_location': 0,
                                'proxy.config.diags.debug.tags': 'ssl_hook_test',
                                'proxy.config.ssl.server.cert.path': '{0}'.format(ts.Variables.SSLDir),
                                'proxy.config.ssl.server.private_key.path': '{0}'.format(ts.Variables.SSLDir),
diff --git a/tests/gold_tests/tls_hooks/tls_hooks3.test.py b/tests/gold_tests/tls_hooks/tls_hooks3.test.py
index c6c89e089d5..b4ae7c508a3 100644
--- a/tests/gold_tests/tls_hooks/tls_hooks3.test.py
+++ b/tests/gold_tests/tls_hooks/tls_hooks3.test.py
@@ -34,6 +34,7 @@
 ts.addDefaultSSLFiles()
 
 ts.Disk.records_config.update({'proxy.config.diags.debug.enabled': 1,
+                               'proxy.config.diags.show_location': 0,
                                'proxy.config.diags.debug.tags': 'ssl_hook_test',
                                'proxy.config.ssl.server.cert.path': '{0}'.format(ts.Variables.SSLDir),
                                'proxy.config.ssl.server.private_key.path': '{0}'.format(ts.Variables.SSLDir),
diff --git a/tests/gold_tests/tls_hooks/tls_hooks4.test.py b/tests/gold_tests/tls_hooks/tls_hooks4.test.py
index b1be3add7fa..eb01c67dfb2 100644
--- a/tests/gold_tests/tls_hooks/tls_hooks4.test.py
+++ b/tests/gold_tests/tls_hooks/tls_hooks4.test.py
@@ -34,6 +34,7 @@
 ts.addDefaultSSLFiles()
 
 ts.Disk.records_config.update({'proxy.config.diags.debug.enabled': 1,
+                               'proxy.config.diags.show_location': 0,
                                'proxy.config.diags.debug.tags': 'ssl_hook_test',
                                'proxy.config.ssl.server.cert.path': '{0}'.format(ts.Variables.SSLDir),
                                'proxy.config.ssl.server.private_key.path': '{0}'.format(ts.Variables.SSLDir),
diff --git a/tests/gold_tests/tls_hooks/tls_hooks6.test.py b/tests/gold_tests/tls_hooks/tls_hooks6.test.py
index 8dece265892..81844e8be12 100644
--- a/tests/gold_tests/tls_hooks/tls_hooks6.test.py
+++ b/tests/gold_tests/tls_hooks/tls_hooks6.test.py
@@ -34,6 +34,7 @@
 ts.addDefaultSSLFiles()
 
 ts.Disk.records_config.update({'proxy.config.diags.debug.enabled': 1,
+                               'proxy.config.diags.show_location': 0,
                                'proxy.config.diags.debug.tags': 'ssl_hook_test',
                                'proxy.config.ssl.server.cert.path': '{0}'.format(ts.Variables.SSLDir),
                                'proxy.config.ssl.server.private_key.path': '{0}'.format(ts.Variables.SSLDir),
diff --git a/tests/gold_tests/tls_hooks/tls_hooks7.test.py b/tests/gold_tests/tls_hooks/tls_hooks7.test.py
index 52a55a164af..89e48aac220 100644
--- a/tests/gold_tests/tls_hooks/tls_hooks7.test.py
+++ b/tests/gold_tests/tls_hooks/tls_hooks7.test.py
@@ -34,6 +34,7 @@
 ts.addDefaultSSLFiles()
 
 ts.Disk.records_config.update({'proxy.config.diags.debug.enabled': 1,
+                               'proxy.config.diags.show_location': 0,
                                'proxy.config.diags.debug.tags': 'ssl_hook_test',
                                'proxy.config.ssl.server.cert.path': '{0}'.format(ts.Variables.SSLDir),
                                'proxy.config.ssl.server.private_key.path': '{0}'.format(ts.Variables.SSLDir),
diff --git a/tests/gold_tests/tls_hooks/tls_hooks8.test.py b/tests/gold_tests/tls_hooks/tls_hooks8.test.py
index 19db5b62d58..2f2698569ee 100644
--- a/tests/gold_tests/tls_hooks/tls_hooks8.test.py
+++ b/tests/gold_tests/tls_hooks/tls_hooks8.test.py
@@ -34,6 +34,7 @@
 ts.addDefaultSSLFiles()
 
 ts.Disk.records_config.update({'proxy.config.diags.debug.enabled': 1,
+                               'proxy.config.diags.show_location': 0,
                                'proxy.config.diags.debug.tags': 'ssl_hook_test',
                                'proxy.config.ssl.server.cert.path': '{0}'.format(ts.Variables.SSLDir),
                                'proxy.config.ssl.server.private_key.path': '{0}'.format(ts.Variables.SSLDir),
diff --git a/tests/gold_tests/tls_hooks/tls_hooks9.test.py b/tests/gold_tests/tls_hooks/tls_hooks9.test.py
index 4ab72467b39..684a993e2bd 100644
--- a/tests/gold_tests/tls_hooks/tls_hooks9.test.py
+++ b/tests/gold_tests/tls_hooks/tls_hooks9.test.py
@@ -34,6 +34,7 @@
 ts.addDefaultSSLFiles()
 
 ts.Disk.records_config.update({'proxy.config.diags.debug.enabled': 1,
+                               'proxy.config.diags.show_location': 0,
                                'proxy.config.diags.debug.tags': 'ssl_hook_test',
                                'proxy.config.ssl.server.cert.path': '{0}'.format(ts.Variables.SSLDir),
                                'proxy.config.ssl.server.private_key.path': '{0}'.format(ts.Variables.SSLDir),
diff --git a/tests/tools/plugins/cert_update.cc b/tests/tools/plugins/cert_update.cc
index 115f4ce7729..338815b0fa0 100644
--- a/tests/tools/plugins/cert_update.cc
+++ b/tests/tools/plugins/cert_update.cc
@@ -31,6 +31,11 @@
 
 #define PLUGIN_NAME "cert_update"
 
+namespace
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 // Plugin Message Continuation
 int
 CB_cert_update(TSCont, TSEvent, void *edata)
@@ -45,25 +50,25 @@ CB_cert_update(TSCont, TSEvent, void *edata)
     tag.remove_prefix(PLUGIN_PREFIX.size());
     if (tag == "server") {
       server_cert_path = static_cast<const char *>(msg->data);
-      TSDebug(PLUGIN_NAME, "Received Msg to update server cert with %s", server_cert_path);
+      Dbg(dbg_ctl, "Received Msg to update server cert with %s", server_cert_path);
     } else if (tag == "client") {
       client_cert_path = static_cast<const char *>(msg->data);
-      TSDebug(PLUGIN_NAME, "Received Msg to update client cert with %s", client_cert_path);
+      Dbg(dbg_ctl, "Received Msg to update client cert with %s", client_cert_path);
     }
   }
 
   if (server_cert_path) {
     if (TS_SUCCESS == TSSslServerCertUpdate(server_cert_path, nullptr)) {
-      TSDebug(PLUGIN_NAME, "Successfully updated server cert with %s", server_cert_path);
+      Dbg(dbg_ctl, "Successfully updated server cert with %s", server_cert_path);
     } else {
-      TSDebug(PLUGIN_NAME, "Failed to update server cert with %s", server_cert_path);
+      Dbg(dbg_ctl, "Failed to update server cert with %s", server_cert_path);
     }
   }
   if (client_cert_path) {
     if (TS_SUCCESS == TSSslClientCertUpdate(client_cert_path, nullptr)) {
-      TSDebug(PLUGIN_NAME, "Successfully updated client cert with %s", client_cert_path);
+      Dbg(dbg_ctl, "Successfully updated client cert with %s", client_cert_path);
     } else {
-      TSDebug(PLUGIN_NAME, "Failed to update client cert with %s", client_cert_path);
+      Dbg(dbg_ctl, "Failed to update client cert with %s", client_cert_path);
     }
   }
   return TS_SUCCESS;
@@ -81,6 +86,6 @@ TSPluginInit(int argc, const char *argv[])
   if (TSPluginRegister(&info) != TS_SUCCESS) {
     TSError("[%s] Plugin registration failed", PLUGIN_NAME);
   }
-  TSDebug(PLUGIN_NAME, "Initialized.");
+  Dbg(dbg_ctl, "Initialized.");
   TSLifecycleHookAdd(TS_LIFECYCLE_MSG_HOOK, TSContCreate(CB_cert_update, nullptr));
 }
diff --git a/tests/tools/plugins/cont_schedule.cc b/tests/tools/plugins/cont_schedule.cc
index 46553b856ac..04f28689b73 100644
--- a/tests/tools/plugins/cont_schedule.cc
+++ b/tests/tools/plugins/cont_schedule.cc
@@ -29,6 +29,11 @@ static const char DEBUG_TAG_SCHD[] = "TSContSchedule_test.schedule";
 static const char DEBUG_TAG_HDL[]  = "TSContSchedule_test.handler";
 static const char DEBUG_TAG_CHK[]  = "TSContSchedule_test.check";
 
+static DbgCtl dbg_ctl_init{DEBUG_TAG_INIT};
+static DbgCtl dbg_ctl_schd{DEBUG_TAG_SCHD};
+static DbgCtl dbg_ctl_hdl{DEBUG_TAG_HDL};
+static DbgCtl dbg_ctl_chk{DEBUG_TAG_CHK};
+
 // plugin registration info
 static char plugin_name[]   = "TSContSchedule_test";
 static char vendor_name[]   = "apache";
@@ -52,16 +57,16 @@ static int
 TSContScheduleOnPool_handler_1(TSCont contp, TSEvent event, void *edata)
 {
   // This runs on ET_NET threads.
-  TSDebug(DEBUG_TAG_HDL, "TSContScheduleOnPool handler 1 thread [%p]", TSThreadSelf());
+  Dbg(dbg_ctl_hdl, "TSContScheduleOnPool handler 1 thread [%p]", TSThreadSelf());
   if (thread_1 == nullptr) {
     // First time here, record thread id.
     thread_1 = TSEventThreadSelf();
   } else {
     // Second time here, we should be on a different thread since affinity was cleared.
     if (thread_1 != TSEventThreadSelf()) {
-      TSDebug(DEBUG_TAG_CHK, "pass [should not be the same thread]");
+      Dbg(dbg_ctl_chk, "pass [should not be the same thread]");
     } else {
-      TSDebug(DEBUG_TAG_CHK, "fail [on the same thread]");
+      Dbg(dbg_ctl_chk, "fail [on the same thread]");
     }
   }
   return 0;
@@ -71,7 +76,7 @@ static int
 TSContScheduleOnPool_handler_2(TSCont contp, TSEvent event, void *edata)
 {
   // This runs on ET_TASK threads.
-  TSDebug(DEBUG_TAG_HDL, "TSContScheduleOnPool handler 2 thread [%p]", TSThreadSelf());
+  Dbg(dbg_ctl_hdl, "TSContScheduleOnPool handler 2 thread [%p]", TSThreadSelf());
   if (thread_2 == nullptr) {
     // First time here, record thread id.
     thread_2 = TSEventThreadSelf();
@@ -80,9 +85,9 @@ TSContScheduleOnPool_handler_2(TSCont contp, TSEvent event, void *edata)
       // Second time there, we should be on the same thread even though affinity was cleared,
       // reason being plugin is running on ET_TASK threads, and we were scheduled on ET_TASK
       // threads as well, so the thread the plugin is on is used and set to affinity.
-      TSDebug(DEBUG_TAG_CHK, "pass [should be the same thread]");
+      Dbg(dbg_ctl_chk, "pass [should be the same thread]");
     } else {
-      TSDebug(DEBUG_TAG_CHK, "fail [not the same thread]");
+      Dbg(dbg_ctl_chk, "fail [not the same thread]");
     }
   }
   return 0;
@@ -95,10 +100,10 @@ TSContScheduleOnPool_test()
   contp_2 = TSContCreate(TSContScheduleOnPool_handler_2, TSMutexCreate());
 
   if (contp_1 == nullptr || contp_2 == nullptr) {
-    TSDebug(DEBUG_TAG_SCHD, "[%s] could not create continuation", plugin_name);
+    Dbg(dbg_ctl_schd, "[%s] could not create continuation", plugin_name);
     abort();
   } else {
-    TSDebug(DEBUG_TAG_SCHD, "[%s] scheduling continuation", plugin_name);
+    Dbg(dbg_ctl_schd, "[%s] scheduling continuation", plugin_name);
 
     TSContScheduleOnPool(contp_1, 0, TS_THREAD_POOL_NET);
     TSContThreadAffinityClear(contp_1);
@@ -115,20 +120,20 @@ TSContScheduleOnThread_handler_1(TSCont contp, TSEvent event, void *edata)
 {
   // Mostly same as TSContScheduleOnPool_handler_1, no need to set affinity
   // since we are scheduling directly on to a thread.
-  TSDebug(DEBUG_TAG_HDL, "TSContScheduleOnThread handler 1 thread [%p]", TSThreadSelf());
+  Dbg(dbg_ctl_hdl, "TSContScheduleOnThread handler 1 thread [%p]", TSThreadSelf());
   if (thread_1 == nullptr) {
     thread_1 = TSEventThreadSelf();
 
-    TSDebug(DEBUG_TAG_HDL, "[%s] scheduling continuation", plugin_name);
+    Dbg(dbg_ctl_hdl, "[%s] scheduling continuation", plugin_name);
     TSContScheduleOnThread(contp_2, 0, thread_1);
     TSContScheduleOnThread(contp_2, 0, thread_1);
   } else if (thread_2 == nullptr) {
-    TSDebug(DEBUG_TAG_CHK, "fail [schedule delay not applied]");
+    Dbg(dbg_ctl_chk, "fail [schedule delay not applied]");
   } else {
     if (thread_2 != TSEventThreadSelf()) {
-      TSDebug(DEBUG_TAG_CHK, "pass [should not be the same thread]");
+      Dbg(dbg_ctl_chk, "pass [should not be the same thread]");
     } else {
-      TSDebug(DEBUG_TAG_CHK, "fail [on the same thread]");
+      Dbg(dbg_ctl_chk, "fail [on the same thread]");
     }
   }
   return 0;
@@ -137,13 +142,13 @@ TSContScheduleOnThread_handler_1(TSCont contp, TSEvent event, void *edata)
 static int
 TSContScheduleOnThread_handler_2(TSCont contp, TSEvent event, void *edata)
 {
-  TSDebug(DEBUG_TAG_HDL, "TSContScheduleOnThread handler 2 thread [%p]", TSThreadSelf());
+  Dbg(dbg_ctl_hdl, "TSContScheduleOnThread handler 2 thread [%p]", TSThreadSelf());
   if (thread_2 == nullptr) {
     thread_2 = TSEventThreadSelf();
   } else if (thread_2 == TSEventThreadSelf()) {
-    TSDebug(DEBUG_TAG_CHK, "pass [should be the same thread]");
+    Dbg(dbg_ctl_chk, "pass [should be the same thread]");
   } else {
-    TSDebug(DEBUG_TAG_CHK, "fail [not the same thread]");
+    Dbg(dbg_ctl_chk, "fail [not the same thread]");
   }
   return 0;
 }
@@ -155,10 +160,10 @@ TSContScheduleOnThread_test()
   contp_2 = TSContCreate(TSContScheduleOnThread_handler_2, TSMutexCreate());
 
   if (contp_1 == nullptr || contp_2 == nullptr) {
-    TSDebug(DEBUG_TAG_SCHD, "[%s] could not create continuation", plugin_name);
+    Dbg(dbg_ctl_schd, "[%s] could not create continuation", plugin_name);
     abort();
   } else {
-    TSDebug(DEBUG_TAG_SCHD, "[%s] scheduling continuation", plugin_name);
+    Dbg(dbg_ctl_schd, "[%s] scheduling continuation", plugin_name);
     TSContScheduleOnPool(contp_1, 0, TS_THREAD_POOL_NET);
     TSContThreadAffinityClear(contp_1);
     TSContScheduleOnPool(contp_1, 200, TS_THREAD_POOL_NET);
@@ -168,26 +173,26 @@ TSContScheduleOnThread_test()
 static int
 TSContThreadAffinity_handler(TSCont contp, TSEvent event, void *edata)
 {
-  TSDebug(DEBUG_TAG_HDL, "TSContThreadAffinity handler thread [%p]", TSThreadSelf());
+  Dbg(dbg_ctl_hdl, "TSContThreadAffinity handler thread [%p]", TSThreadSelf());
 
   thread_1 = TSEventThreadSelf();
 
   if (TSContThreadAffinityGet(contp) != nullptr) {
-    TSDebug(DEBUG_TAG_CHK, "pass [affinity thread is not null]");
+    Dbg(dbg_ctl_chk, "pass [affinity thread is not null]");
     TSContThreadAffinityClear(contp);
     if (TSContThreadAffinityGet(contp) == nullptr) {
-      TSDebug(DEBUG_TAG_CHK, "pass [affinity thread is cleared]");
+      Dbg(dbg_ctl_chk, "pass [affinity thread is cleared]");
       TSContThreadAffinitySet(contp, TSEventThreadSelf());
       if (TSContThreadAffinityGet(contp) == thread_1) {
-        TSDebug(DEBUG_TAG_CHK, "pass [affinity thread is set]");
+        Dbg(dbg_ctl_chk, "pass [affinity thread is set]");
       } else {
-        TSDebug(DEBUG_TAG_CHK, "fail [affinity thread is not set]");
+        Dbg(dbg_ctl_chk, "fail [affinity thread is not set]");
       }
     } else {
-      TSDebug(DEBUG_TAG_CHK, "fail [affinity thread is not cleared]");
+      Dbg(dbg_ctl_chk, "fail [affinity thread is not cleared]");
     }
   } else {
-    TSDebug(DEBUG_TAG_CHK, "fail [affinity thread is null]");
+    Dbg(dbg_ctl_chk, "fail [affinity thread is null]");
   }
 
   return 0;
@@ -199,10 +204,10 @@ TSContThreadAffinity_test()
   TSCont contp = TSContCreate(TSContThreadAffinity_handler, TSMutexCreate());
 
   if (contp == nullptr) {
-    TSDebug(DEBUG_TAG_SCHD, "[%s] could not create continuation", plugin_name);
+    Dbg(dbg_ctl_schd, "[%s] could not create continuation", plugin_name);
     abort();
   } else {
-    TSDebug(DEBUG_TAG_SCHD, "[%s] scheduling continuation", plugin_name);
+    Dbg(dbg_ctl_schd, "[%s] scheduling continuation", plugin_name);
     TSContScheduleOnPool(contp, 0, TS_THREAD_POOL_NET);
   }
 }
@@ -234,13 +239,13 @@ TSPluginInit(int argc, const char *argv[])
   if (argc == 2) {
     int len = strlen(argv[1]);
     if (len == 4 && strncmp(argv[1], "pool", 4) == 0) {
-      TSDebug(DEBUG_TAG_INIT, "initializing plugin for testing TSContScheduleOnPool");
+      Dbg(dbg_ctl_init, "initializing plugin for testing TSContScheduleOnPool");
       test_flag = 1;
     } else if (len == 6 && strncmp(argv[1], "thread", 6) == 0) {
-      TSDebug(DEBUG_TAG_INIT, "initializing plugin for testing TSContScheduleOnThread");
+      Dbg(dbg_ctl_init, "initializing plugin for testing TSContScheduleOnThread");
       test_flag = 2;
     } else if (len == 8 && strncmp(argv[1], "affinity", 8) == 0) {
-      TSDebug(DEBUG_TAG_INIT, "initializing plugin for testing TSContThreadAffinity");
+      Dbg(dbg_ctl_init, "initializing plugin for testing TSContThreadAffinity");
       test_flag = 3;
     } else {
       goto Lerror;
@@ -256,7 +261,7 @@ TSPluginInit(int argc, const char *argv[])
   info.support_email = support_email;
 
   if (TSPluginRegister(&info) != TS_SUCCESS) {
-    TSDebug(DEBUG_TAG_INIT, "[%s] plugin registration failed", plugin_name);
+    Dbg(dbg_ctl_init, "[%s] plugin registration failed", plugin_name);
     abort();
   }
 
@@ -265,6 +270,6 @@ TSPluginInit(int argc, const char *argv[])
   return;
 
 Lerror:
-  TSDebug(DEBUG_TAG_INIT, "[%s] plugin invalid argument", plugin_name);
+  Dbg(dbg_ctl_init, "[%s] plugin invalid argument", plugin_name);
   abort();
 }
diff --git a/tests/tools/plugins/continuations_verify.cc b/tests/tools/plugins/continuations_verify.cc
index c88a0ac881e..4bd726f8ca2 100644
--- a/tests/tools/plugins/continuations_verify.cc
+++ b/tests/tools/plugins/continuations_verify.cc
@@ -34,6 +34,10 @@ static const char DEBUG_TAG_INIT[] = "continuations_verify.init";
 static const char DEBUG_TAG_MSG[]  = "continuations_verify.msg";
 static const char DEBUG_TAG_HOOK[] = "continuations_verify.hook";
 
+static DbgCtl dbg_ctl_init{DEBUG_TAG_INIT};
+static DbgCtl dbg_ctl_msg{DEBUG_TAG_MSG};
+static DbgCtl dbg_ctl_hook{DEBUG_TAG_HOOK};
+
 // plugin registration info
 static char plugin_name[]   = "continuations_verify";
 static char vendor_name[]   = "apache";
@@ -50,7 +54,7 @@ static int
 handle_msg(TSCont contp, TSEvent event, void *edata)
 {
   if (event == TS_EVENT_LIFECYCLE_MSG) { // External trigger, such as traffic_ctl
-    TSDebug(DEBUG_TAG_MSG, "event TS_EVENT_LIFECYCLE_MSG");
+    Dbg(dbg_ctl_msg, "event TS_EVENT_LIFECYCLE_MSG");
     // Send to a ET net thread just to be sure.
     // Turns out the msg is sent to a task thread, but task
     // threads do not get their thread local copy of the stats
@@ -58,7 +62,7 @@ handle_msg(TSCont contp, TSEvent event, void *edata)
     // the Schedule to a NET thread
     TSContScheduleOnPool(contp, 0, TS_THREAD_POOL_NET);
   } else {
-    TSDebug(DEBUG_TAG_MSG, "event %d", event);
+    Dbg(dbg_ctl_msg, "event %d", event);
     TSStatIntIncrement(stat_test_done, 1);
   }
   return 0;
@@ -75,7 +79,7 @@ handle_order_1(TSCont contp, TSEvent event, void *edata)
   TSHttpSsn ssnp; // session data
   TSHttpTxn txnp; // transaction data
 
-  TSDebug(DEBUG_TAG_HOOK, "order_1 event %d", event);
+  Dbg(dbg_ctl_hook, "order_1 event %d", event);
 
   // Find the event that happened
   switch (event) {
@@ -105,7 +109,7 @@ handle_order_2(TSCont contp, TSEvent event, void *edata)
   TSHttpSsn ssnp; // session data
   TSHttpTxn txnp; // transaction data
 
-  TSDebug(DEBUG_TAG_HOOK, "order_2 event %d", event);
+  Dbg(dbg_ctl_hook, "order_2 event %d", event);
 
   // Find the event that happened
   switch (event) {
@@ -139,7 +143,7 @@ handle_order_2(TSCont contp, TSEvent event, void *edata)
 void
 TSPluginInit(int argc, const char *argv[])
 {
-  TSDebug(DEBUG_TAG_INIT, "initializing plugin");
+  Dbg(dbg_ctl_init, "initializing plugin");
 
   TSPluginRegistrationInfo info;
 
diff --git a/tests/tools/plugins/custom204plugin.cc b/tests/tools/plugins/custom204plugin.cc
index dc52dd7569a..57c279e52b1 100644
--- a/tests/tools/plugins/custom204plugin.cc
+++ b/tests/tools/plugins/custom204plugin.cc
@@ -26,6 +26,11 @@
 
 #define PLUGIN_NAME "custom204plugintest"
 
+namespace
+{
+DbgCtl dbg_ctl{PLUGIN_NAME};
+}
+
 static int
 local_handler(TSCont contp, TSEvent event, void *edata)
 {
@@ -53,51 +58,51 @@ local_handler(TSCont contp, TSEvent event, void *edata)
 
   switch (event) {
   case TS_EVENT_HTTP_PRE_REMAP:
-    TSDebug(PLUGIN_NAME, "event TS_EVENT_HTTP_PRE_REMAP received");
-    TSDebug(PLUGIN_NAME, "running plugin logic.");
+    Dbg(dbg_ctl, "event TS_EVENT_HTTP_PRE_REMAP received");
+    Dbg(dbg_ctl, "running plugin logic.");
     if (TSHttpTxnClientReqGet(txnp, &bufp, &hdr_loc) != TS_SUCCESS) {
-      TSDebug(PLUGIN_NAME, "Couldn't retrieve client request header");
+      Dbg(dbg_ctl, "Couldn't retrieve client request header");
       TSError("[%s] Couldn't retrieve client request header", PLUGIN_NAME);
       goto done;
     }
-    TSDebug(PLUGIN_NAME, "got client request");
+    Dbg(dbg_ctl, "got client request");
 
     if (TSHttpHdrUrlGet(bufp, hdr_loc, &url_loc) != TS_SUCCESS) {
       TSError("[%s] Couldn't retrieve request url", PLUGIN_NAME);
-      TSDebug(PLUGIN_NAME, "Couldn't retrieve request url");
+      Dbg(dbg_ctl, "Couldn't retrieve request url");
       TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
       goto done;
     }
-    TSDebug(PLUGIN_NAME, "got client request url");
+    Dbg(dbg_ctl, "got client request url");
 
     host = TSUrlHostGet(bufp, url_loc, &host_length);
     if (!host) {
       TSError("[%s] Couldn't retrieve request hostname", PLUGIN_NAME);
-      TSDebug(PLUGIN_NAME, "Couldn't retrieve request hostname");
+      Dbg(dbg_ctl, "Couldn't retrieve request hostname");
       TSHandleMLocRelease(bufp, hdr_loc, url_loc);
       TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
       goto done;
     }
-    TSDebug(PLUGIN_NAME, "request's host was retrieved");
+    Dbg(dbg_ctl, "request's host was retrieved");
 
     if (strncmp(host, test_host, strlen(test_host)) == 0) {
-      TSDebug(PLUGIN_NAME, "host matches, hook TS_HTTP_SEND_RESPONSE_HDR_HOOK");
+      Dbg(dbg_ctl, "host matches, hook TS_HTTP_SEND_RESPONSE_HDR_HOOK");
       TSHttpTxnHookAdd(txnp, TS_HTTP_SEND_RESPONSE_HDR_HOOK, contp);
       TSHandleMLocRelease(bufp, hdr_loc, url_loc);
       TSHandleMLocRelease(bufp, TS_NULL_MLOC, hdr_loc);
       TSHttpTxnReenable(txnp, TS_EVENT_HTTP_CONTINUE);
       return 0;
     }
-    TSDebug(PLUGIN_NAME, "Host != expected host '%s'", test_host);
+    Dbg(dbg_ctl, "Host != expected host '%s'", test_host);
     break;
   case TS_EVENT_HTTP_SEND_RESPONSE_HDR:
-    TSDebug(PLUGIN_NAME, "Returning 204 with custom response body.");
+    Dbg(dbg_ctl, "Returning 204 with custom response body.");
     TSHttpTxnStatusSet(txnp, TS_HTTP_STATUS_NO_CONTENT);
     TSHttpTxnErrorBodySet(txnp, TSstrdup(msg), strlen(msg), TSstrdup("text/html"));
     break;
 
   case TS_EVENT_HTTP_TXN_CLOSE:
-    TSDebug(PLUGIN_NAME, "event TS_EVENT_HTTP_TXN_CLOSE received");
+    Dbg(dbg_ctl, "event TS_EVENT_HTTP_TXN_CLOSE received");
     TSContDestroy(contp);
     break;
 
@@ -124,7 +129,7 @@ global_handler(TSCont contp, TSEvent event, void *edata)
     txn_contp = TSContCreate(local_handler, TSMutexCreate());
     TSHttpTxnHookAdd(txnp, TS_HTTP_PRE_REMAP_HOOK, txn_contp);
     TSHttpTxnHookAdd(txnp, TS_HTTP_TXN_CLOSE_HOOK, txn_contp);
-    TSDebug(PLUGIN_NAME, "hooked TS_HTTP_OS_DNS_HOOK and TS_EVENT_HTTP_TXN_CLOSE_HOOK");
+    Dbg(dbg_ctl, "hooked TS_HTTP_OS_DNS_HOOK and TS_EVENT_HTTP_TXN_CLOSE_HOOK");
     break;
   default:
     TSAssert(!"Unexpected event");
diff --git a/tests/tools/plugins/emergency_shutdown.cc b/tests/tools/plugins/emergency_shutdown.cc
index ce8eab602d6..296cc56110e 100644
--- a/tests/tools/plugins/emergency_shutdown.cc
+++ b/tests/tools/plugins/emergency_shutdown.cc
@@ -25,6 +25,7 @@
 
 // debug messages during one-time initialization
 static const char DEBUG_TAG[] = "TSEmergency_test";
+static DbgCtl dbg_ctl{DEBUG_TAG};
 
 // plugin registration info
 static char plugin_name[]   = "TSEmergency_test";
@@ -34,7 +35,7 @@ static char support_email[] = "duke8253@apache.org";
 static int
 test_handler(TSCont contp, TSEvent event, void *edata)
 {
-  TSDebug(DEBUG_TAG, "failed to shutdown");
+  Dbg(dbg_ctl, "failed to shutdown");
   return 0;
 }
 
diff --git a/tests/tools/plugins/fatal_shutdown.cc b/tests/tools/plugins/fatal_shutdown.cc
index abfd90b5ad7..b33ea4ed96b 100644
--- a/tests/tools/plugins/fatal_shutdown.cc
+++ b/tests/tools/plugins/fatal_shutdown.cc
@@ -25,6 +25,7 @@
 
 // debug messages during one-time initialization
 static const char DEBUG_TAG[] = "TSFatal_test";
+static DbgCtl dbg_ctl{DEBUG_TAG};
 
 // plugin registration info
 static char plugin_name[]   = "TSFatal_test";
@@ -34,7 +35,7 @@ static char support_email[] = "duke8253@apache.org";
 static int
 test_handler(TSCont contp, TSEvent event, void *edata)
 {
-  TSDebug(DEBUG_TAG, "failed to shutdown");
+  Dbg(dbg_ctl, "failed to shutdown");
   return 0;
 }
 
diff --git a/tests/tools/plugins/hook_add_plugin.cc b/tests/tools/plugins/hook_add_plugin.cc
index b6a45784078..437696fab36 100644
--- a/tests/tools/plugins/hook_add_plugin.cc
+++ b/tests/tools/plugins/hook_add_plugin.cc
@@ -25,6 +25,11 @@
 
 #define PLUGIN_TAG "test"
 
+namespace
+{
+DbgCtl dbg_ctl{PLUGIN_TAG};
+}
+
 // Number of seconds to reschedule to a task thread and delay
 int DelayStart = 0;
 
@@ -40,11 +45,11 @@ transactionHandler(TSCont continuation, TSEvent event, void *d)
 
   switch (event) {
   case TS_EVENT_HTTP_PRE_REMAP: {
-    TSDebug(PLUGIN_TAG, " -- transactionHandler :: TS_EVENT_HTTP_PRE_REMAP");
+    Dbg(dbg_ctl, " -- transactionHandler :: TS_EVENT_HTTP_PRE_REMAP");
   } break;
 
   case TS_EVENT_HTTP_TXN_CLOSE:
-    TSDebug(PLUGIN_TAG, " -- transactionHandler :: TS_EVENT_HTTP_TXN_CLOSE");
+    Dbg(dbg_ctl, " -- transactionHandler :: TS_EVENT_HTTP_TXN_CLOSE");
     TSContDataSet(continuation, nullptr);
     TSContDestroy(continuation);
     break;
@@ -66,7 +71,7 @@ sessionHandler(TSCont continuation, TSEvent event, void *d)
 
   switch (event) {
   case TS_EVENT_HTTP_PRE_REMAP: {
-    TSDebug(PLUGIN_TAG, " -- sessionHandler :: TS_EVENT_HTTP_PRE_REMAP");
+    Dbg(dbg_ctl, " -- sessionHandler :: TS_EVENT_HTTP_PRE_REMAP");
     txn_contp = TSContCreate(transactionHandler, nullptr);
 
     /* Registers locally to hook PRE_REMAP_HOOK and TXN_CLOSE */
@@ -75,7 +80,7 @@ sessionHandler(TSCont continuation, TSEvent event, void *d)
   } break;
 
   case TS_EVENT_HTTP_SSN_CLOSE: {
-    TSDebug(PLUGIN_TAG, " -- sessionHandler :: TS_EVENT_HTTP_SSN_CLOSE");
+    Dbg(dbg_ctl, " -- sessionHandler :: TS_EVENT_HTTP_SSN_CLOSE");
     const TSHttpSsn session = static_cast<TSHttpSsn>(d);
 
     TSHttpSsnReenable(session, TS_EVENT_HTTP_CONTINUE);
@@ -84,7 +89,7 @@ sessionHandler(TSCont continuation, TSEvent event, void *d)
   } break;
 
   case TS_EVENT_TIMEOUT: { // The schedule case, reenable the session continuation
-    TSDebug(PLUGIN_TAG, " -- sessionHandler :: TS_EVENT_TIMEOUT");
+    Dbg(dbg_ctl, " -- sessionHandler :: TS_EVENT_TIMEOUT");
     TSHttpSsn session = static_cast<TSHttpSsn>(TSContDataGet(continuation));
     TSHttpSsnReenable(session, TS_EVENT_HTTP_CONTINUE);
     return 0;
@@ -103,13 +108,13 @@ globalHandler(TSCont continuation, TSEvent event, void *data)
 {
   if (event == TS_EVENT_HTTP_SSN_START) {
     TSHttpSsn session = static_cast<TSHttpSsn>(data);
-    TSDebug(PLUGIN_TAG, " -- globalHandler :: TS_EVENT_HTTP_SSN_START");
+    Dbg(dbg_ctl, " -- globalHandler :: TS_EVENT_HTTP_SSN_START");
     TSCont cont = TSContCreate(sessionHandler, TSMutexCreate());
 
     TSHttpSsnHookAdd(session, TS_HTTP_PRE_REMAP_HOOK, cont);
     TSHttpSsnHookAdd(session, TS_HTTP_SSN_CLOSE_HOOK, cont);
 
-    TSDebug(PLUGIN_TAG, "New session, cont is %p", cont);
+    Dbg(dbg_ctl, "New session, cont is %p", cont);
 
     if (DelayStart == 0) {
       TSHttpSsnReenable(session, TS_EVENT_HTTP_CONTINUE);
@@ -137,7 +142,7 @@ TSPluginInit(int argc, const char **argv)
   }
 
   if (argc >= 2) {
-    TSDebug(PLUGIN_TAG, "Argument %s", argv[1]);
+    Dbg(dbg_ctl, "Argument %s", argv[1]);
     if (strcmp(argv[1], "-delay") == 0) {
       DelayStart = 1;
     }
diff --git a/tests/tools/plugins/ssl_client_verify_test.cc b/tests/tools/plugins/ssl_client_verify_test.cc
index 8b64e520c61..d3fcbea34b1 100644
--- a/tests/tools/plugins/ssl_client_verify_test.cc
+++ b/tests/tools/plugins/ssl_client_verify_test.cc
@@ -38,6 +38,11 @@
 #define PN  "ssl_client_verify_test"
 #define PCP "[" PN " Plugin] "
 
+namespace
+{
+DbgCtl dbg_ctl{PN};
+}
+
 std::map<std::string, int> good_names;
 
 bool
@@ -125,8 +130,8 @@ CB_client_verify(TSCont cont, TSEvent event, void *edata)
     reenable_event = TS_EVENT_ERROR;
   }
 
-  TSDebug(PN, "Client verify callback %d %p - event is %s %s", count, ssl_vc, event == TS_EVENT_SSL_VERIFY_CLIENT ? "good" : "bad",
-          reenable_event == TS_EVENT_ERROR ? "error HS" : "good HS");
+  Dbg(dbg_ctl, "Client verify callback %d %p - event is %s %s", count, ssl_vc, event == TS_EVENT_SSL_VERIFY_CLIENT ? "good" : "bad",
+      reenable_event == TS_EVENT_ERROR ? "error HS" : "good HS");
 
   // All done, reactivate things
   TSVConnReenableEx(ssl_vc, reenable_event);
@@ -164,7 +169,7 @@ setup_callbacks(int count)
   TSCont cb = nullptr;
   int i;
 
-  TSDebug(PN, "Setup callbacks count=%d", count);
+  Dbg(dbg_ctl, "Setup callbacks count=%d", count);
   for (i = 0; i < count; i++) {
     cb = TSContCreate(&CB_client_verify, TSMutexCreate());
     TSContDataSet(cb, (void *)static_cast<intptr_t>(i));
diff --git a/tests/tools/plugins/ssl_hook_test.cc b/tests/tools/plugins/ssl_hook_test.cc
index e896cd1c2a4..425548a799e 100644
--- a/tests/tools/plugins/ssl_hook_test.cc
+++ b/tests/tools/plugins/ssl_hook_test.cc
@@ -35,6 +35,7 @@
 #define PN  "ssl_hook_test"
 #define PCP "[" PN " Plugin] "
 
+static DbgCtl dbg_ctl{PN};
 static bool was_conn_closed;
 
 int
@@ -46,7 +47,7 @@ ReenableSSL(TSCont cont, TSEvent event, void *edata)
   }
 
   TSVConn ssl_vc = reinterpret_cast<TSVConn>(TSContDataGet(cont));
-  TSDebug(PN, "Callback reenable ssl_vc=%p", ssl_vc);
+  Dbg(dbg_ctl, "Callback reenable ssl_vc=%p", ssl_vc);
   TSVConnReenable(ssl_vc);
   TSContDestroy(cont);
   return TS_SUCCESS;
@@ -59,7 +60,7 @@ CB_Pre_Accept(TSCont cont, TSEvent event, void *edata)
 
   int count = reinterpret_cast<intptr_t>(TSContDataGet(cont));
 
-  TSDebug(PN, "Pre accept callback %d %p - event is %s", count, ssl_vc, event == TS_EVENT_VCONN_START ? "good" : "bad");
+  Dbg(dbg_ctl, "Pre accept callback %d %p - event is %s", count, ssl_vc, event == TS_EVENT_VCONN_START ? "good" : "bad");
 
   // All done, reactivate things
   TSVConnReenable(ssl_vc);
@@ -73,7 +74,7 @@ CB_Pre_Accept_Delay(TSCont cont, TSEvent event, void *edata)
 
   int count = reinterpret_cast<intptr_t>(TSContDataGet(cont));
 
-  TSDebug(PN, "Pre accept delay callback %d %p - event is %s", count, ssl_vc, event == TS_EVENT_VCONN_START ? "good" : "bad");
+  Dbg(dbg_ctl, "Pre accept delay callback %d %p - event is %s", count, ssl_vc, event == TS_EVENT_VCONN_START ? "good" : "bad");
 
   TSCont cb = TSContCreate(&ReenableSSL, TSMutexCreate());
 
@@ -93,8 +94,8 @@ CB_out_start(TSCont cont, TSEvent event, void *edata)
 
   int count = reinterpret_cast<intptr_t>(TSContDataGet(cont));
 
-  TSDebug(PN, "Outbound start callback %d %p - event is %s", count, ssl_vc,
-          event == TS_EVENT_VCONN_OUTBOUND_START ? "good" : "bad");
+  Dbg(dbg_ctl, "Outbound start callback %d %p - event is %s", count, ssl_vc,
+      event == TS_EVENT_VCONN_OUTBOUND_START ? "good" : "bad");
 
   // All done, reactivate things
   TSVConnReenable(ssl_vc);
@@ -108,8 +109,8 @@ CB_out_start_delay(TSCont cont, TSEvent event, void *edata)
 
   int count = reinterpret_cast<intptr_t>(TSContDataGet(cont));
 
-  TSDebug(PN, "Outbound delay start callback %d %p - event is %s", count, ssl_vc,
-          event == TS_EVENT_VCONN_OUTBOUND_START ? "good" : "bad");
+  Dbg(dbg_ctl, "Outbound delay start callback %d %p - event is %s", count, ssl_vc,
+      event == TS_EVENT_VCONN_OUTBOUND_START ? "good" : "bad");
 
   TSCont cb = TSContCreate(&ReenableSSL, TSMutexCreate());
 
@@ -129,7 +130,7 @@ CB_close(TSCont cont, TSEvent event, void *edata)
 
   int count = reinterpret_cast<intptr_t>(TSContDataGet(cont));
 
-  TSDebug(PN, "Close callback %d %p - event is %s", count, ssl_vc, event == TS_EVENT_VCONN_CLOSE ? "good" : "bad");
+  Dbg(dbg_ctl, "Close callback %d %p - event is %s", count, ssl_vc, event == TS_EVENT_VCONN_CLOSE ? "good" : "bad");
 
   // All done, reactivate things
   TSVConnReenable(ssl_vc);
@@ -146,8 +147,8 @@ CB_out_close(TSCont cont, TSEvent event, void *edata)
 
   int count = reinterpret_cast<intptr_t>(TSContDataGet(cont));
 
-  TSDebug(PN, "Outbound close callback %d %p - event is %s", count, ssl_vc,
-          event == TS_EVENT_VCONN_OUTBOUND_CLOSE ? "good" : "bad");
+  Dbg(dbg_ctl, "Outbound close callback %d %p - event is %s", count, ssl_vc,
+      event == TS_EVENT_VCONN_OUTBOUND_CLOSE ? "good" : "bad");
 
   // All done, reactivate things
   TSVConnReenable(ssl_vc);
@@ -160,7 +161,7 @@ CB_Client_Hello_Immediate(TSCont cont, TSEvent event, void *edata)
 
   int count = reinterpret_cast<intptr_t>(TSContDataGet(cont));
 
-  TSDebug(PN, "Client Hello callback %d ssl_vc=%p", count, ssl_vc);
+  Dbg(dbg_ctl, "Client Hello callback %d ssl_vc=%p", count, ssl_vc);
 
   // All done, reactivate things
   TSVConnReenable(ssl_vc);
@@ -174,7 +175,7 @@ CB_Client_Hello(TSCont cont, TSEvent event, void *edata)
 
   int count = reinterpret_cast<intptr_t>(TSContDataGet(cont));
 
-  TSDebug(PN, "Client Hello callback %d ssl_vc=%p", count, ssl_vc);
+  Dbg(dbg_ctl, "Client Hello callback %d ssl_vc=%p", count, ssl_vc);
 
   TSCont cb = TSContCreate(&ReenableSSL, TSMutexCreate());
 
@@ -194,7 +195,7 @@ CB_SNI(TSCont cont, TSEvent event, void *edata)
 
   int count = reinterpret_cast<intptr_t>(TSContDataGet(cont));
 
-  TSDebug(PN, "SNI callback %d %p", count, ssl_vc);
+  Dbg(dbg_ctl, "SNI callback %d %p", count, ssl_vc);
 
   // All done, reactivate things
   TSVConnReenable(ssl_vc);
@@ -208,7 +209,7 @@ CB_Cert_Immediate(TSCont cont, TSEvent event, void *edata)
 
   int count = reinterpret_cast<intptr_t>(TSContDataGet(cont));
 
-  TSDebug(PN, "Cert callback %d ssl_vc=%p", count, ssl_vc);
+  Dbg(dbg_ctl, "Cert callback %d ssl_vc=%p", count, ssl_vc);
 
   TSVConnReenable(ssl_vc);
   return TS_SUCCESS;
@@ -221,7 +222,7 @@ CB_Cert(TSCont cont, TSEvent event, void *edata)
 
   int count = reinterpret_cast<intptr_t>(TSContDataGet(cont));
 
-  TSDebug(PN, "Cert callback %d ssl_vc=%p", count, ssl_vc);
+  Dbg(dbg_ctl, "Cert callback %d ssl_vc=%p", count, ssl_vc);
 
   TSCont cb = TSContCreate(&ReenableSSL, TSMutexCreate());
 
@@ -306,8 +307,8 @@ setup_callbacks(TSHttpTxn txn, int preaccept_count, int client_hello_count, int
   TSCont cb = nullptr; // pre-accept callback continuation
   int i;
 
-  TSDebug(PN, "Setup callbacks pa=%d client_hello=%d client_hello_imm=%d sni=%d cert=%d cert_imm=%d pa_delay=%d", preaccept_count,
-          client_hello_count, client_hello_count_immediate, sni_count, cert_count, cert_count_immediate, preaccept_count_delay);
+  Dbg(dbg_ctl, "Setup callbacks pa=%d client_hello=%d client_hello_imm=%d sni=%d cert=%d cert_imm=%d pa_delay=%d", preaccept_count,
+      client_hello_count, client_hello_count_immediate, sni_count, cert_count, cert_count_immediate, preaccept_count_delay);
   for (i = 0; i < preaccept_count; i++) {
     cb = TSContCreate(&CB_Pre_Accept, nullptr);
     TSContDataSet(cb, (void *)static_cast<intptr_t>(i));
diff --git a/tests/tools/plugins/ssl_secret_load_test.cc b/tests/tools/plugins/ssl_secret_load_test.cc
index 1dd50fbefb8..e8e604677f7 100644
--- a/tests/tools/plugins/ssl_secret_load_test.cc
+++ b/tests/tools/plugins/ssl_secret_load_test.cc
@@ -40,6 +40,11 @@
 #define PN  "ssl_secret_load_test"
 #define PCP "[" PN " Plugin] "
 
+namespace
+{
+DbgCtl dbg_ctl{PN};
+}
+
 // Map of secret name to last modified time
 std::unordered_map<std::string, time_t> secret_versions;
 
@@ -67,7 +72,7 @@ load_file(const std::string &newname, struct stat *statdata, std::string &data_i
 
   int fd = open(newname.c_str(), O_RDONLY);
   if (fd < 0) {
-    TSDebug(PN, "Failed to load %s", newname.c_str());
+    Dbg(dbg_ctl, "Failed to load %s", newname.c_str());
     return false;
   }
   size_t total_size = statdata->st_size;
@@ -91,7 +96,7 @@ CB_Load_Secret(TSCont cont, TSEvent event, void *edata)
 {
   TSSecretID *id = reinterpret_cast<TSSecretID *>(edata);
 
-  TSDebug(PN, "Load secret for %*.s", static_cast<int>(id->cert_name_len), id->cert_name);
+  Dbg(dbg_ctl, "Load secret for %*.s", static_cast<int>(id->cert_name_len), id->cert_name);
 
   std::string newname;
   std::string data_item;
@@ -99,7 +104,7 @@ CB_Load_Secret(TSCont cont, TSEvent event, void *edata)
 
   update_file_name(std::string_view{id->cert_name, id->cert_name_len}, newname);
 
-  TSDebug(PN, "Really load secret for %s", newname.c_str());
+  Dbg(dbg_ctl, "Really load secret for %s", newname.c_str());
 
   // Load the secret and add it to the map
   if (!load_file(newname, &statdata, data_item)) {
@@ -110,10 +115,10 @@ CB_Load_Secret(TSCont cont, TSEvent event, void *edata)
   TSSslSecretSet(id->cert_name, id->cert_name_len, data_item.data(), data_item.size());
 
   if (id->key_name_len > 0) {
-    TSDebug(PN, "Load secret for %*.s", static_cast<int>(id->key_name_len), id->key_name);
+    Dbg(dbg_ctl, "Load secret for %*.s", static_cast<int>(id->key_name_len), id->key_name);
     update_file_name(std::string_view{id->key_name, id->key_name_len}, newname);
 
-    TSDebug(PN, "Really load secret for %s", newname.c_str());
+    Dbg(dbg_ctl, "Really load secret for %s", newname.c_str());
 
     // Load the secret and add it to the map
     if (!load_file(newname, &statdata, data_item)) {
@@ -137,14 +142,14 @@ CB_Update_Secret(TSCont cont, TSEvent event, void *edata)
     struct stat statdata;
 
     update_file_name(iter->first, newname);
-    TSDebug(PN, "check secret for %s, really %s", iter->first.c_str(), newname.c_str());
+    Dbg(dbg_ctl, "check secret for %s, really %s", iter->first.c_str(), newname.c_str());
 
     if (stat(newname.c_str(), &statdata) < 0) {
       continue;
     }
 
     if (statdata.st_mtime > iter->second) {
-      TSDebug(PN, "check secret %s has been updated", newname.c_str());
+      Dbg(dbg_ctl, "check secret %s has been updated", newname.c_str());
       if (!load_file(newname, &statdata, data_item)) {
         continue;
       }
@@ -154,7 +159,7 @@ CB_Update_Secret(TSCont cont, TSEvent event, void *edata)
     }
   }
   for (auto name : updates) {
-    TSDebug(PN, "update cert for secret %s", name.c_str());
+    Dbg(dbg_ctl, "update cert for secret %s", name.c_str());
     TSSslSecretUpdate(name.c_str(), name.length());
   }
   TSContScheduleOnPool(cont, 3000, TS_THREAD_POOL_TASK);
diff --git a/tests/tools/plugins/ssl_verify_test.cc b/tests/tools/plugins/ssl_verify_test.cc
index 6efff0ab1ae..235ff491bc3 100644
--- a/tests/tools/plugins/ssl_verify_test.cc
+++ b/tests/tools/plugins/ssl_verify_test.cc
@@ -36,6 +36,11 @@
 #define PN  "ssl_verify_test"
 #define PCP "[" PN " Plugin] "
 
+namespace
+{
+DbgCtl dbg_ctl{PN};
+}
+
 std::map<std::string, int> bad_names;
 
 int
@@ -56,15 +61,14 @@ CB_server_verify(TSCont cont, TSEvent event, void *edata)
       reenable_event = TS_EVENT_ERROR;
     }
 
-    TSDebug(PN, "Server verify callback %d %p - event is %s SNI=%s %s", count, ssl_vc,
-            event == TS_EVENT_SSL_VERIFY_SERVER ? "good" : "bad", sni_name,
-            reenable_event == TS_EVENT_ERROR ? "error HS" : "good HS");
+    Dbg(dbg_ctl, "Server verify callback %d %p - event is %s SNI=%s %s", count, ssl_vc,
+        event == TS_EVENT_SSL_VERIFY_SERVER ? "good" : "bad", sni_name, reenable_event == TS_EVENT_ERROR ? "error HS" : "good HS");
 
     int len;
     char const *const method2_name = TSVConnSslSniGet(ssl_vc, &len);
-    TSDebug(PN, "Server verify callback SNI APIs match=%s", 0 == strncmp(method2_name, sni_name, len) ? "true" : "false");
+    Dbg(dbg_ctl, "Server verify callback SNI APIs match=%s", 0 == strncmp(method2_name, sni_name, len) ? "true" : "false");
   } else {
-    TSDebug(PN, "SSL_get_servername failed");
+    Dbg(dbg_ctl, "SSL_get_servername failed");
     reenable_event = TS_EVENT_ERROR;
   }
 
@@ -104,7 +108,7 @@ setup_callbacks(int count)
   TSCont cb = nullptr;
   int i;
 
-  TSDebug(PN, "Setup callbacks count=%d", count);
+  Dbg(dbg_ctl, "Setup callbacks count=%d", count);
   for (i = 0; i < count; i++) {
     cb = TSContCreate(&CB_server_verify, TSMutexCreate());
     TSContDataSet(cb, (void *)static_cast<intptr_t>(i));
diff --git a/tests/tools/plugins/ssntxnorder_verify.cc b/tests/tools/plugins/ssntxnorder_verify.cc
index 226e947dab9..ae3b8ef50b6 100644
--- a/tests/tools/plugins/ssntxnorder_verify.cc
+++ b/tests/tools/plugins/ssntxnorder_verify.cc
@@ -36,10 +36,15 @@
 // debug messages during one-time initialization
 static const char DEBUG_TAG_INIT[] = "ssntxnorder_verify.init";
 
+static DbgCtl dbg_ctl_init{DEBUG_TAG_INIT};
+
 // debug messages on every request serviced
 static const char DEBUG_TAG_HOOK[]  = "ssntxnorder_verify.hook";
 static const char DEBUG_TAG_CLOSE[] = "ssntxnorder_verify.close";
 
+static DbgCtl dbg_ctl_hook{DEBUG_TAG_HOOK};
+static DbgCtl dbg_ctl_close{DEBUG_TAG_CLOSE};
+
 // plugin registration info
 static char plugin_name[]   = "ssntxnorder_verify";
 static char vendor_name[]   = "Apache";
@@ -97,7 +102,7 @@ static const char ctl_dump[] = "dump";      // output active ssn/txn tables cmd
 static void
 dump_tables()
 {
-  TSDebug(DEBUG_TAG_HOOK, "Dumping active session and transaction tables.");
+  Dbg(dbg_ctl_hook, "Dumping active session and transaction tables.");
   std::stringstream dump("");
 
   dump << std::string(100, '+') << std::endl;
@@ -140,17 +145,17 @@ handle_order(TSCont contp, TSEvent event, void *edata)
   case TS_EVENT_HTTP_SSN_CLOSE: // End of session
   {
     ssnp = reinterpret_cast<TSHttpSsn>(edata);
-    TSDebug(DEBUG_TAG_CLOSE, "event TS_EVENT_HTTP_SSN_CLOSE [ SSNID = %p ]", ssnp);
+    Dbg(dbg_ctl_close, "event TS_EVENT_HTTP_SSN_CLOSE [ SSNID = %p ]", ssnp);
     TSStatIntIncrement(stat_ssn_close, 1);
     if (started_ssns.erase(ssnp) == 0) {
       // No record existsted for this session
-      TSDebug(DEBUG_TAG_HOOK, "Session [ SSNID = %p ] closing was not previously started", ssnp);
+      Dbg(dbg_ctl_hook, "Session [ SSNID = %p ] closing was not previously started", ssnp);
       TSStatIntIncrement(stat_err, 1);
       abort();
     }
 
     if (--ssn_balance < 0) {
-      TSDebug(DEBUG_TAG_HOOK, "More sessions have been closed than started.");
+      Dbg(dbg_ctl_hook, "More sessions have been closed than started.");
       TSStatIntIncrement(stat_err, 1);
       abort();
     }
@@ -162,12 +167,12 @@ handle_order(TSCont contp, TSEvent event, void *edata)
   case TS_EVENT_HTTP_SSN_START: // Beginning of session
   {
     ssnp = reinterpret_cast<TSHttpSsn>(edata);
-    TSDebug(DEBUG_TAG_HOOK, "event TS_EVENT_HTTP_SSN_START [ SSNID = %p ]", ssnp);
+    Dbg(dbg_ctl_hook, "event TS_EVENT_HTTP_SSN_START [ SSNID = %p ]", ssnp);
     TSStatIntIncrement(stat_ssn_start, 1);
 
     if (!started_ssns.insert(ssnp).second) {
       // Insert failed. Session already existed in the record.
-      TSDebug(DEBUG_TAG_HOOK, "Session [ SSNID = %p ] has previously started.", ssnp);
+      Dbg(dbg_ctl_hook, "Session [ SSNID = %p ] has previously started.", ssnp);
       TSStatIntIncrement(stat_err, 1);
       abort();
     }
@@ -180,7 +185,7 @@ handle_order(TSCont contp, TSEvent event, void *edata)
   case TS_EVENT_HTTP_TXN_CLOSE: // End of transaction
   {
     txnp = reinterpret_cast<TSHttpTxn>(edata);
-    TSDebug(DEBUG_TAG_HOOK, "event TS_EVENT_HTTP_TXN_CLOSE [ TXNID = %" PRIu64 " ]", TSHttpTxnIdGet(txnp));
+    Dbg(dbg_ctl_hook, "event TS_EVENT_HTTP_TXN_CLOSE [ TXNID = %" PRIu64 " ]", TSHttpTxnIdGet(txnp));
     TSStatIntIncrement(stat_txn_close, 1);
 
     std::set<started_txn>::iterator closed_txn = closed_txns.find(started_txn(TSHttpTxnIdGet(txnp)));
@@ -200,26 +205,26 @@ handle_order(TSCont contp, TSEvent event, void *edata)
       if (started_ssns.find(ssnp) == started_ssns.end()) {
         // The session of the transaction was either not started, or was
         // already closed.
-        TSDebug(DEBUG_TAG_HOOK,
-                "Transaction [ TXNID = %" PRIu64 " ] closing not in an "
-                "active session [ SSNID = %p ].",
-                current_txn->id, ssnp);
+        Dbg(dbg_ctl_hook,
+            "Transaction [ TXNID = %" PRIu64 " ] closing not in an "
+            "active session [ SSNID = %p ].",
+            current_txn->id, ssnp);
         TSStatIntIncrement(stat_err, 1);
         abort();
       }
       started_txns.erase(current_txn); // Stop monitoring the transaction
     } else {
       // Transaction does not exists.
-      TSDebug(DEBUG_TAG_HOOK,
-              "Transaction [ TXNID = %" PRIu64 " ] closing not "
-              "previously started.",
-              TSHttpTxnIdGet(txnp));
+      Dbg(dbg_ctl_hook,
+          "Transaction [ TXNID = %" PRIu64 " ] closing not "
+          "previously started.",
+          TSHttpTxnIdGet(txnp));
       TSStatIntIncrement(stat_err, 1);
       abort();
     }
 
     if (--txn_balance < 0) {
-      TSDebug(DEBUG_TAG_HOOK, "More transactions have been closed than started.");
+      Dbg(dbg_ctl_hook, "More transactions have been closed than started.");
       TSStatIntIncrement(stat_err, 1);
       abort();
     }
@@ -232,24 +237,24 @@ handle_order(TSCont contp, TSEvent event, void *edata)
   {
     txnp = reinterpret_cast<TSHttpTxn>(edata);
     ssnp = TSHttpTxnSsnGet(txnp);
-    TSDebug(DEBUG_TAG_HOOK, "event TS_EVENT_HTTP_TXN_START [ TXNID = %" PRIu64 " ]", TSHttpTxnIdGet(txnp));
+    Dbg(dbg_ctl_hook, "event TS_EVENT_HTTP_TXN_START [ TXNID = %" PRIu64 " ]", TSHttpTxnIdGet(txnp));
     TSStatIntIncrement(stat_txn_start, 1);
 
     started_txn new_txn = started_txn(TSHttpTxnIdGet(txnp), txnp, ssnp);
 
     if (started_ssns.find(ssnp) == started_ssns.end()) {
       // Session of the transaction has not started.
-      TSDebug(DEBUG_TAG_HOOK,
-              "Transaction [ TXNID = %" PRIu64 " ] starting not in an "
-              "active session [ SSNID = %p ].",
-              new_txn.id, ssnp);
+      Dbg(dbg_ctl_hook,
+          "Transaction [ TXNID = %" PRIu64 " ] starting not in an "
+          "active session [ SSNID = %p ].",
+          new_txn.id, ssnp);
       TSStatIntIncrement(stat_err, 1);
       abort();
     }
 
     if (!started_txns.insert(new_txn).second) {
       // Insertion failed. Transaction has previously started.
-      TSDebug(DEBUG_TAG_HOOK, "Transaction [ TXNID = %" PRIu64 " ] has previously started.", new_txn.id);
+      Dbg(dbg_ctl_hook, "Transaction [ TXNID = %" PRIu64 " ] has previously started.", new_txn.id);
       TSStatIntIncrement(stat_err, 1);
       abort();
     }
@@ -262,7 +267,7 @@ handle_order(TSCont contp, TSEvent event, void *edata)
 
   case TS_EVENT_LIFECYCLE_MSG: // External trigger, such as traffic_ctl
   {
-    TSDebug(DEBUG_TAG_HOOK, "event TS_EVENT_LIFECYCLE_MSG");
+    Dbg(dbg_ctl_hook, "event TS_EVENT_LIFECYCLE_MSG");
     msgp = reinterpret_cast<TSPluginMsg *>(edata); // inconsistency
 
     // Verify message is with the appropriate tag
@@ -298,7 +303,7 @@ handle_order(TSCont contp, TSEvent event, void *edata)
 void
 TSPluginInit(int argc, const char *argv[])
 {
-  TSDebug(DEBUG_TAG_INIT, "initializing plugin");
+  Dbg(dbg_ctl_init, "initializing plugin");
 
   TSPluginRegistrationInfo info;
 
@@ -307,13 +312,13 @@ TSPluginInit(int argc, const char *argv[])
   info.support_email = support_email;
 
   if (TSPluginRegister(&info) != TS_SUCCESS) {
-    TSDebug(DEBUG_TAG_HOOK, "[%s] Plugin registration failed. \n", plugin_name);
+    Dbg(dbg_ctl_hook, "[%s] Plugin registration failed. \n", plugin_name);
   }
 
   TSCont contp = TSContCreate(handle_order, TSMutexCreate());
   if (contp == nullptr) {
     // Continuation initialization failed. Unrecoverable, report and exit.
-    TSDebug(DEBUG_TAG_HOOK, "[%s] could not create continuation", plugin_name);
+    Dbg(dbg_ctl_hook, "[%s] could not create continuation", plugin_name);
     abort();
   } else {
     // Continuation initialization succeeded.
diff --git a/tests/tools/plugins/test_hooks.cc b/tests/tools/plugins/test_hooks.cc
index 176df3ee80b..44ef48fc892 100644
--- a/tests/tools/plugins/test_hooks.cc
+++ b/tests/tools/plugins/test_hooks.cc
@@ -39,6 +39,8 @@ namespace
 #define PINAME "test_hooks"
 char PIName[] = PINAME;
 
+DbgCtl dbg_ctl{PIName};
+
 // NOTE:  It's important to flush this after writing so that a gold test using this plugin can examine the log before TS
 // terminates.
 //
@@ -55,13 +57,13 @@ transactionContFunc(TSCont, TSEvent event, void *eventData)
 {
   logFile << "Transaction: event=" << TSHttpEventNameLookup(event) << std::endl;
 
-  TSDebug(PIName, "Transaction: event=%s(%d) eventData=%p", TSHttpEventNameLookup(event), event, eventData);
+  Dbg(dbg_ctl, "Transaction: event=%s(%d) eventData=%p", TSHttpEventNameLookup(event), event, eventData);
 
   switch (event) {
   case TS_EVENT_HTTP_TXN_CLOSE: {
     auto txn = static_cast<TSHttpTxn>(eventData);
 
-    TSDebug(PIName, "Transaction: ssn=%p", TSHttpTxnSsnGet(txn));
+    Dbg(dbg_ctl, "Transaction: ssn=%p", TSHttpTxnSsnGet(txn));
 
     // Don't assume any order of continuation execution on the same hook.
     ALWAYS_ASSERT((txn == activeTxn) or !activeTxn)
@@ -74,7 +76,7 @@ transactionContFunc(TSCont, TSEvent event, void *eventData)
   case TS_EVENT_HTTP_READ_REQUEST_HDR: {
     auto txn = static_cast<TSHttpTxn>(eventData);
 
-    TSDebug(PIName, "Transaction: ssn=%p", TSHttpTxnSsnGet(txn));
+    Dbg(dbg_ctl, "Transaction: ssn=%p", TSHttpTxnSsnGet(txn));
 
     ALWAYS_ASSERT(txn == activeTxn)
     ALWAYS_ASSERT(TSHttpTxnSsnGet(txn) == activeSsn)
@@ -98,7 +100,7 @@ sessionContFunc(TSCont, TSEvent event, void *eventData)
 {
   logFile << "Session: event=" << TSHttpEventNameLookup(event) << std::endl;
 
-  TSDebug(PIName, "Session: event=%s(%d) eventData=%p", TSHttpEventNameLookup(event), event, eventData);
+  Dbg(dbg_ctl, "Session: event=%s(%d) eventData=%p", TSHttpEventNameLookup(event), event, eventData);
 
   switch (event) {
   case TS_EVENT_HTTP_SSN_CLOSE: {
@@ -116,7 +118,7 @@ sessionContFunc(TSCont, TSEvent event, void *eventData)
     // Don't assume any order of continuation execution on the same hook.
     ALWAYS_ASSERT((txn == activeTxn) or !activeTxn)
 
-    TSDebug(PIName, "Session: ssn=%p", TSHttpTxnSsnGet(txn));
+    Dbg(dbg_ctl, "Session: ssn=%p", TSHttpTxnSsnGet(txn));
 
     ALWAYS_ASSERT(TSHttpTxnSsnGet(txn) == activeSsn)
 
@@ -129,7 +131,7 @@ sessionContFunc(TSCont, TSEvent event, void *eventData)
   case TS_EVENT_HTTP_TXN_CLOSE: {
     auto txn = static_cast<TSHttpTxn>(eventData);
 
-    TSDebug(PIName, "Session: ssn=%p", TSHttpTxnSsnGet(txn));
+    Dbg(dbg_ctl, "Session: ssn=%p", TSHttpTxnSsnGet(txn));
 
     // Don't assume any order of continuation execution on the same hook.
     ALWAYS_ASSERT((txn == activeTxn) or !activeTxn)
@@ -142,7 +144,7 @@ sessionContFunc(TSCont, TSEvent event, void *eventData)
   case TS_EVENT_HTTP_READ_REQUEST_HDR: {
     auto txn = static_cast<TSHttpTxn>(eventData);
 
-    TSDebug(PIName, "Session: ssn=%p", TSHttpTxnSsnGet(txn));
+    Dbg(dbg_ctl, "Session: ssn=%p", TSHttpTxnSsnGet(txn));
 
     ALWAYS_ASSERT(txn == activeTxn)
     ALWAYS_ASSERT(TSHttpTxnSsnGet(txn) == activeSsn)
@@ -166,7 +168,7 @@ globalContFunc(TSCont, TSEvent event, void *eventData)
 {
   logFile << "Global: event=" << TSHttpEventNameLookup(event) << std::endl;
 
-  TSDebug(PIName, "Global: event=%s(%d) eventData=%p", TSHttpEventNameLookup(event), event, eventData);
+  Dbg(dbg_ctl, "Global: event=%s(%d) eventData=%p", TSHttpEventNameLookup(event), event, eventData);
 
   switch (event) {
   case TS_EVENT_VCONN_START: {
@@ -233,7 +235,7 @@ globalContFunc(TSCont, TSEvent event, void *eventData)
 
     auto txn = static_cast<TSHttpTxn>(eventData);
 
-    TSDebug(PIName, "Global: ssn=%p", TSHttpTxnSsnGet(txn));
+    Dbg(dbg_ctl, "Global: ssn=%p", TSHttpTxnSsnGet(txn));
 
     activeTxn = txn;
 
@@ -245,7 +247,7 @@ globalContFunc(TSCont, TSEvent event, void *eventData)
   case TS_EVENT_HTTP_TXN_CLOSE: {
     auto txn = static_cast<TSHttpTxn>(eventData);
 
-    TSDebug(PIName, "Global: ssn=%p", TSHttpTxnSsnGet(txn));
+    Dbg(dbg_ctl, "Global: ssn=%p", TSHttpTxnSsnGet(txn));
 
     ALWAYS_ASSERT(txn == activeTxn)
     ALWAYS_ASSERT(TSHttpTxnSsnGet(txn) == activeSsn)
@@ -258,7 +260,7 @@ globalContFunc(TSCont, TSEvent event, void *eventData)
   case TS_EVENT_HTTP_READ_REQUEST_HDR: {
     auto txn = static_cast<TSHttpTxn>(eventData);
 
-    TSDebug(PIName, "Global: ssn=%p", TSHttpTxnSsnGet(txn));
+    Dbg(dbg_ctl, "Global: ssn=%p", TSHttpTxnSsnGet(txn));
 
     ALWAYS_ASSERT(txn == activeTxn)
     ALWAYS_ASSERT(TSHttpTxnSsnGet(txn) == activeSsn)