diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7bb04dd0e0..378396c9b6 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -3374,10 +3374,10 @@ set(SHARK_PUBLIC_HEADERS
 	cli_main.h
 	file.h
 	globals.h
-	log.h
 	ws_attributes.h
 	ws_compiler_tests.h
 	ws_diag_control.h
+	ws_log_domains.h
 	ws_symbol_export.h
 	version_info.h
 	${CMAKE_BINARY_DIR}/ws_version.h
diff --git a/capture/capture-pcap-util.c b/capture/capture-pcap-util.c
index 3dc6c9d181..f9dda3cf9a 100644
--- a/capture/capture-pcap-util.c
+++ b/capture/capture-pcap-util.c
@@ -9,6 +9,7 @@
  */
 
 #include "config.h"
+#define WS_LOG_DOMAIN LOG_DOMAIN_CAPCHILD
 
 #ifdef HAVE_LIBPCAP
 
@@ -68,10 +69,9 @@
 #include "capture/capture-pcap-util.h"
 #include "capture/capture-pcap-util-int.h"
 
-#include "log.h"
-
 #include <wsutil/file_util.h>
 #include <wsutil/please_report_bug.h>
+#include <wsutil/wslog.h>
 
 #ifndef _WIN32
 #include <netinet/in.h>
@@ -1275,23 +1275,19 @@ open_capture_device_pcap_create(
 	pcap_t *pcap_h;
 	int status;
 
-	g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
-	    "Calling pcap_create() using %s.", interface_opts->name);
+	ws_debug("Calling pcap_create() using %s.", interface_opts->name);
 	pcap_h = pcap_create(interface_opts->name, *open_err_str);
-	g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
-	    "pcap_create() returned %p.", (void *)pcap_h);
+	ws_debug("pcap_create() returned %p.", (void *)pcap_h);
 	if (pcap_h == NULL) {
 		*open_err = CAP_DEVICE_OPEN_ERR_NOT_PERMISSIONS;
 		return NULL;
 	}
 	if (interface_opts->has_snaplen) {
-		g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
-		    "Calling pcap_set_snaplen() with snaplen %d.",
+		ws_debug("Calling pcap_set_snaplen() with snaplen %d.",
 		    interface_opts->snaplen);
 		pcap_set_snaplen(pcap_h, interface_opts->snaplen);
 	}
-	g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
-	    "Calling pcap_set_promisc() with promisc_mode %d.",
+	ws_debug("Calling pcap_set_promisc() with promisc_mode %d.",
 	    interface_opts->promisc_mode);
 	pcap_set_promisc(pcap_h, interface_opts->promisc_mode);
 	pcap_set_timeout(pcap_h, timeout);
@@ -1337,18 +1333,15 @@ open_capture_device_pcap_create(
 	}
 #endif /* HAVE_PCAP_SET_TSTAMP_PRECISION */
 
-	g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
-	    "buffersize %d.", interface_opts->buffer_size);
+	ws_debug("buffersize %d.", interface_opts->buffer_size);
 	if (interface_opts->buffer_size != 0)
 		pcap_set_buffer_size(pcap_h,
 		    interface_opts->buffer_size * 1024 * 1024);
-	g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
-	    "monitor_mode %d.", interface_opts->monitor_mode);
+	ws_debug("monitor_mode %d.", interface_opts->monitor_mode);
 	if (interface_opts->monitor_mode)
 		pcap_set_rfmon(pcap_h, 1);
 	status = pcap_activate(pcap_h);
-	g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
-	    "pcap_activate() returned %d.", status);
+	ws_debug("pcap_activate() returned %d.", status);
 	if (status < 0) {
 		/* Failed to activate, set to NULL */
 		if (status == PCAP_ERROR) {
@@ -1424,13 +1417,11 @@ open_capture_device_pcap_open_live(interface_options *interface_opts,
 		 */
 		snaplen = 256*1024;
 	}
-	g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
-	    "pcap_open_live() calling using name %s, snaplen %d, promisc_mode %d.",
+	ws_debug("pcap_open_live() calling using name %s, snaplen %d, promisc_mode %d.",
 	    interface_opts->name, snaplen, interface_opts->promisc_mode);
 	pcap_h = pcap_open_live(interface_opts->name, snaplen,
 	    interface_opts->promisc_mode, timeout, *open_err_str);
-	g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
-	    "pcap_open_live() returned %p.", (void *)pcap_h);
+	ws_debug("pcap_open_live() returned %p.", (void *)pcap_h);
 	if (pcap_h == NULL) {
 		*open_err = CAP_DEVICE_OPEN_ERR_GENERIC;
 		return NULL;
@@ -1538,7 +1529,7 @@ open_capture_device(capture_options *capture_opts,
 	   Some versions of libpcap may put warnings into the error buffer
 	   if they succeed; to tell if that's happened, we have to clear
 	   the error buffer, and check if it's still a null string.  */
-	g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "Entering open_capture_device().");
+	ws_debug("Entering open_capture_device().");
 	*open_err = CAP_DEVICE_OPEN_NO_ERR;
 	(*open_err_str)[0] = '\0';
 #if defined(HAVE_PCAP_OPEN) && defined(HAVE_PCAP_REMOTE)
@@ -1563,8 +1554,7 @@ open_capture_device(capture_options *capture_opts,
 			 */
 			snaplen = 256*1024;
 		}
-		g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
-		    "Calling pcap_open() using name %s, snaplen %d, promisc_mode %d, datatx_udp %d, nocap_rpcap %d.",
+		ws_debug("Calling pcap_open() using name %s, snaplen %d, promisc_mode %d, datatx_udp %d, nocap_rpcap %d.",
 		    interface_opts->name, snaplen,
 		    interface_opts->promisc_mode, interface_opts->datatx_udp,
 		    interface_opts->nocap_rpcap);
@@ -1597,16 +1587,15 @@ open_capture_device(capture_options *capture_opts,
 				    sizeof *open_err_str);
 			}
 		}
-		g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
-		    "pcap_open() returned %p.", (void *)pcap_h);
-		g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "open_capture_device %s : %s", pcap_h ? "SUCCESS" : "FAILURE", interface_opts->name);
+		ws_debug("pcap_open() returned %p.", (void *)pcap_h);
+		ws_debug("open_capture_device %s : %s", pcap_h ? "SUCCESS" : "FAILURE", interface_opts->name);
 		return pcap_h;
 	}
 #endif
 
 	pcap_h = open_capture_device_local(capture_opts, interface_opts,
 	    timeout, open_err, open_err_str);
-	g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "open_capture_device %s : %s", pcap_h ? "SUCCESS" : "FAILURE", interface_opts->name);
+	ws_debug("open_capture_device %s : %s", pcap_h ? "SUCCESS" : "FAILURE", interface_opts->name);
 	return pcap_h;
 }
 
diff --git a/capture/capture_ifinfo.c b/capture/capture_ifinfo.c
index 396d0733cf..40e0f03944 100644
--- a/capture/capture_ifinfo.c
+++ b/capture/capture_ifinfo.c
@@ -9,6 +9,7 @@
  */
 
 #include "config.h"
+#define WS_LOG_DOMAIN LOG_DOMAIN_CAPTURE
 
 #ifdef HAVE_LIBPCAP
 
@@ -23,7 +24,6 @@
 #include "capture/capture_session.h"
 #include "capture/capture_sync.h"
 #include "extcap.h"
-#include "log.h"
 
 #include <capture/capture_ifinfo.h>
 #include <wsutil/inet_addr.h>
@@ -90,8 +90,6 @@ capture_interface_list(int *err, char **err_str, void (*update_cb)(void))
     if_info_t *if_info;
     if_addr_t *if_addr;
 
-    g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture Interface List ...");
-
     *err = 0;
     if (err_str) {
         *err_str = NULL;
@@ -101,12 +99,12 @@ capture_interface_list(int *err, char **err_str, void (*update_cb)(void))
     ret = sync_interface_list_open(&data, &primary_msg, &secondary_msg, update_cb);
     if (ret != 0) {
         /* Add the extcap interfaces that can exist, even if no native interfaces have been found */
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Loading External Capture Interface List ...");
+        ws_message("Loading External Capture Interface List ...");
         if_list = append_extcap_interface_list(if_list, err_str);
         /* err_str is ignored, as the error for the interface loading list will take precedence */
         if ( g_list_length(if_list) == 0 ) {
 
-            g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture Interface List failed. Error %d, %s (%s)",
+            ws_message("Capture Interface List failed. Error %d, %s (%s)",
                   *err, primary_msg ? primary_msg : "no message",
                   secondary_msg ? secondary_msg : "no secondary message");
             if (err_str) {
@@ -185,7 +183,7 @@ capture_interface_list(int *err, char **err_str, void (*update_cb)(void))
 #endif
 
     /* Add the extcap interfaces after the native and remote interfaces */
-    g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Loading External Capture Interface List ...");
+    ws_message("Loading External Capture Interface List ...");
     if_list = append_extcap_interface_list(if_list, err_str);
 
     return if_list;
@@ -205,8 +203,6 @@ capture_get_if_capabilities(const gchar *ifname, gboolean monitor_mode,
     gchar              *data, *primary_msg, *secondary_msg;
     gchar             **raw_list;
 
-    g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture Interface Capabilities ...");
-
     /* see if the interface is from extcap */
     caps = extcap_get_if_dlts(ifname, err_primary_msg);
     if (caps != NULL)
@@ -220,7 +216,7 @@ capture_get_if_capabilities(const gchar *ifname, gboolean monitor_mode,
     err = sync_if_capabilities_open(ifname, monitor_mode, auth_string, &data,
                                     &primary_msg, &secondary_msg, update_cb);
     if (err != 0) {
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture Interface Capabilities failed. Error %d, %s",
+        ws_message("Capture Interface Capabilities failed. Error %d, %s",
               err, primary_msg ? primary_msg : "no message");
         if (err_primary_msg)
             *err_primary_msg = primary_msg;
@@ -245,7 +241,7 @@ capture_get_if_capabilities(const gchar *ifname, gboolean monitor_mode,
      * First line is 0 if monitor mode isn't supported, 1 if it is.
      */
     if (raw_list[0] == NULL || *raw_list[0] == '\0') {
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture Interface Capabilities returned no information.");
+        ws_message("Capture Interface Capabilities returned no information.");
         if (err_primary_msg) {
             *err_primary_msg = g_strdup("Dumpcap returned no interface capability information");
         }
@@ -268,7 +264,7 @@ capture_get_if_capabilities(const gchar *ifname, gboolean monitor_mode,
         break;
 
     default:
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture Interface Capabilities returned bad information.");
+        ws_message("Capture Interface Capabilities returned bad information.");
         if (err_primary_msg) {
             *err_primary_msg = g_strdup_printf("Dumpcap returned \"%s\" for monitor-mode capability",
                                        raw_list[0]);
diff --git a/capture/capture_sync.c b/capture/capture_sync.c
index afd9f47778..88af85b9e6 100644
--- a/capture/capture_sync.c
+++ b/capture/capture_sync.c
@@ -9,6 +9,7 @@
  */
 
 #include "config.h"
+#define WS_LOG_DOMAIN LOG_DOMAIN_CAPTURE
 
 #ifdef HAVE_LIBPCAP
 
@@ -20,6 +21,7 @@
 #include <signal.h>
 
 #include <wsutil/strtoi.h>
+#include <wsutil/wslog.h>
 
 #ifdef _WIN32
 #include <wsutil/unicode-utils.h>
@@ -81,7 +83,6 @@
 #include <wsutil/file_util.h>
 #include <wsutil/report_message.h>
 #include "extcap.h"
-#include "log.h"
 
 #ifdef _WIN32
 #include <process.h>    /* For spawning child process */
@@ -230,8 +231,8 @@ sync_pipe_start(capture_options *capture_opts, capture_session *cap_session, inf
 
     if (capture_opts->ifaces->len > 1)
         capture_opts->use_pcapng = TRUE;
-    g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_pipe_start");
-    capture_opts_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, capture_opts);
+    ws_debug("sync_pipe_start");
+    capture_opts_log(LOG_DOMAIN_CAPTURE, LOG_LEVEL_DEBUG, capture_opts);
 
     cap_session->fork_child = WS_INVALID_PID;
 
@@ -447,7 +448,7 @@ sync_pipe_start(capture_options *capture_opts, capture_session *cap_session, inf
         argv = sync_pipe_add_arg(argv, &argc, capture_opts->save_file);
     }
     for (i = 0; i < argc; i++) {
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "argv[%d]: %s", i, argv[i]);
+        ws_debug("argv[%d]: %s", i, argv[i]);
     }
     if (capture_opts->compress_type) {
         argv = sync_pipe_add_arg(argv, &argc, "--compress-type");
@@ -682,7 +683,7 @@ sync_pipe_open_command(char* const argv[], int *data_read_fd,
     *fork_child = WS_INVALID_PID;
     *data_read_fd = -1;
     *message_read_fd = -1;
-    g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_pipe_open_command");
+    ws_debug("sync_pipe_open_command");
 
     if (!msg) {
         /* We can't return anything */
@@ -1096,21 +1097,21 @@ sync_pipe_run_command(char* const argv[], gchar **data, gchar **primary_msg,
     int logging_enabled;
 
     /* check if logging is actually enabled, otherwise don't expend the CPU generating logging */
-    logging_enabled=( (G_LOG_LEVEL_DEBUG | G_LOG_LEVEL_INFO) & G_LOG_LEVEL_MASK & prefs.console_log_level);
-    if(logging_enabled){
+    logging_enabled = ws_log_level_is_active(LOG_LEVEL_INFO);
+    if (logging_enabled) {
         start_time = g_get_monotonic_time();
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_INFO, "sync_pipe_run_command() starts");
-        for(i=0; argv[i] != 0; i++) {
-            g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "  argv[%d]: %s", i, argv[i]);
+        ws_info("sync_pipe_run_command() starts");
+        for (i=0; argv[i] != 0; i++) {
+            ws_debug("  argv[%d]: %s", i, argv[i]);
         }
     }
     /* do the actual sync pipe run command */
-    ret=sync_pipe_run_command_actual(argv, data, primary_msg, secondary_msg, update_cb);
+    ret = sync_pipe_run_command_actual(argv, data, primary_msg, secondary_msg, update_cb);
 
-    if(logging_enabled){
+    if (logging_enabled) {
         elapsed = (g_get_monotonic_time() - start_time) / 1e6;
 
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_INFO, "sync_pipe_run_command() ends, taking %.3fs, result=%d", elapsed, ret);
+        ws_info("sync_pipe_run_command() ends, taking %.3fs, result=%d", elapsed, ret);
 
     }
     return ret;
@@ -1191,7 +1192,7 @@ sync_interface_list_open(gchar **data, gchar **primary_msg,
     char **argv;
     int ret;
 
-    g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_interface_list_open");
+    ws_debug("sync_interface_list_open");
 
     argv = init_pipe_args(&argc);
 
@@ -1236,7 +1237,7 @@ sync_if_capabilities_open(const gchar *ifname, gboolean monitor_mode, const gcha
     char **argv;
     int ret;
 
-    g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_if_capabilities_open");
+    ws_debug("sync_if_capabilities_open");
 
     argv = init_pipe_args(&argc);
 
@@ -1291,7 +1292,7 @@ sync_interface_stats_open(int *data_read_fd, ws_process_id *fork_child, gchar **
     /*char *secondary_msg_text;*/
     char *combined_msg;
 
-    g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_interface_stats_open");
+    ws_debug("sync_interface_stats_open");
 
     argv = init_pipe_args(&argc);
 
@@ -1456,17 +1457,14 @@ pipe_read_bytes(int pipe_fd, char *bytes, int required, char **msg)
         newly = ws_read(pipe_fd, &bytes[offset], required);
         if (newly == 0) {
             /* EOF */
-            g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
-                  "read from pipe %d: EOF (capture closed?)", pipe_fd);
+            ws_debug("read from pipe %d: EOF (capture closed?)", pipe_fd);
             *msg = 0;
             return offset;
         }
         if (newly < 0) {
             /* error */
             error = errno;
-            g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
-                  "read from pipe %d: error(%u): %s", pipe_fd, error,
-                  g_strerror(error));
+            ws_debug("read from pipe %d: error(%u): %s", pipe_fd, error, g_strerror(error));
             *msg = g_strdup_printf("Error reading from sync pipe: %s",
                                    g_strerror(error));
             return newly;
@@ -1501,8 +1499,7 @@ sync_pipe_gets_nonblock(int pipe_fd, char *bytes, int max) {
             break;
         } else if (newly == -1) {
             /* error */
-            g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
-                  "read from pipe %d: error(%u): %s", pipe_fd, errno, g_strerror(errno));
+            ws_debug("read from pipe %d: error(%u): %s", pipe_fd, errno, g_strerror(errno));
             return -1;
         } else if (bytes[offset] == '\n') {
             break;
@@ -1547,12 +1544,10 @@ pipe_read_block(int pipe_fd, char *indicator, int len, char *msg,
              * is an "I'm done" indication, so don't report it as an
              * error.
              */
-            g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
-                  "read %d got an EOF", pipe_fd);
+            ws_debug("read %d got an EOF", pipe_fd);
             return 0;
         }
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
-              "read %d failed to read header: %lu", pipe_fd, (long)newly);
+        ws_debug("read %d failed to read header: %lu", pipe_fd, (long)newly);
         if (newly != -1) {
             /*
              * Short read, but not an immediate EOF.
@@ -1568,15 +1563,13 @@ pipe_read_block(int pipe_fd, char *indicator, int len, char *msg,
 
     /* only indicator with no value? */
     if(required == 0) {
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
-              "read %d indicator: %c empty value", pipe_fd, *indicator);
+        ws_debug("read %d indicator: %c empty value", pipe_fd, *indicator);
         return 4;
     }
 
     /* does the data fit into the given buffer? */
     if(required > len) {
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
-              "read %d length error, required %d > len %d, header: 0x%02x 0x%02x 0x%02x 0x%02x",
+        ws_debug("read %d length error, required %d > len %d, header: 0x%02x 0x%02x 0x%02x 0x%02x",
               pipe_fd, required, len,
               header[0], header[1], header[2], header[3]);
 
@@ -1584,8 +1577,7 @@ pipe_read_block(int pipe_fd, char *indicator, int len, char *msg,
         memcpy(msg, header, sizeof(header));
         newly = ws_read(pipe_fd, &msg[sizeof(header)], len-sizeof(header));
         if (newly < 0) { /* error */
-            g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
-                  "read from pipe %d: error(%u): %s", pipe_fd, errno, g_strerror(errno));
+            ws_debug("read from pipe %d: error(%u): %s", pipe_fd, errno, g_strerror(errno));
         }
         *err_msg = g_strdup_printf("Unknown message from dumpcap reading header, try to show it as a string: %s",
                                    msg);
@@ -1604,9 +1596,7 @@ pipe_read_block(int pipe_fd, char *indicator, int len, char *msg,
     }
 
     /* XXX If message is "2part", the msg probably won't be sent to debug log correctly */
-    g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
-          "read %d ok indicator: %c len: %u msg: %s", pipe_fd, *indicator,
-          len, msg);
+    ws_debug("read %d ok indicator: %c len: %u msg: %s", pipe_fd, *indicator, len, msg);
     *err_msg = NULL;
     return newly + 4;
 }
@@ -1672,7 +1662,7 @@ sync_pipe_input_cb(gint source, gpointer user_data)
 #ifdef _WIN32
         ws_close(cap_session->signal_pipe_write_fd);
 #endif
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_pipe_input_cb: cleaning extcap pipe");
+        ws_debug("cleaning extcap pipe");
         extcap_if_cleanup(cap_session->capture_opts, &primary_msg);
         cap_session->closed(cap_session, primary_msg);
         g_free(primary_msg);
@@ -1683,7 +1673,7 @@ sync_pipe_input_cb(gint source, gpointer user_data)
     switch(indicator) {
     case SP_FILE:
         if(!cap_session->new_file(cap_session, buffer)) {
-            g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_pipe_input_cb: file failed, closing capture");
+            ws_debug("file failed, closing capture");
 
             /* We weren't able to open the new capture file; user has been
                alerted. Close the sync pipe. */
@@ -1708,9 +1698,9 @@ sync_pipe_input_cb(gint source, gpointer user_data)
         break;
     case SP_PACKET_COUNT:
         if (!ws_strtou32(buffer, NULL, &npackets)) {
-            g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_WARNING, "Invalid packets number: %s", buffer);
+            ws_warning("Invalid packets number: %s", buffer);
         }
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_pipe_input_cb: new packets %u", npackets);
+        ws_debug("new packets %u", npackets);
         cap_session->count += npackets;
         cap_session->new_packets(cap_session, npackets);
         break;
@@ -1781,7 +1771,7 @@ sync_pipe_wait_for_child(ws_process_id fork_child, gchar **msgp)
 
     start_time = g_get_monotonic_time();
 
-    g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_pipe_wait_for_child: wait till child closed");
+    ws_debug("wait till child closed");
     g_assert(fork_child != WS_INVALID_PID);
 
     *msgp = NULL; /* assume no error */
@@ -1849,7 +1839,7 @@ sync_pipe_wait_for_child(ws_process_id fork_child, gchar **msgp)
                  * kills dumpcap, so we should eventually see that and
                  * clean up and terminate.
                  */
-                g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_WARNING, "sync_pipe_wait_for_child: waitpid returned EINTR. retrying.");
+                ws_warning("waitpid returned EINTR. retrying.");
                 continue;
             } else if (errno == ECHILD) {
                 /*
@@ -1870,7 +1860,7 @@ sync_pipe_wait_for_child(ws_process_id fork_child, gchar **msgp)
 #endif
 
     elapsed = (g_get_monotonic_time() - start_time) / 1e6;
-    g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "sync_pipe_wait_for_child: capture child closed after %.3fs", elapsed);
+    ws_debug("capture child closed after %.3fs", elapsed);
     return ret;
 }
 
@@ -1997,15 +1987,14 @@ signal_pipe_capquit_to_child(capture_session *cap_session)
     const char quit_msg[] = "QUIT";
     int ret;
 
-    g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "signal_pipe_capquit_to_child");
+    ws_debug("signal_pipe_capquit_to_child");
 
     /* it doesn't matter *what* we send here, the first byte will stop the capture */
     /* simply sending a "QUIT" string */
     /*pipe_write_block(cap_session->signal_pipe_write_fd, SP_QUIT, quit_msg);*/
     ret = ws_write(cap_session->signal_pipe_write_fd, quit_msg, sizeof quit_msg);
     if(ret == -1) {
-        g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_WARNING,
-              "signal_pipe_capquit_to_child: %d header: error %s", cap_session->signal_pipe_write_fd, g_strerror(errno));
+        ws_warning("%d header: error %s", cap_session->signal_pipe_write_fd, g_strerror(errno));
     }
 }
 #endif
@@ -2025,8 +2014,7 @@ sync_pipe_stop(capture_session *cap_session)
         /* send the SIGINT signal to close the capture child gracefully. */
         int sts = kill(cap_session->fork_child, SIGINT);
         if (sts != 0) {
-            g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_WARNING,
-                  "Sending SIGINT to child failed: %s\n", g_strerror(errno));
+            ws_warning("Sending SIGINT to child failed: %s\n", g_strerror(errno));
         }
 #else
 #define STOP_SLEEP_TIME 500 /* ms */
@@ -2048,8 +2036,7 @@ sync_pipe_stop(capture_session *cap_session)
 
         /* Force the issue. */
         if (terminate) {
-            g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_WARNING,
-                  "sync_pipe_stop: forcing child to exit");
+            ws_warning("sync_pipe_stop: forcing child to exit");
             sync_pipe_kill(cap_session->fork_child);
         }
 #endif
@@ -2065,8 +2052,7 @@ sync_pipe_kill(ws_process_id fork_child)
 #ifndef _WIN32
         int sts = kill(fork_child, SIGTERM);    /* SIGTERM so it can clean up if necessary */
         if (sts != 0) {
-            g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_WARNING,
-                  "Sending SIGTERM to child failed: %s\n", g_strerror(errno));
+            ws_warning("Sending SIGTERM to child failed: %s\n", g_strerror(errno));
         }
 #else
         /* Remark: This is not the preferred method of closing a process!
diff --git a/capture/capture_win_ifnames.c b/capture/capture_win_ifnames.c
index 90cc1cbffd..f13c4d2699 100644
--- a/capture/capture_win_ifnames.c
+++ b/capture/capture_win_ifnames.c
@@ -31,8 +31,6 @@
 #define NETIO_STATUS DWORD
 #endif
 
-#include "log.h"
-
 #include "capture/capture_ifinfo.h"
 #include "capture/capture_win_ifnames.h"
 
diff --git a/capture_opts.c b/capture_opts.c
index 0c7b7de36d..6bf735b707 100644
--- a/capture_opts.c
+++ b/capture_opts.c
@@ -150,115 +150,115 @@ capture_opts_cleanup(capture_options *capture_opts)
 
 /* log content of capture_opts */
 void
-capture_opts_log(const char *log_domain, GLogLevelFlags log_level, capture_options *capture_opts) {
+capture_opts_log(enum ws_log_domain log_domain, enum ws_log_level log_level, capture_options *capture_opts) {
     guint i;
 
-    g_log(log_domain, log_level, "CAPTURE OPTIONS     :");
+    ws_log(log_domain, log_level, "CAPTURE OPTIONS     :");
 
     for (i = 0; i < capture_opts->ifaces->len; i++) {
         interface_options *interface_opts;
 
         interface_opts = &g_array_index(capture_opts->ifaces, interface_options, i);
-        g_log(log_domain, log_level, "Interface name[%02d]  : %s", i, interface_opts->name ? interface_opts->name : "(unspecified)");
-        g_log(log_domain, log_level, "Interface description[%02d] : %s", i, interface_opts->descr ? interface_opts->descr : "(unspecified)");
-        g_log(log_domain, log_level, "Interface vendor description[%02d] : %s", i, interface_opts->hardware ? interface_opts->hardware : "(unspecified)");
-        g_log(log_domain, log_level, "Display name[%02d]: %s", i, interface_opts->display_name ? interface_opts->display_name : "(unspecified)");
-        g_log(log_domain, log_level, "Capture filter[%02d]  : %s", i, interface_opts->cfilter ? interface_opts->cfilter : "(unspecified)");
-        g_log(log_domain, log_level, "Snap length[%02d] (%u) : %d", i, interface_opts->has_snaplen, interface_opts->snaplen);
-        g_log(log_domain, log_level, "Link Type[%02d]       : %d", i, interface_opts->linktype);
-        g_log(log_domain, log_level, "Promiscuous Mode[%02d]: %s", i, interface_opts->promisc_mode?"TRUE":"FALSE");
-        g_log(log_domain, log_level, "Extcap[%02d]          : %s", i, interface_opts->extcap ? interface_opts->extcap : "(unspecified)");
-        g_log(log_domain, log_level, "Extcap FIFO[%02d]     : %s", i, interface_opts->extcap_fifo ? interface_opts->extcap_fifo : "(unspecified)");
-        g_log(log_domain, log_level, "Extcap PID[%02d]      : %d", i, interface_opts->extcap_pid);
+        ws_log(log_domain, log_level, "Interface name[%02d]  : %s", i, interface_opts->name ? interface_opts->name : "(unspecified)");
+        ws_log(log_domain, log_level, "Interface description[%02d] : %s", i, interface_opts->descr ? interface_opts->descr : "(unspecified)");
+        ws_log(log_domain, log_level, "Interface vendor description[%02d] : %s", i, interface_opts->hardware ? interface_opts->hardware : "(unspecified)");
+        ws_log(log_domain, log_level, "Display name[%02d]: %s", i, interface_opts->display_name ? interface_opts->display_name : "(unspecified)");
+        ws_log(log_domain, log_level, "Capture filter[%02d]  : %s", i, interface_opts->cfilter ? interface_opts->cfilter : "(unspecified)");
+        ws_log(log_domain, log_level, "Snap length[%02d] (%u) : %d", i, interface_opts->has_snaplen, interface_opts->snaplen);
+        ws_log(log_domain, log_level, "Link Type[%02d]       : %d", i, interface_opts->linktype);
+        ws_log(log_domain, log_level, "Promiscuous Mode[%02d]: %s", i, interface_opts->promisc_mode?"TRUE":"FALSE");
+        ws_log(log_domain, log_level, "Extcap[%02d]          : %s", i, interface_opts->extcap ? interface_opts->extcap : "(unspecified)");
+        ws_log(log_domain, log_level, "Extcap FIFO[%02d]     : %s", i, interface_opts->extcap_fifo ? interface_opts->extcap_fifo : "(unspecified)");
+        ws_log(log_domain, log_level, "Extcap PID[%02d]      : %d", i, interface_opts->extcap_pid);
 #ifdef CAN_SET_CAPTURE_BUFFER_SIZE
-        g_log(log_domain, log_level, "Buffer size[%02d]     : %d (MB)", i, interface_opts->buffer_size);
+        ws_log(log_domain, log_level, "Buffer size[%02d]     : %d (MB)", i, interface_opts->buffer_size);
 #endif
-        g_log(log_domain, log_level, "Monitor Mode[%02d]    : %s", i, interface_opts->monitor_mode?"TRUE":"FALSE");
+        ws_log(log_domain, log_level, "Monitor Mode[%02d]    : %s", i, interface_opts->monitor_mode?"TRUE":"FALSE");
 #ifdef HAVE_PCAP_REMOTE
-        g_log(log_domain, log_level, "Capture source[%02d]  : %s", i,
+        ws_log(log_domain, log_level, "Capture source[%02d]  : %s", i,
             interface_opts->src_type == CAPTURE_IFLOCAL ? "Local interface" :
             interface_opts->src_type == CAPTURE_IFREMOTE ? "Remote interface" :
             "Unknown");
         if (interface_opts->src_type == CAPTURE_IFREMOTE) {
-            g_log(log_domain, log_level, "Remote host[%02d]     : %s", i, interface_opts->remote_host ? interface_opts->remote_host : "(unspecified)");
-            g_log(log_domain, log_level, "Remote port[%02d]     : %s", i, interface_opts->remote_port ? interface_opts->remote_port : "(unspecified)");
+            ws_log(log_domain, log_level, "Remote host[%02d]     : %s", i, interface_opts->remote_host ? interface_opts->remote_host : "(unspecified)");
+            ws_log(log_domain, log_level, "Remote port[%02d]     : %s", i, interface_opts->remote_port ? interface_opts->remote_port : "(unspecified)");
         }
-        g_log(log_domain, log_level, "Authentication[%02d]  : %s", i,
+        ws_log(log_domain, log_level, "Authentication[%02d]  : %s", i,
             interface_opts->auth_type == CAPTURE_AUTH_NULL ? "Null" :
             interface_opts->auth_type == CAPTURE_AUTH_PWD ? "By username/password" :
             "Unknown");
         if (interface_opts->auth_type == CAPTURE_AUTH_PWD) {
-            g_log(log_domain, log_level, "Auth username[%02d]   : %s", i, interface_opts->auth_username ? interface_opts->auth_username : "(unspecified)");
-            g_log(log_domain, log_level, "Auth password[%02d]   : <hidden>", i);
+            ws_log(log_domain, log_level, "Auth username[%02d]   : %s", i, interface_opts->auth_username ? interface_opts->auth_username : "(unspecified)");
+            ws_log(log_domain, log_level, "Auth password[%02d]   : <hidden>", i);
         }
-        g_log(log_domain, log_level, "UDP data tfer[%02d]   : %u", i, interface_opts->datatx_udp);
-        g_log(log_domain, log_level, "No cap. RPCAP[%02d]   : %u", i, interface_opts->nocap_rpcap);
-        g_log(log_domain, log_level, "No cap. local[%02d]   : %u", i, interface_opts->nocap_local);
+        ws_log(log_domain, log_level, "UDP data tfer[%02d]   : %u", i, interface_opts->datatx_udp);
+        ws_log(log_domain, log_level, "No cap. RPCAP[%02d]   : %u", i, interface_opts->nocap_rpcap);
+        ws_log(log_domain, log_level, "No cap. local[%02d]   : %u", i, interface_opts->nocap_local);
 #endif
 #ifdef HAVE_PCAP_SETSAMPLING
-        g_log(log_domain, log_level, "Sampling meth.[%02d]  : %d", i, interface_opts->sampling_method);
-        g_log(log_domain, log_level, "Sampling param.[%02d] : %d", i, interface_opts->sampling_param);
+        ws_log(log_domain, log_level, "Sampling meth.[%02d]  : %d", i, interface_opts->sampling_method);
+        ws_log(log_domain, log_level, "Sampling param.[%02d] : %d", i, interface_opts->sampling_param);
 #endif
-        g_log(log_domain, log_level, "Timestamp type [%02d] : %s", i, interface_opts->timestamp_type);
+        ws_log(log_domain, log_level, "Timestamp type [%02d] : %s", i, interface_opts->timestamp_type);
     }
-    g_log(log_domain, log_level, "Interface name[df]  : %s", capture_opts->default_options.name ? capture_opts->default_options.name : "(unspecified)");
-    g_log(log_domain, log_level, "Interface Descr[df] : %s", capture_opts->default_options.descr ? capture_opts->default_options.descr : "(unspecified)");
-    g_log(log_domain, log_level, "Interface Hardware Descr[df] : %s", capture_opts->default_options.hardware ? capture_opts->default_options.hardware : "(unspecified)");
-    g_log(log_domain, log_level, "Interface display name[df] : %s", capture_opts->default_options.display_name ? capture_opts->default_options.display_name : "(unspecified)");
-    g_log(log_domain, log_level, "Capture filter[df]  : %s", capture_opts->default_options.cfilter ? capture_opts->default_options.cfilter : "(unspecified)");
-    g_log(log_domain, log_level, "Snap length[df] (%u) : %d", capture_opts->default_options.has_snaplen, capture_opts->default_options.snaplen);
-    g_log(log_domain, log_level, "Link Type[df]       : %d", capture_opts->default_options.linktype);
-    g_log(log_domain, log_level, "Promiscuous Mode[df]: %s", capture_opts->default_options.promisc_mode?"TRUE":"FALSE");
-    g_log(log_domain, log_level, "Extcap[df]          : %s", capture_opts->default_options.extcap ? capture_opts->default_options.extcap : "(unspecified)");
-    g_log(log_domain, log_level, "Extcap FIFO[df]     : %s", capture_opts->default_options.extcap_fifo ? capture_opts->default_options.extcap_fifo : "(unspecified)");
+    ws_log(log_domain, log_level, "Interface name[df]  : %s", capture_opts->default_options.name ? capture_opts->default_options.name : "(unspecified)");
+    ws_log(log_domain, log_level, "Interface Descr[df] : %s", capture_opts->default_options.descr ? capture_opts->default_options.descr : "(unspecified)");
+    ws_log(log_domain, log_level, "Interface Hardware Descr[df] : %s", capture_opts->default_options.hardware ? capture_opts->default_options.hardware : "(unspecified)");
+    ws_log(log_domain, log_level, "Interface display name[df] : %s", capture_opts->default_options.display_name ? capture_opts->default_options.display_name : "(unspecified)");
+    ws_log(log_domain, log_level, "Capture filter[df]  : %s", capture_opts->default_options.cfilter ? capture_opts->default_options.cfilter : "(unspecified)");
+    ws_log(log_domain, log_level, "Snap length[df] (%u) : %d", capture_opts->default_options.has_snaplen, capture_opts->default_options.snaplen);
+    ws_log(log_domain, log_level, "Link Type[df]       : %d", capture_opts->default_options.linktype);
+    ws_log(log_domain, log_level, "Promiscuous Mode[df]: %s", capture_opts->default_options.promisc_mode?"TRUE":"FALSE");
+    ws_log(log_domain, log_level, "Extcap[df]          : %s", capture_opts->default_options.extcap ? capture_opts->default_options.extcap : "(unspecified)");
+    ws_log(log_domain, log_level, "Extcap FIFO[df]     : %s", capture_opts->default_options.extcap_fifo ? capture_opts->default_options.extcap_fifo : "(unspecified)");
 #ifdef CAN_SET_CAPTURE_BUFFER_SIZE
-    g_log(log_domain, log_level, "Buffer size[df]     : %d (MB)", capture_opts->default_options.buffer_size);
+    ws_log(log_domain, log_level, "Buffer size[df]     : %d (MB)", capture_opts->default_options.buffer_size);
 #endif
-    g_log(log_domain, log_level, "Monitor Mode[df]    : %s", capture_opts->default_options.monitor_mode?"TRUE":"FALSE");
+    ws_log(log_domain, log_level, "Monitor Mode[df]    : %s", capture_opts->default_options.monitor_mode?"TRUE":"FALSE");
 #ifdef HAVE_PCAP_REMOTE
-    g_log(log_domain, log_level, "Capture source[df]  : %s",
+    ws_log(log_domain, log_level, "Capture source[df]  : %s",
         capture_opts->default_options.src_type == CAPTURE_IFLOCAL ? "Local interface" :
         capture_opts->default_options.src_type == CAPTURE_IFREMOTE ? "Remote interface" :
         "Unknown");
     if (capture_opts->default_options.src_type == CAPTURE_IFREMOTE) {
-        g_log(log_domain, log_level, "Remote host[df]     : %s", capture_opts->default_options.remote_host ? capture_opts->default_options.remote_host : "(unspecified)");
-        g_log(log_domain, log_level, "Remote port[df]     : %s", capture_opts->default_options.remote_port ? capture_opts->default_options.remote_port : "(unspecified)");
+        ws_log(log_domain, log_level, "Remote host[df]     : %s", capture_opts->default_options.remote_host ? capture_opts->default_options.remote_host : "(unspecified)");
+        ws_log(log_domain, log_level, "Remote port[df]     : %s", capture_opts->default_options.remote_port ? capture_opts->default_options.remote_port : "(unspecified)");
     }
-    g_log(log_domain, log_level, "Authentication[df]  : %s",
+    ws_log(log_domain, log_level, "Authentication[df]  : %s",
         capture_opts->default_options.auth_type == CAPTURE_AUTH_NULL ? "Null" :
         capture_opts->default_options.auth_type == CAPTURE_AUTH_PWD ? "By username/password" :
         "Unknown");
     if (capture_opts->default_options.auth_type == CAPTURE_AUTH_PWD) {
-        g_log(log_domain, log_level, "Auth username[df]   : %s", capture_opts->default_options.auth_username ? capture_opts->default_options.auth_username : "(unspecified)");
-        g_log(log_domain, log_level, "Auth password[df]   : <hidden>");
+        ws_log(log_domain, log_level, "Auth username[df]   : %s", capture_opts->default_options.auth_username ? capture_opts->default_options.auth_username : "(unspecified)");
+        ws_log(log_domain, log_level, "Auth password[df]   : <hidden>");
     }
-    g_log(log_domain, log_level, "UDP data tfer[df]   : %u", capture_opts->default_options.datatx_udp);
-    g_log(log_domain, log_level, "No cap. RPCAP[df]   : %u", capture_opts->default_options.nocap_rpcap);
-    g_log(log_domain, log_level, "No cap. local[df]   : %u", capture_opts->default_options.nocap_local);
+    ws_log(log_domain, log_level, "UDP data tfer[df]   : %u", capture_opts->default_options.datatx_udp);
+    ws_log(log_domain, log_level, "No cap. RPCAP[df]   : %u", capture_opts->default_options.nocap_rpcap);
+    ws_log(log_domain, log_level, "No cap. local[df]   : %u", capture_opts->default_options.nocap_local);
 #endif
 #ifdef HAVE_PCAP_SETSAMPLING
-    g_log(log_domain, log_level, "Sampling meth. [df] : %d", capture_opts->default_options.sampling_method);
-    g_log(log_domain, log_level, "Sampling param.[df] : %d", capture_opts->default_options.sampling_param);
+    ws_log(log_domain, log_level, "Sampling meth. [df] : %d", capture_opts->default_options.sampling_method);
+    ws_log(log_domain, log_level, "Sampling param.[df] : %d", capture_opts->default_options.sampling_param);
 #endif
-    g_log(log_domain, log_level, "Timestamp type [df] : %s", capture_opts->default_options.timestamp_type ? capture_opts->default_options.timestamp_type : "(unspecified)");
-    g_log(log_domain, log_level, "SavingToFile        : %u", capture_opts->saving_to_file);
-    g_log(log_domain, log_level, "SaveFile            : %s", (capture_opts->save_file) ? capture_opts->save_file : "");
-    g_log(log_domain, log_level, "GroupReadAccess     : %u", capture_opts->group_read_access);
-    g_log(log_domain, log_level, "Fileformat          : %s", (capture_opts->use_pcapng) ? "PCAPNG" : "PCAP");
-    g_log(log_domain, log_level, "RealTimeMode        : %u", capture_opts->real_time_mode);
-    g_log(log_domain, log_level, "ShowInfo            : %u", capture_opts->show_info);
+    ws_log(log_domain, log_level, "Timestamp type [df] : %s", capture_opts->default_options.timestamp_type ? capture_opts->default_options.timestamp_type : "(unspecified)");
+    ws_log(log_domain, log_level, "SavingToFile        : %u", capture_opts->saving_to_file);
+    ws_log(log_domain, log_level, "SaveFile            : %s", (capture_opts->save_file) ? capture_opts->save_file : "");
+    ws_log(log_domain, log_level, "GroupReadAccess     : %u", capture_opts->group_read_access);
+    ws_log(log_domain, log_level, "Fileformat          : %s", (capture_opts->use_pcapng) ? "PCAPNG" : "PCAP");
+    ws_log(log_domain, log_level, "RealTimeMode        : %u", capture_opts->real_time_mode);
+    ws_log(log_domain, log_level, "ShowInfo            : %u", capture_opts->show_info);
 
-    g_log(log_domain, log_level, "MultiFilesOn        : %u", capture_opts->multi_files_on);
-    g_log(log_domain, log_level, "FileDuration    (%u) : %.3f", capture_opts->has_file_duration, capture_opts->file_duration);
-    g_log(log_domain, log_level, "FileInterval    (%u) : %u", capture_opts->has_file_interval, capture_opts->file_interval);
-    g_log(log_domain, log_level, "FilePackets     (%u) : %u", capture_opts->has_file_packets, capture_opts->file_packets);
-    g_log(log_domain, log_level, "RingNumFiles    (%u) : %u", capture_opts->has_ring_num_files, capture_opts->ring_num_files);
-    g_log(log_domain, log_level, "RingPrintFiles  (%u) : %s", capture_opts->print_file_names, (capture_opts->print_file_names ? capture_opts->print_name_to : ""));
+    ws_log(log_domain, log_level, "MultiFilesOn        : %u", capture_opts->multi_files_on);
+    ws_log(log_domain, log_level, "FileDuration    (%u) : %.3f", capture_opts->has_file_duration, capture_opts->file_duration);
+    ws_log(log_domain, log_level, "FileInterval    (%u) : %u", capture_opts->has_file_interval, capture_opts->file_interval);
+    ws_log(log_domain, log_level, "FilePackets     (%u) : %u", capture_opts->has_file_packets, capture_opts->file_packets);
+    ws_log(log_domain, log_level, "RingNumFiles    (%u) : %u", capture_opts->has_ring_num_files, capture_opts->ring_num_files);
+    ws_log(log_domain, log_level, "RingPrintFiles  (%u) : %s", capture_opts->print_file_names, (capture_opts->print_file_names ? capture_opts->print_name_to : ""));
 
-    g_log(log_domain, log_level, "AutostopFiles   (%u) : %u", capture_opts->has_autostop_files, capture_opts->autostop_files);
-    g_log(log_domain, log_level, "AutostopPackets (%u) : %u", capture_opts->has_autostop_packets, capture_opts->autostop_packets);
-    g_log(log_domain, log_level, "AutostopFilesize(%u) : %u (KB)", capture_opts->has_autostop_filesize, capture_opts->autostop_filesize);
-    g_log(log_domain, log_level, "AutostopDuration(%u) : %.3f", capture_opts->has_autostop_duration, capture_opts->autostop_duration);
+    ws_log(log_domain, log_level, "AutostopFiles   (%u) : %u", capture_opts->has_autostop_files, capture_opts->autostop_files);
+    ws_log(log_domain, log_level, "AutostopPackets (%u) : %u", capture_opts->has_autostop_packets, capture_opts->autostop_packets);
+    ws_log(log_domain, log_level, "AutostopFilesize(%u) : %u (KB)", capture_opts->has_autostop_filesize, capture_opts->autostop_filesize);
+    ws_log(log_domain, log_level, "AutostopDuration(%u) : %.3f", capture_opts->has_autostop_duration, capture_opts->autostop_duration);
 }
 
 /*
diff --git a/capture_opts.h b/capture_opts.h
index c815c53586..2c6fffc8a3 100644
--- a/capture_opts.h
+++ b/capture_opts.h
@@ -22,6 +22,7 @@
 
 #include <capture/capture_ifinfo.h>
 #include "ringbuffer.h"
+#include <wsutil/wslog.h>
 
 #ifdef _WIN32
 #include <windows.h>
@@ -338,7 +339,7 @@ capture_opts_add_opt(capture_options *capture_opts, int opt, const char *optarg)
 
 /* log content of capture_opts */
 extern void
-capture_opts_log(const char *log_domain, GLogLevelFlags log_level, capture_options *capture_opts);
+capture_opts_log(enum ws_log_domain domain, enum ws_log_level level, capture_options *capture_opts);
 
 enum caps_query {
     CAPS_QUERY_LINK_TYPES      = 0x1,
diff --git a/cmakeconfig.h.in b/cmakeconfig.h.in
index d03badad62..cfe20395c6 100644
--- a/cmakeconfig.h.in
+++ b/cmakeconfig.h.in
@@ -380,5 +380,6 @@
 #endif
 
 #include <ws_diag_control.h>
+#include <ws_log_domains.h>
 
 #endif /* __CONFIG_H__ */
diff --git a/debian/libwsutil0.symbols b/debian/libwsutil0.symbols
index 6dcc95d870..3449ab932b 100644
--- a/debian/libwsutil0.symbols
+++ b/debian/libwsutil0.symbols
@@ -225,7 +225,20 @@ libwsutil.so.0 libwsutil0 #MINVER#
  ws_inet_pton4@Base 2.1.2
  ws_inet_pton6@Base 2.1.2
  ws_init_sockets@Base 3.1.0
+ ws_log@Base 3.5.0
+ ws_log_add_custom_file@Base 3.5.0
+ ws_log_default_writer@Base 3.5.0
+ ws_log_domain_to_string@Base 3.5.0
  ws_log_full@Base 3.5.0
+ ws_log_get_level@Base 3.5.0
+ ws_log_init@Base 3.5.0
+ ws_log_init_with_data@Base 3.5.0
+ ws_log_level_is_active@Base 3.5.0
+ ws_log_level_to_string@Base 3.5.0
+ ws_log_set_level@Base 3.5.0
+ ws_log_set_level_args@Base 3.5.0
+ ws_log_set_level_str@Base 3.5.0
+ ws_logv@Base 3.5.0
  ws_mempbrk_compile@Base 1.99.4
  ws_mempbrk_exec@Base 1.99.4
  ws_pipe_close@Base 2.6.5
diff --git a/dumpcap.c b/dumpcap.c
index 163f9c69c3..6036dae003 100644
--- a/dumpcap.c
+++ b/dumpcap.c
@@ -8,6 +8,7 @@
  */
 
 #include <config.h>
+#define WS_LOG_DOMAIN LOG_DOMAIN_CAPCHILD
 
 #include <stdio.h>
 #include <stdlib.h> /* for exit() */
@@ -47,6 +48,7 @@
 #include <version_info.h>
 
 #include <wsutil/socket.h>
+#include <wsutil/wslog.h>
 
 #ifdef HAVE_LIBCAP
 # include <sys/prctl.h>
@@ -78,7 +80,6 @@
 #include <capture/capture_sync.h>
 
 #include "wsutil/tempfile.h"
-#include "log.h"
 #include "wsutil/file_util.h"
 #include "wsutil/cpu_info.h"
 #include "wsutil/os_version_info.h"
@@ -326,8 +327,8 @@ static gboolean need_timeout_workaround;
 #define WRITER_THREAD_TIMEOUT 100000 /* usecs */
 
 static void
-console_log_handler(const char *log_domain, GLogLevelFlags log_level,
-                    const char *message, gpointer user_data _U_);
+dumpcap_log_writer(const char *message, enum ws_log_domain domain,
+                    enum ws_log_level level, void *ptr);
 
 /* capture related options */
 static capture_options global_capture_opts;
@@ -510,9 +511,7 @@ static void
 /* ....                                                                      */
 print_caps(const char *pfx) {
     cap_t caps = cap_get_proc();
-    g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
-          "%s: EUID: %d  Capabilities: %s", pfx,
-          geteuid(), cap_to_text(caps, NULL));
+    ws_debug("%s: EUID: %d  Capabilities: %s", pfx, geteuid(), cap_to_text(caps, NULL));
     cap_free(caps);
 }
 #else
@@ -931,8 +930,7 @@ print_statistics_loop(gboolean machine_readable)
          * connections. We avoid collecting stats on them.
          */
         if (!strncmp(if_info->name, "nf", 2)) {
-            g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "Skipping interface %s for stats",
-                if_info->name);
+            ws_debug("Skipping interface %s for stats", if_info->name);
             continue;
         }
 #endif
@@ -1025,10 +1023,8 @@ capture_cleanup_handler(DWORD dwCtrlType)
        user logs out.  (XXX - can we explicitly check whether we're
        running as a service?) */
 
-    g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO,
-        "Console: Control signal");
-    g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
-        "Console: Control signal, CtrlType: %lu", dwCtrlType);
+    ws_info("Console: Control signal");
+    ws_debug("Console: Control signal, CtrlType: %lu", dwCtrlType);
 
     /* Keep capture running if we're a service and a user logs off */
     if (capture_child || (dwCtrlType != CTRL_LOGOFF_EVENT)) {
@@ -1046,11 +1042,6 @@ capture_cleanup_handler(int signum _U_)
        SIGTERM.  We assume that if the user wanted it to keep running
        after they logged out, they'd have nohupped it. */
 
-    /* Note: don't call g_log() in the signal handler: if we happened to be in
-     * g_log() in process context when the signal came in, g_log will detect
-     * the "recursion" and abort.
-     */
-
     capture_loop_stop();
 }
 #endif
@@ -1452,7 +1443,7 @@ cap_pipe_read_data_bytes(capture_src *pcap_src, char *errmsg, size_t errmsgl)
     ssize_t b;
 
 #ifdef LOG_CAPTURE_VERBOSE
-    g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "cap_pipe_read_data_bytes read %lu of %lu",
+    ws_debug("cap_pipe_read_data_bytes read %lu of %lu",
           pcap_src->cap_pipe_bytes_read, pcap_src->cap_pipe_bytes_to_read);
 #endif
     sz = pcap_src->cap_pipe_bytes_to_read - pcap_src->cap_pipe_bytes_read;
@@ -1501,7 +1492,7 @@ cap_pipe_read_data_bytes(capture_src *pcap_src, char *errmsg, size_t errmsgl)
     }
     pcap_src->cap_pipe_bytes_read += bytes_read;
 #ifdef LOG_CAPTURE_VERBOSE
-    g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "cap_pipe_read_data_bytes read %lu of %lu",
+    ws_debug("cap_pipe_read_data_bytes read %lu of %lu",
           pcap_src->cap_pipe_bytes_read, pcap_src->cap_pipe_bytes_to_read);
 #endif
     return bytes_read;
@@ -1552,7 +1543,7 @@ cap_pipe_open_live(char *pipename,
     pcap_src->cap_pipe_h = INVALID_HANDLE_VALUE;
 #endif
 
-    g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "cap_pipe_open_live: %s", pipename);
+    ws_debug("cap_pipe_open_live: %s", pipename);
 
     /*
      * XXX - this blocks until a pcap per-file header has been written to
@@ -1868,7 +1859,7 @@ cap_pipe_open_live(char *pipename,
     return;
 
 error:
-    g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "cap_pipe_open_live: error %s", errmsg);
+    ws_debug("cap_pipe_open_live: error %s", errmsg);
     pcap_src->cap_pipe_err = PIPERR;
     cap_pipe_close(fd, pcap_src->from_cap_socket);
     pcap_src->cap_pipe_fd = -1;
@@ -1992,7 +1983,7 @@ pcap_pipe_open_live(int fd,
     return;
 
 error:
-    g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "pcap_pipe_open_live: error %s", errmsg);
+    ws_debug("pcap_pipe_open_live: error %s", errmsg);
     pcap_src->cap_pipe_err = PIPERR;
     cap_pipe_close(fd, pcap_src->from_cap_socket);
     pcap_src->cap_pipe_fd = -1;
@@ -2043,10 +2034,10 @@ pcapng_read_shb(capture_src *pcap_src,
     switch (shb.magic)
     {
     case PCAPNG_MAGIC:
-        g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "pcapng SHB MAGIC");
+        ws_debug("pcapng SHB MAGIC");
         break;
     case PCAPNG_SWAPPED_MAGIC:
-        g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "pcapng SHB SWAPPED MAGIC");
+        ws_debug("pcapng SHB SWAPPED MAGIC");
         /*
          * pcapng sources can contain all sorts of block types.
          * Rather than add a bunch of complexity to this code (which is
@@ -2141,7 +2132,7 @@ pcapng_adjust_block(capture_src *pcap_src, const pcapng_block_header_t *bh, u_ch
                 g_free(idb_source->idb);
                 memset(idb_source, 0, sizeof(saved_idb_t));
                 idb_source->deleted = TRUE;
-                g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "%s: deleted pcapng IDB %u", G_STRFUNC, iface_id);
+                ws_debug("%s: deleted pcapng IDB %u", G_STRFUNC, iface_id);
             }
         }
         g_array_set_size(pcap_src->cap_pipe_info.pcapng.src_iface_to_global, 0);
@@ -2160,7 +2151,7 @@ pcapng_adjust_block(capture_src *pcap_src, const pcapng_block_header_t *bh, u_ch
         g_array_append_val(global_ld.saved_idbs, idb_source);
         guint32 iface_id = global_ld.saved_idbs->len - 1;
         g_array_append_val(pcap_src->cap_pipe_info.pcapng.src_iface_to_global, iface_id);
-        g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "%s: mapped pcapng IDB %u -> %u from source %u",
+        ws_debug("%s: mapped pcapng IDB %u -> %u from source %u",
               G_STRFUNC, pcap_src->cap_pipe_info.pcapng.src_iface_to_global->len - 1, iface_id, pcap_src->interface_id);
     }
         break;
@@ -2178,7 +2169,7 @@ pcapng_adjust_block(capture_src *pcap_src, const pcapng_block_header_t *bh, u_ch
             memcpy(pd + sizeof(pcapng_block_header_t),
                    &g_array_index(pcap_src->cap_pipe_info.pcapng.src_iface_to_global, guint32, iface_id), 4);
         } else {
-            g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "%s: pcapng EPB or ISB interface id %u > max %u", G_STRFUNC, iface_id, pcap_src->cap_pipe_info.pcapng.src_iface_to_global->len);
+            ws_debug("%s: pcapng EPB or ISB interface id %u > max %u", G_STRFUNC, iface_id, pcap_src->cap_pipe_info.pcapng.src_iface_to_global->len);
             return FALSE;
         }
     }
@@ -2203,7 +2194,7 @@ pcapng_pipe_open_live(int fd,
     guint32 type = BLOCK_TYPE_SHB;
     pcapng_block_header_t *bh = &pcap_src->cap_pipe_info.pcapng.bh;
 
-    g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "pcapng_pipe_open_live: fd %d", fd);
+    ws_debug("pcapng_pipe_open_live: fd %d", fd);
 
     /*
      * A pcapng block begins with the block type followed by the block
@@ -2266,7 +2257,7 @@ pcapng_pipe_open_live(int fd,
     return;
 
 error:
-    g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "pcapng_pipe_open_live: error %s", errmsg);
+    ws_debug("pcapng_pipe_open_live: error %s", errmsg);
     pcap_src->cap_pipe_err = PIPERR;
     cap_pipe_close(fd, pcap_src->from_cap_socket);
     pcap_src->cap_pipe_fd = -1;
@@ -2291,7 +2282,7 @@ pcap_pipe_dispatch(loop_data *ld, capture_src *pcap_src, char *errmsg, size_t er
     pcap_pipe_info_t *pcap_info = &pcap_src->cap_pipe_info.pcap;
 
 #ifdef LOG_CAPTURE_VERBOSE
-    g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "pcap_pipe_dispatch");
+    ws_debug("pcap_pipe_dispatch");
 #endif
 
     switch (pcap_src->cap_pipe_state) {
@@ -2531,14 +2522,14 @@ pcapng_pipe_dispatch(loop_data *ld, capture_src *pcap_src, char *errmsg, size_t
     pcapng_block_header_t *bh = &pcap_src->cap_pipe_info.pcapng.bh;
 
 #ifdef LOG_CAPTURE_VERBOSE
-    g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "pcapng_pipe_dispatch");
+    ws_debug("pcapng_pipe_dispatch");
 #endif
 
     switch (pcap_src->cap_pipe_state) {
 
     case STATE_EXPECT_REC_HDR:
 #ifdef LOG_CAPTURE_VERBOSE
-        g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "pcapng_pipe_dispatch STATE_EXPECT_REC_HDR");
+        ws_debug("pcapng_pipe_dispatch STATE_EXPECT_REC_HDR");
 #endif
 #ifdef _WIN32
         if (g_mutex_trylock(pcap_src->cap_pipe_read_mtx)) {
@@ -2560,7 +2551,7 @@ pcapng_pipe_dispatch(loop_data *ld, capture_src *pcap_src, char *errmsg, size_t
 
     case STATE_READ_REC_HDR:
 #ifdef LOG_CAPTURE_VERBOSE
-        g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "pcapng_pipe_dispatch STATE_READ_REC_HDR");
+        ws_debug("pcapng_pipe_dispatch STATE_READ_REC_HDR");
 #endif
 #ifdef _WIN32
         if (pcap_src->from_cap_socket) {
@@ -2593,7 +2584,7 @@ pcapng_pipe_dispatch(loop_data *ld, capture_src *pcap_src, char *errmsg, size_t
 
     case STATE_EXPECT_DATA:
 #ifdef LOG_CAPTURE_VERBOSE
-        g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "pcapng_pipe_dispatch STATE_EXPECT_DATA");
+        ws_debug("pcapng_pipe_dispatch STATE_EXPECT_DATA");
 #endif
 #ifdef _WIN32
         if (g_mutex_trylock(pcap_src->cap_pipe_read_mtx)) {
@@ -2615,7 +2606,7 @@ pcapng_pipe_dispatch(loop_data *ld, capture_src *pcap_src, char *errmsg, size_t
 
     case STATE_READ_DATA:
 #ifdef LOG_CAPTURE_VERBOSE
-        g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "pcapng_pipe_dispatch STATE_READ_DATA");
+        ws_debug("pcapng_pipe_dispatch STATE_READ_DATA");
 #endif
 #ifdef _WIN32
         if (pcap_src->from_cap_socket) {
@@ -2808,7 +2799,7 @@ capture_loop_open_input(capture_options *capture_opts, loop_data *ld,
         g_rw_lock_writer_lock (&ld->saved_shb_idb_lock);
         g_array_append_val(global_ld.saved_idbs, idb_source);
         g_rw_lock_writer_unlock (&ld->saved_shb_idb_lock);
-        g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "%s: saved capture_opts IDB %u",
+        ws_debug("%s: saved capture_opts IDB %u",
               G_STRFUNC, i);
 
 #ifdef MUST_DO_SELECT
@@ -2831,7 +2822,7 @@ capture_loop_open_input(capture_options *capture_opts, loop_data *ld,
 #endif
         g_array_append_val(ld->pcaps, pcap_src);
 
-        g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_open_input : %s", interface_opts->name);
+        ws_debug("capture_loop_open_input : %s", interface_opts->name);
         pcap_src->pcap_h = open_capture_device(capture_opts, interface_opts,
             CAP_READ_TIMEOUT, &open_err, &open_err_str);
 
@@ -2963,7 +2954,7 @@ capture_loop_open_input(capture_options *capture_opts, loop_data *ld,
          */
         ld->pcapng_passthrough = TRUE;
         g_rw_lock_writer_lock (&ld->saved_shb_idb_lock);
-        g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "%s: Clearing %u interfaces for passthrough",
+        ws_debug("%s: Clearing %u interfaces for passthrough",
               G_STRFUNC, global_ld.saved_idbs->len);
         g_array_set_size(global_ld.saved_idbs, 0);
         g_rw_lock_writer_unlock (&ld->saved_shb_idb_lock);
@@ -2988,7 +2979,7 @@ static void capture_loop_close_input(loop_data *ld)
     guint        i;
     capture_src *pcap_src;
 
-    g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_close_input");
+    ws_debug("capture_loop_close_input");
 
     for (i = 0; i < ld->pcaps->len; i++) {
         pcap_src = g_array_index(ld->pcaps, capture_src *, i);
@@ -3017,7 +3008,7 @@ static void capture_loop_close_input(loop_data *ld)
         } else {
             /* Capture device.  If open, close the pcap_t. */
             if (pcap_src->pcap_h != NULL) {
-                g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_close_input: closing %p", (void *)pcap_src->pcap_h);
+                ws_debug("capture_loop_close_input: closing %p", (void *)pcap_src->pcap_h);
                 pcap_close(pcap_src->pcap_h);
                 pcap_src->pcap_h = NULL;
             }
@@ -3035,7 +3026,7 @@ capture_loop_init_filter(pcap_t *pcap_h, gboolean from_cap_pipe,
 {
     struct bpf_program fcode;
 
-    g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_init_filter: %s", cfilter);
+    ws_debug("capture_loop_init_filter: %s", cfilter);
 
     /* capture filters only work on real interfaces */
     if (cfilter && !from_cap_pipe) {
@@ -3072,7 +3063,7 @@ capture_loop_init_pcapng_output(capture_options *capture_opts, loop_data *ld,
 
     if (ld->pcapng_passthrough && !ld->saved_shb) {
         /* We have a single pcapng capture interface and this is the first or only output file. */
-        g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "%s: skipping dumpcap SHB and IDBs in favor of source", G_STRFUNC);
+        ws_debug("%s: skipping dumpcap SHB and IDBs in favor of source", G_STRFUNC);
         g_rw_lock_reader_unlock (&ld->saved_shb_idb_lock);
         return TRUE;
     }
@@ -3092,7 +3083,7 @@ capture_loop_init_pcapng_output(capture_options *capture_opts, loop_data *ld,
 
         successful = pcapng_write_block(ld->pdh, ld->saved_shb, bh.block_total_length, &ld->bytes_written, err);
 
-        g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "%s: wrote saved passthrough SHB %d", G_STRFUNC, successful);
+        ws_debug("%s: wrote saved passthrough SHB %d", G_STRFUNC, successful);
     } else {
         GString *cpu_info_str = g_string_new("");
         get_cpu_info(cpu_info_str);
@@ -3105,7 +3096,7 @@ capture_loop_init_pcapng_output(capture_options *capture_opts, loop_data *ld,
                                                        -1,                          /* section_length */
                                                        &ld->bytes_written,
                                                        err);
-        g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "%s: wrote dumpcap SHB %d", G_STRFUNC, successful);
+        ws_debug("%s: wrote dumpcap SHB %d", G_STRFUNC, successful);
         g_string_free(cpu_info_str, TRUE);
     }
 
@@ -3138,10 +3129,10 @@ capture_loop_init_pcapng_output(capture_options *capture_opts, loop_data *ld,
                                                                   0,                                /* IDB_IF_SPEED      8 */
                                                                   6,                                /* IDB_TSRESOL       9 */
                                                                   &global_ld.err);
-            g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "%s: skipping deleted pcapng IDB %u", G_STRFUNC, i);
+            ws_debug("%s: skipping deleted pcapng IDB %u", G_STRFUNC, i);
         } else if (idb_source.idb && idb_source.idb_len) {
             successful = pcapng_write_block(global_ld.pdh, idb_source.idb, idb_source.idb_len, &ld->bytes_written, err);
-            g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "%s: wrote pcapng IDB %d", G_STRFUNC, successful);
+            ws_debug("%s: wrote pcapng IDB %d", G_STRFUNC, successful);
         } else if (idb_source.interface_id < capture_opts->ifaces->len) {
             unsigned if_id = idb_source.interface_id;
             interface_options *interface_opts = &g_array_index(capture_opts->ifaces, interface_options, if_id);
@@ -3164,7 +3155,7 @@ capture_loop_init_pcapng_output(capture_options *capture_opts, loop_data *ld,
                                                                   0,                          /* IDB_IF_SPEED      8 */
                                                                   pcap_src->ts_nsec ? 9 : 6,  /* IDB_TSRESOL       9 */
                                                                   &global_ld.err);
-            g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "%s: wrote capture_opts IDB %d: %d", G_STRFUNC, if_id, successful);
+            ws_debug("%s: wrote capture_opts IDB %d: %d", G_STRFUNC, if_id, successful);
         }
     }
     g_rw_lock_reader_unlock (&ld->saved_shb_idb_lock);
@@ -3180,7 +3171,7 @@ capture_loop_init_output(capture_options *capture_opts, loop_data *ld, char *err
 {
     int err = 0;
 
-    g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_init_output");
+    ws_debug("capture_loop_init_output");
 
     if ((capture_opts->use_pcapng == FALSE) &&
         (capture_opts->ifaces->len > 1)) {
@@ -3210,7 +3201,7 @@ capture_loop_init_output(capture_options *capture_opts, loop_data *ld, char *err
             /* Increase the size of the IO buffer */
             ld->io_buffer = (char *)g_malloc(buffsize);
             setvbuf(ld->pdh, ld->io_buffer, _IOFBF, buffsize);
-            g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_init_output: buffsize %zu", buffsize);
+            ws_debug("capture_loop_init_output: buffsize %zu", buffsize);
         }
     }
     if (ld->pdh) {
@@ -3265,7 +3256,7 @@ capture_loop_close_output(capture_options *capture_opts, loop_data *ld, int *err
     guint64      end_time = create_timestamp();
     gboolean success;
 
-    g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_close_output");
+    ws_debug("capture_loop_close_output");
 
     if (capture_opts->multi_files_on) {
         return ringbuf_libpcap_dump_close(&capture_opts->save_file, err_close);
@@ -3333,7 +3324,7 @@ capture_loop_dispatch(loop_data *ld,
     if (pcap_src->from_cap_pipe) {
         /* dispatch from capture pipe */
 #ifdef LOG_CAPTURE_VERBOSE
-        g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_dispatch: from capture pipe");
+        ws_debug("capture_loop_dispatch: from capture pipe");
 #endif
 #ifdef _WIN32
         if (pcap_src->from_cap_socket) {
@@ -3362,7 +3353,7 @@ capture_loop_dispatch(loop_data *ld,
              */
             inpkts = pcap_src->cap_pipe_dispatch(ld, pcap_src, errmsg, errmsg_len);
             if (inpkts < 0) {
-                g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "%s: src %u pipe reached EOF or err, rcv: %u drop: %u flush: %u",
+                ws_debug("%s: src %u pipe reached EOF or err, rcv: %u drop: %u flush: %u",
                       G_STRFUNC, pcap_src->interface_id, pcap_src->received, pcap_src->dropped, pcap_src->flushed);
                 g_assert(pcap_src->cap_pipe_err != PIPOK);
             }
@@ -3386,7 +3377,7 @@ capture_loop_dispatch(loop_data *ld,
          * later, so it can use pcap_breakloop().
          */
 #ifdef LOG_CAPTURE_VERBOSE
-        g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_dispatch: from pcap_dispatch with select");
+        ws_debug("capture_loop_dispatch: from pcap_dispatch with select");
 #endif
         if (pcap_src->pcap_fd != -1) {
             sel_ret = cap_pipe_select(pcap_src->pcap_fd);
@@ -3427,7 +3418,7 @@ capture_loop_dispatch(loop_data *ld,
             /* dispatch from pcap without select */
 #if 1
 #ifdef LOG_CAPTURE_VERBOSE
-            g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_dispatch: from pcap_dispatch");
+            ws_debug("capture_loop_dispatch: from pcap_dispatch");
 #endif
 #ifdef _WIN32
             /*
@@ -3457,7 +3448,7 @@ capture_loop_dispatch(loop_data *ld,
             }
 #else /* pcap_next_ex */
 #ifdef LOG_CAPTURE_VERBOSE
-            g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_dispatch: from pcap_next_ex");
+            ws_debug("capture_loop_dispatch: from pcap_next_ex");
 #endif
             /* XXX - this is currently unused, as there is some confusion with pcap_next_ex() vs. pcap_dispatch() */
 
@@ -3496,7 +3487,7 @@ capture_loop_dispatch(loop_data *ld,
     }
 
 #ifdef LOG_CAPTURE_VERBOSE
-    g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_dispatch: %d new packet%s", inpkts, plurality(inpkts, "", "s"));
+    ws_debug("capture_loop_dispatch: %d new packet%s", inpkts, plurality(inpkts, "", "s"));
 #endif
 
     return ld->packets_captured - packet_count_before;
@@ -3538,7 +3529,7 @@ capture_loop_open_output(capture_options *capture_opts, int *save_file_fd,
     gboolean  is_tempfile;
     GError   *err_tempfile = NULL;
 
-    g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_open_output: %s",
+    ws_debug("capture_loop_open_output: %s",
           (capture_opts->save_file) ? capture_opts->save_file : "(not specified)");
 
     if (capture_opts->save_file != NULL) {
@@ -3790,8 +3781,7 @@ pcap_read_handler(void* arg)
     capture_src *pcap_src = (capture_src *)arg;
     char         errmsg[MSG_MAX_LENGTH+1];
 
-    g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "Started thread for interface %d.",
-          pcap_src->interface_id);
+    ws_info("Started thread for interface %d.", pcap_src->interface_id);
 
     /* If this is a pipe input it might finish early. */
     while (global_ld.go && pcap_src->cap_pipe_err == PIPOK) {
@@ -3799,8 +3789,7 @@ pcap_read_handler(void* arg)
         capture_loop_dispatch(&global_ld, errmsg, sizeof(errmsg), pcap_src);
     }
 
-    g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "Stopped thread for interface %d.",
-          pcap_src->interface_id);
+    ws_info("Stopped thread for interface %d.", pcap_src->interface_id);
     g_thread_exit(NULL);
     return (NULL);
 }
@@ -3823,8 +3812,7 @@ capture_loop_dequeue_packet(void) {
     g_async_queue_unlock(pcap_queue);
     if (queue_element) {
         if (queue_element->pcap_src->from_pcapng) {
-            g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO,
-                  "Dequeued a block of type 0x%08x of length %d captured on interface %d.",
+            ws_info("Dequeued a block of type 0x%08x of length %d captured on interface %d.",
                   queue_element->u.bh.block_type, queue_element->u.bh.block_total_length,
                   queue_element->pcap_src->interface_id);
 
@@ -3832,8 +3820,7 @@ capture_loop_dequeue_packet(void) {
                                         &queue_element->u.bh,
                                         queue_element->pd);
         } else {
-            g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO,
-                "Dequeued a packet of length %d captured on interface %d.",
+            ws_info("Dequeued a packet of length %d captured on interface %d.",
                 queue_element->u.phdr.caplen, queue_element->pcap_src->interface_id);
 
             capture_loop_write_packet_cb((u_char *) queue_element->pcap_src,
@@ -3935,8 +3922,8 @@ capture_loop_start(capture_options *capture_opts, gboolean *stats_known, struct
     /* We haven't yet gotten the capture statistics. */
     *stats_known      = FALSE;
 
-    g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "Capture loop starting ...");
-    capture_opts_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, capture_opts);
+    ws_info("Capture loop starting ...");
+    capture_opts_log(LOG_DOMAIN_CAPCHILD, LOG_LEVEL_DEBUG, capture_opts);
 
     /* open the "input file" from network interface or capture pipe */
     if (!capture_loop_open_input(capture_opts, &global_ld, errmsg, sizeof(errmsg),
@@ -4031,8 +4018,8 @@ capture_loop_start(capture_options *capture_opts, gboolean *stats_known, struct
     gettimeofday(&upd_time, NULL);
 #endif
     start_time = create_timestamp();
-    g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "Capture loop running.");
-    capture_opts_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, capture_opts);
+    ws_info("Capture loop running.");
+    capture_opts_log(LOG_DOMAIN_CAPCHILD, LOG_LEVEL_DEBUG, capture_opts);
 
     /* WOW, everything is prepared! */
     /* please fasten your seat belts, we will enter now the actual capture loop */
@@ -4158,16 +4145,14 @@ capture_loop_start(capture_options *capture_opts, gboolean *stats_known, struct
         }
     }
 
-    g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "Capture loop stopping ...");
+    ws_info("Capture loop stopping ...");
     if (use_threads) {
 
         for (i = 0; i < global_ld.pcaps->len; i++) {
             pcap_src = g_array_index(global_ld.pcaps, capture_src *, i);
-            g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "Waiting for thread of interface %u...",
-                  pcap_src->interface_id);
+            ws_info("Waiting for thread of interface %u...", pcap_src->interface_id);
             g_thread_join(pcap_src->tid);
-            g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "Thread of interface %u terminated.",
-                  pcap_src->interface_id);
+            ws_info("Thread of interface %u terminated.", pcap_src->interface_id);
         }
         while (1) {
             gboolean dequeued = capture_loop_dequeue_packet();
@@ -4374,7 +4359,7 @@ capture_loop_start(capture_options *capture_opts, gboolean *stats_known, struct
     /* close the input file (pcap or capture pipe) */
     capture_loop_close_input(&global_ld);
 
-    g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "Capture loop stopped.");
+    ws_info("Capture loop stopped.");
 
     /* ok, if the write and the close were successful. */
     return write_ok && close_ok;
@@ -4404,7 +4389,7 @@ error:
     /* close the input file (pcap or cap_pipe) */
     capture_loop_close_input(&global_ld);
 
-    g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "Capture loop stopped with error");
+    ws_info("Capture loop stopped with error");
 
     return FALSE;
 }
@@ -4531,7 +4516,7 @@ capture_loop_write_pcapng_cb(capture_src *pcap_src, const pcapng_block_header_t
     }
 
     if (!pcapng_adjust_block(pcap_src, bh, pd)) {
-        g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "%s failed to adjust pcapng block.", G_STRFUNC);
+        ws_info("%s failed to adjust pcapng block.", G_STRFUNC);
         g_assert_not_reached();
         return;
     }
@@ -4564,8 +4549,7 @@ capture_loop_write_pcapng_cb(capture_src *pcap_src, const pcapng_block_header_t
         } else if (bh->block_type == BLOCK_TYPE_EPB || bh->block_type == BLOCK_TYPE_SPB || bh->block_type == BLOCK_TYPE_SYSTEMD_JOURNAL) {
             /* count packet only if we actually have an EPB or SPB */
 #if defined(DEBUG_DUMPCAP) || defined(DEBUG_CHILD_DUMPCAP)
-            g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO,
-                  "Wrote a pcapng block type %u of length %d captured on interface %u.",
+            ws_info("Wrote a pcapng block type %u of length %d captured on interface %u.",
                    bh->block_type, bh->block_total_length, pcap_src->interface_id);
 #endif
             capture_loop_wrote_one_packet(pcap_src);
@@ -4582,7 +4566,7 @@ capture_loop_write_packet_cb(u_char *pcap_src_p, const struct pcap_pkthdr *phdr,
     int          err;
     guint        ts_mul    = pcap_src->ts_nsec ? 1000000000 : 1000000;
 
-    g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "capture_loop_write_packet_cb");
+    ws_debug("capture_loop_write_packet_cb");
 
     /* We may be called multiple times from pcap_dispatch(); if we've set
        the "stop capturing" flag, ignore this packet, as we're not
@@ -4620,8 +4604,7 @@ capture_loop_write_packet_cb(u_char *pcap_src_p, const struct pcap_pkthdr *phdr,
             pcap_src->dropped++;
         } else {
 #if defined(DEBUG_DUMPCAP) || defined(DEBUG_CHILD_DUMPCAP)
-            g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO,
-                  "Wrote a pcap packet of length %d captured on interface %u.",
+            ws_info("Wrote a pcap packet of length %d captured on interface %u.",
                    phdr->caplen, pcap_src->interface_id);
 #endif
             capture_loop_wrote_one_packet(pcap_src);
@@ -4675,19 +4658,16 @@ capture_loop_queue_packet_cb(u_char *pcap_src_p, const struct pcap_pkthdr *phdr,
         pcap_src->dropped++;
         g_free(queue_element->pd);
         g_free(queue_element);
-        g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO,
-              "Dropped a packet of length %d captured on interface %u.",
+        ws_info("Dropped a packet of length %d captured on interface %u.",
               phdr->caplen, pcap_src->interface_id);
     } else {
         pcap_src->received++;
-        g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO,
-              "Queued a packet of length %d captured on interface %u.",
+        ws_info("Queued a packet of length %d captured on interface %u.",
               phdr->caplen, pcap_src->interface_id);
     }
     /* I don't want to hold the mutex over the debug output. So the
        output may be wrong */
-    g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO,
-          "Queue size is now %" G_GINT64_MODIFIER "d bytes (%" G_GINT64_MODIFIER "d packets)",
+    ws_info("Queue size is now %" G_GINT64_MODIFIER "d bytes (%" G_GINT64_MODIFIER "d packets)",
           pcap_queue_bytes, pcap_queue_packets);
 }
 
@@ -4735,19 +4715,16 @@ capture_loop_queue_pcapng_cb(capture_src *pcap_src, const pcapng_block_header_t
         pcap_src->dropped++;
         g_free(queue_element->pd);
         g_free(queue_element);
-        g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO,
-              "Dropped a packet of length %d captured on interface %u.",
+        ws_info("Dropped a packet of length %d captured on interface %u.",
               bh->block_total_length, pcap_src->interface_id);
     } else {
         pcap_src->received++;
-        g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO,
-              "Queued a block of type 0x%08x of length %d captured on interface %u.",
+        ws_info("Queued a block of type 0x%08x of length %d captured on interface %u.",
               bh->block_type, bh->block_total_length, pcap_src->interface_id);
     }
     /* I don't want to hold the mutex over the debug output. So the
        output may be wrong */
-    g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO,
-          "Queue size is now %" G_GINT64_MODIFIER "d bytes (%" G_GINT64_MODIFIER "d packets)",
+    ws_info("Queue size is now %" G_GINT64_MODIFIER "d bytes (%" G_GINT64_MODIFIER "d packets)",
           pcap_queue_bytes, pcap_queue_packets);
 }
 
@@ -4852,7 +4829,6 @@ main(int argc, char *argv[])
 
     gboolean          stats_known;
     struct pcap_stat  stats = {0};
-    GLogLevelFlags    log_flags;
     gboolean          list_interfaces       = FALSE;
     int               caps_queries          = 0;
     gboolean          print_bpf_code        = FALSE;
@@ -4868,8 +4844,19 @@ main(int argc, char *argv[])
 #endif
     GString          *str;
 
+    /* Initialize log handler early so we can have proper logging during startup. */
+    ws_log_init(dumpcap_log_writer);
+
     cmdarg_err_init(dumpcap_cmdarg_err, dumpcap_cmdarg_err_cont);
 
+    /* Command line options are parsed too late to configure logging, do it
+        manually. */
+    const char *opt_err_val;
+    if ((opt_err_val = ws_log_set_level_args(&argc, argv)) != NULL) {
+        cmdarg_err("Invalid log level \"%s\"", opt_err_val);
+        exit (1);
+    }
+
 #ifdef _WIN32
     create_app_running_mutex();
 
@@ -4969,37 +4956,6 @@ main(int argc, char *argv[])
         }
     }
 
-    /* The default_log_handler will use stdout, which makes trouble in   */
-    /* capture child mode, as it uses stdout for its sync_pipe.          */
-    /* So: the filtering is done in the console_log_handler and not here.*/
-    /* We set the log handlers right up front to make sure that any log  */
-    /* messages when running as child will be sent back to the parent    */
-    /* with the correct format.                                          */
-
-    log_flags =
-        (GLogLevelFlags)(
-        G_LOG_LEVEL_ERROR|
-        G_LOG_LEVEL_CRITICAL|
-        G_LOG_LEVEL_WARNING|
-        G_LOG_LEVEL_MESSAGE|
-        G_LOG_LEVEL_INFO|
-        G_LOG_LEVEL_DEBUG|
-        G_LOG_FLAG_FATAL|
-        G_LOG_FLAG_RECURSION);
-
-    g_log_set_handler(NULL,
-                      log_flags,
-                      console_log_handler, NULL /* user_data */);
-    g_log_set_handler(LOG_DOMAIN_MAIN,
-                      log_flags,
-                      console_log_handler, NULL /* user_data */);
-    g_log_set_handler(LOG_DOMAIN_CAPTURE,
-                      log_flags,
-                      console_log_handler, NULL /* user_data */);
-    g_log_set_handler(LOG_DOMAIN_CAPTURE_CHILD,
-                      log_flags,
-                      console_log_handler, NULL /* user_data */);
-
     /* Initialize the pcaps list and IDBs */
     global_ld.pcaps = g_array_new(FALSE, FALSE, sizeof(capture_src *));
     global_ld.pcapng_passthrough = FALSE;
@@ -5009,10 +4965,10 @@ main(int argc, char *argv[])
     err_msg = ws_init_sockets();
     if (err_msg != NULL)
     {
-        g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_ERROR,
+        ws_log(LOG_DOMAIN_CAPCHILD, LOG_LEVEL_ERROR,
                           "ERROR: %s", err_msg);
         g_free(err_msg);
-        g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_ERROR,
+        ws_log(LOG_DOMAIN_CAPCHILD, LOG_LEVEL_ERROR,
                           "%s", please_report_bug());
         exit_main(1);
     }
@@ -5237,8 +5193,7 @@ main(int argc, char *argv[])
                                              GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL);
 
                 if (sig_pipe_handle == INVALID_HANDLE_VALUE) {
-                    g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO,
-                          "Signal pipe: Unable to open %s.  Dead parent?",
+                    ws_info("Signal pipe: Unable to open %s.  Dead parent?",
                           sig_pipe_name);
                     exit_main(1);
                 }
@@ -5535,8 +5490,7 @@ main(int argc, char *argv[])
             interface_options *interface_opts;
 
             interface_opts = &g_array_index(global_capture_opts.ifaces, interface_options, j);
-            g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "Interface: %s\n",
-                  interface_opts->name);
+            ws_debug("Interface: %s\n", interface_opts->name);
         }
     } else {
         str = g_string_new("");
@@ -5613,92 +5567,29 @@ main(int argc, char *argv[])
 }
 
 static void
-console_log_handler(const char *log_domain, GLogLevelFlags log_level,
-                    const char *message, gpointer user_data _U_)
+dumpcap_log_writer(const char *message, enum ws_log_domain domain _U_,
+                    enum ws_log_level level _U_, void *ptr _U_)
 {
-    time_t      curr;
-    struct tm  *today;
-    const char *level;
-    gchar      *msg;
-
-    /* ignore log message, if log_level isn't interesting */
-    if ( !(log_level & G_LOG_LEVEL_MASK & ~(G_LOG_LEVEL_DEBUG|G_LOG_LEVEL_INFO))) {
-#if !defined(DEBUG_DUMPCAP) && !defined(DEBUG_CHILD_DUMPCAP)
-        return;
-#endif
-    }
-
-    switch(log_level & G_LOG_LEVEL_MASK) {
-    case G_LOG_LEVEL_ERROR:
-        level = "Err ";
-        break;
-    case G_LOG_LEVEL_CRITICAL:
-        level = "Crit";
-        break;
-    case G_LOG_LEVEL_WARNING:
-        level = "Warn";
-        break;
-    case G_LOG_LEVEL_MESSAGE:
-        level = "Msg ";
-        break;
-    case G_LOG_LEVEL_INFO:
-        level = "Info";
-        break;
-    case G_LOG_LEVEL_DEBUG:
-        level = "Dbg ";
-        break;
-    default:
-        fprintf(stderr, "unknown log_level %d\n", log_level);
-        level = NULL;
-        g_assert_not_reached();
-    }
-
-    /* Generate the output message                                  */
-    if (log_level & G_LOG_LEVEL_MESSAGE) {
-        /* normal user messages without additional infos */
-        msg =  g_strdup_printf("%s\n", message);
-    } else {
-        /* create a "timestamp" */
-        time(&curr);
-        today = localtime(&curr);
-
-        /* info/debug messages with additional infos */
-        if (today != NULL)
-            msg = g_strdup_printf("%02u:%02u:%02u %8s %s %s\n",
-                                  today->tm_hour, today->tm_min, today->tm_sec,
-                                  log_domain != NULL ? log_domain : "",
-                                  level, message);
-        else
-            msg = g_strdup_printf("Time not representable %8s %s %s\n",
-                                  log_domain != NULL ? log_domain : "",
-                                  level, message);
-    }
-
-    /* DEBUG & INFO msgs (if we're debugging today)                 */
 #if defined(DEBUG_DUMPCAP) || defined(DEBUG_CHILD_DUMPCAP)
-    if ( !(log_level & G_LOG_LEVEL_MASK & ~(G_LOG_LEVEL_DEBUG|G_LOG_LEVEL_INFO))) {
 #ifdef DEBUG_DUMPCAP
-        fprintf(stderr, "%s", msg);
+        fprintf(stderr, "%s\n", message);
         fflush(stderr);
 #endif
 #ifdef DEBUG_CHILD_DUMPCAP
-        fprintf(debug_log, "%s", msg);
+        fprintf(debug_log, "%s\n", message);
         fflush(debug_log);
 #endif
-        g_free(msg);
-        return;
-    }
+    return;
 #endif
 
-    /* ERROR, CRITICAL, WARNING, MESSAGE messages goto stderr or    */
+    /* Messages goto stderr or    */
     /*  to parent especially formatted if dumpcap running as child. */
     if (capture_child) {
-        sync_pipe_errmsg_to_parent(2, msg, "");
+        sync_pipe_errmsg_to_parent(2, message, "");
     } else {
-        fprintf(stderr, "%s", msg);
+        fprintf(stderr, "%s", message);
         fflush(stderr);
     }
-    g_free(msg);
 }
 
 
@@ -5714,7 +5605,7 @@ report_packet_count(unsigned int packet_count)
 
     if (capture_child) {
         g_snprintf(count_str, sizeof(count_str), "%u", packet_count);
-        g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "Packets: %s", count_str);
+        ws_debug("Packets: %s", count_str);
         pipe_write_block(2, SP_PACKET_COUNT, count_str);
     } else {
         count += packet_count;
@@ -5728,7 +5619,7 @@ static void
 report_new_capture_file(const char *filename)
 {
     if (capture_child) {
-        g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "File: %s", filename);
+        ws_debug("File: %s", filename);
         pipe_write_block(2, SP_FILE, filename);
     } else {
 #ifdef SIGINFO
@@ -5767,7 +5658,7 @@ report_cfilter_error(capture_options *capture_opts, guint i, const char *errmsg)
     if (i < capture_opts->ifaces->len) {
         if (capture_child) {
             g_snprintf(tmp, sizeof(tmp), "%u:%s", i, errmsg);
-            g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "Capture filter error: %s", errmsg);
+            ws_debug("Capture filter error: %s", errmsg);
             pipe_write_block(2, SP_BAD_FILTER, tmp);
         } else {
             /*
@@ -5789,10 +5680,8 @@ static void
 report_capture_error(const char *error_msg, const char *secondary_error_msg)
 {
     if (capture_child) {
-        g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
-            "Primary Error: %s", error_msg);
-        g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
-            "Secondary Error: %s", secondary_error_msg);
+        ws_debug("Primary Error: %s", error_msg);
+        ws_debug("Secondary Error: %s", secondary_error_msg);
         sync_pipe_errmsg_to_parent(2, error_msg, secondary_error_msg);
     } else {
         cmdarg_err("%s", error_msg);
@@ -5809,8 +5698,7 @@ report_packet_drops(guint32 received, guint32 pcap_drops, guint32 drops, guint32
     if (capture_child) {
         char* tmp = g_strdup_printf("%u:%s", total_drops, name);
 
-        g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
-            "Packets received/dropped on interface '%s': %u/%u (pcap:%u/dumpcap:%u/flushed:%u/ps_ifdrop:%u)",
+        ws_debug("Packets received/dropped on interface '%s': %u/%u (pcap:%u/dumpcap:%u/flushed:%u/ps_ifdrop:%u)",
             name, received, total_drops, pcap_drops, drops, flushed, ps_ifdrop);
         pipe_write_block(2, SP_DROPS, tmp);
         g_free(tmp);
@@ -5844,8 +5732,7 @@ signal_pipe_check_running(void)
 
     if (!sig_pipe_name || !sig_pipe_handle) {
         /* This shouldn't happen */
-        g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO,
-            "Signal pipe: No name or handle");
+        ws_info("Signal pipe: No name or handle");
         return FALSE;
     }
 
@@ -5860,10 +5747,8 @@ signal_pipe_check_running(void)
     if (!result || avail > 0) {
         /* peek failed or some bytes really available */
         /* (if not piping from stdin this would fail) */
-        g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO,
-            "Signal pipe: Stop capture: %s", sig_pipe_name);
-        g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG,
-            "Signal pipe: %s (%p) result: %u avail: %lu", sig_pipe_name,
+        ws_info("Signal pipe: Stop capture: %s", sig_pipe_name);
+        ws_debug("Signal pipe: %s (%p) result: %u avail: %lu", sig_pipe_name,
             sig_pipe_handle, result, avail);
         return FALSE;
     } else {
diff --git a/epan/dissectors/packet-frame.c b/epan/dissectors/packet-frame.c
index 020c32a410..e724ce1f94 100644
--- a/epan/dissectors/packet-frame.c
+++ b/epan/dissectors/packet-frame.c
@@ -29,13 +29,13 @@
 #include <epan/expert.h>
 #include <wsutil/wsgcrypt.h>
 #include <wsutil/str_util.h>
+#include <wsutil/wslog.h>
 #include <epan/proto_data.h>
 #include <epan/addr_resolv.h>
 #include <wmem/wmem.h>
 
 #include "packet-frame.h"
 #include "packet-icmp.h"
-#include "log.h"
 
 #include <epan/column-info.h>
 #include <epan/color_filters.h>
@@ -1012,7 +1012,7 @@ dissect_frame(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree, void*
 				field_info* fi = proto_find_field_from_offset(tree, i, tvb);
 				if (fi && fi->hfinfo->id != proto_frame) {
 					if (prefs.incomplete_dissectors_check_debug)
-						g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_WARNING,
+						ws_log(LOG_DOMAIN_CAPTURE, LOG_LEVEL_WARNING,
 							"Dissector %s incomplete in frame %u: undecoded byte number %u "
 							"(0x%.4X+%u)",
 							fi->hfinfo->abbrev,
diff --git a/epan/epan.c b/epan/epan.c
index aaa404ba9f..461276b0c9 100644
--- a/epan/epan.c
+++ b/epan/epan.c
@@ -31,6 +31,7 @@
 #include "epan_dissect.h"
 
 #include <wsutil/nstime.h>
+#include <wsutil/wslog.h>
 
 #include "conversation.h"
 #include "except.h"
@@ -137,26 +138,28 @@ epan_get_version_number(int *major, int *minor, int *micro)
 static void
 quiet_gcrypt_logger (void *dummy _U_, int level, const char *format, va_list args)
 {
-	GLogLevelFlags log_level = G_LOG_LEVEL_WARNING;
+	enum ws_log_level log_level;
 
 	switch (level) {
 	case GCRY_LOG_CONT: // Continuation. Ignore for now.
 	case GCRY_LOG_DEBUG:
 	case GCRY_LOG_INFO:
-	default:
 		return;
+		break;
 	case GCRY_LOG_WARN:
 	case GCRY_LOG_BUG:
-		log_level = G_LOG_LEVEL_WARNING;
+		log_level = LOG_LEVEL_WARNING;
 		break;
 	case GCRY_LOG_ERROR:
-		log_level = G_LOG_LEVEL_ERROR;
+		log_level = LOG_LEVEL_ERROR;
 		break;
 	case GCRY_LOG_FATAL:
-		log_level = G_LOG_LEVEL_CRITICAL;
+		log_level = LOG_LEVEL_CRITICAL;
 		break;
+	default:
+		return;
 	}
-	g_logv(NULL, log_level, format, args);
+	ws_logv(LOG_DOMAIN_EPAN, log_level, format, args);
 }
 #endif // _WIN32
 
diff --git a/epan/prefs.c b/epan/prefs.c
index 9af1984267..9707f27da4 100644
--- a/epan/prefs.c
+++ b/epan/prefs.c
@@ -2424,73 +2424,6 @@ gui_layout_callback(void)
  ******************************************************/
 static void custom_pref_no_cb(pref_t* pref _U_) {}
 
-
-/*
- * Console log level custom preference functions
- */
-static void
-console_log_level_reset_cb(pref_t* pref)
-{
-    *pref->varp.uint = pref->default_val.uint;
-}
-
-static prefs_set_pref_e
-console_log_level_set_cb(pref_t* pref, const gchar* value, unsigned int* changed_flags)
-{
-    guint    uval;
-
-    if (!ws_strtou32(value, NULL, &uval))
-        return PREFS_SET_SYNTAX_ERR;        /* number was bad */
-
-    if (*pref->varp.uint != uval) {
-        *changed_flags = prefs_get_effect_flags(pref);
-        *pref->varp.uint = uval;
-    }
-
-    if (*pref->varp.uint & (G_LOG_LEVEL_INFO|G_LOG_LEVEL_DEBUG)) {
-        /*
-         * GLib drops INFO and DEBUG messages by default. If the user
-         * hasn't set G_MESSAGES_DEBUG, possibly to a specific set of
-         * domains, tell it not to do that.
-         */
-        const char *s = g_getenv("G_MESSAGES_DEBUG");
-        if(s != NULL) {
-            g_message("prefs: Skip overwriting environment variable "
-                        "G_MESSAGES_DEBUG=\"%s\"", s);
-        }
-        else {
-            g_info("prefs: Set environment variable G_MESSAGES_DEBUG=\"all\"");
-            g_setenv("G_MESSAGES_DEBUG", "all", FALSE);
-        }
-    }
-
-    return PREFS_SET_OK;
-}
-
-static const char * console_log_level_type_name_cb(void) {
-    return "Log level";
-}
-
-static char * console_log_level_type_description_cb(void) {
-    return g_strdup_printf(
-        "Console log level (for debugging)\n"
-        "A bitmask of log levels:\n"
-        "ERROR    = 4\n"
-        "CRITICAL = 8\n"
-        "WARNING  = 16\n"
-        "MESSAGE  = 32\n"
-        "INFO     = 64\n"
-        "DEBUG    = 128");
-}
-
-static gboolean console_log_level_is_default_cb(pref_t* pref) {
-    return *pref->varp.uint == pref->default_val.uint;
-}
-
-static char * console_log_level_to_str_cb(pref_t* pref, gboolean default_val) {
-    return g_strdup_printf("%u",  default_val ? pref->default_val.uint : *pref->varp.uint);
-}
-
 /*
  * Column preference functions
  */
@@ -3547,15 +3480,7 @@ prefs_register_modules(void)
     console_module = prefs_register_module(NULL, "console", "Console",
         "Console logging and debugging output", NULL, FALSE);
 
-    custom_cbs.free_cb = custom_pref_no_cb;
-    custom_cbs.reset_cb = console_log_level_reset_cb;
-    custom_cbs.set_cb = console_log_level_set_cb;
-    custom_cbs.type_name_cb = console_log_level_type_name_cb;
-    custom_cbs.type_description_cb = console_log_level_type_description_cb;
-    custom_cbs.is_default_cb = console_log_level_is_default_cb;
-    custom_cbs.to_str_cb = console_log_level_to_str_cb;
-    prefs_register_uint_custom_preference(console_module, "log.level", "logging level",
-        "A bitmask of GLib log levels", &custom_cbs, &prefs.console_log_level);
+    prefs_register_obsolete_preference(console_module, "log.level");
 
     prefs_register_bool_preference(console_module, "incomplete_dissectors_check_debug",
                                    "Print debug line for incomplete dissectors",
@@ -4271,9 +4196,6 @@ pre_init_prefs(void)
         }
     }
 
-    prefs.console_log_level          =
-        G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_ERROR;
-
 /* set the default values for the tap/statistics dialog box */
     prefs.tap_update_interval    = TAP_UPDATE_DEFAULT_INTERVAL;
     prefs.st_enable_burstinfo = TRUE;
diff --git a/epan/prefs.h b/epan/prefs.h
index 91733c65da..5866e0a728 100644
--- a/epan/prefs.h
+++ b/epan/prefs.h
@@ -185,7 +185,6 @@ typedef struct _e_prefs {
   gchar       *gui_interfaces_hide_types;
   gboolean     gui_interfaces_show_hidden;
   gboolean     gui_interfaces_remote_display;
-  gint         console_log_level;
   gchar       *capture_device;
   gchar       *capture_devices_linktypes;
   gchar       *capture_devices_descr;
diff --git a/epan/reedsolomon.c b/epan/reedsolomon.c
index 0250c00495..5c810aa154 100644
--- a/epan/reedsolomon.c
+++ b/epan/reedsolomon.c
@@ -19,7 +19,7 @@
 
 #include "config.h"
 
-#define G_LOG_DOMAIN "epan"
+#define WS_LOG_DOMAIN LOG_DOMAIN_EPAN
 
 #include <stdio.h>
 #include "reedsolomon.h"
diff --git a/epan/secrets.c b/epan/secrets.c
index 13717d7761..8d61ad42df 100644
--- a/epan/secrets.c
+++ b/epan/secrets.c
@@ -11,8 +11,7 @@
 
 #include "config.h"
 
-/* Start with G_MESSAGES_DEBUG=secrets to see messages. */
-#define G_LOG_DOMAIN "secrets"
+#define WS_LOG_DOMAIN LOG_DOMAIN_EPAN
 
 #include "secrets.h"
 #include <wiretap/wtap.h>
diff --git a/epan/tvbuff_zlib.c b/epan/tvbuff_zlib.c
index befd05c7ce..2264d5dc1d 100644
--- a/epan/tvbuff_zlib.c
+++ b/epan/tvbuff_zlib.c
@@ -9,9 +9,8 @@
  * SPDX-License-Identifier: GPL-2.0-or-later
  */
 
-#define G_LOG_DOMAIN "epan"
-
 #include <config.h>
+#define WS_LOG_DOMAIN LOG_DOMAIN_EPAN
 
 #include <glib.h>
 
diff --git a/extcap.c b/extcap.c
index 70ebed0374..bdbf234c06 100644
--- a/extcap.c
+++ b/extcap.c
@@ -11,6 +11,7 @@
  */
 
 #include <config.h>
+#define WS_LOG_DOMAIN LOG_DOMAIN_CAPCHILD
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -31,7 +32,6 @@
 #endif
 
 #include <glib.h>
-#include <log.h>
 
 #include <epan/prefs.h>
 
@@ -41,6 +41,7 @@
 #include <wsutil/filesystem.h>
 #include <wsutil/ws_pipe.h>
 #include <wsutil/tempfile.h>
+#include <wsutil/wslog.h>
 
 #include "capture_opts.h"
 
@@ -498,7 +499,7 @@ extcap_run_all(const char *argv[], extcap_run_cb_t output_cb, gsize data_size, g
     g_cond_clear(&pool.cond);
     g_thread_pool_free(pool.pool, FALSE, TRUE);
 
-    g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "extcap: completed discovery of %d tools in %.3fms",
+    ws_debug("extcap: completed discovery of %d tools in %.3fms",
             paths_count, (g_get_monotonic_time() - start_time) / 1000.0);
     *count = paths_count;
     return infos;
@@ -534,7 +535,7 @@ static gboolean cb_dlt(extcap_callback_info_t cb_info)
     dlts = extcap_parse_dlts(cb_info.output);
     temp = dlts;
 
-    g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "Extcap pipe %s ", cb_info.extcap);
+    ws_debug("Extcap pipe %s ", cb_info.extcap);
 
     /*
      * Allocate the interface capabilities structure.
@@ -548,8 +549,7 @@ static gboolean cb_dlt(extcap_callback_info_t cb_info)
         dlt_item = (extcap_dlt *)dlts->data;
         if (dlt_item)
         {
-            g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
-                  "  DLT %d name=\"%s\" display=\"%s\" ", dlt_item->number,
+            ws_debug("  DLT %d name=\"%s\" display=\"%s\" ", dlt_item->number,
                   dlt_item->name, dlt_item->display);
 
             data_link_info = g_new(data_link_info_t, 1);
@@ -572,7 +572,7 @@ static gboolean cb_dlt(extcap_callback_info_t cb_info)
     {
         if (cb_info.err_str)
         {
-            g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "  returned no DLTs");
+            ws_debug("  returned no DLTs");
             *(cb_info.err_str) = g_strdup("Extcap returned no DLTs");
         }
         g_free(caps);
@@ -930,8 +930,7 @@ extcap_get_if_configuration(const char *ifname)
     extcap_interface *interface = extcap_find_interface_for_ifname(ifname);
     if (interface)
     {
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "Extcap path %s",
-              get_extcap_dir());
+        ws_debug("Extcap path %s", get_extcap_dir());
 
         arguments = g_list_append(arguments, g_strdup(EXTCAP_ARGUMENT_CONFIG));
         arguments = g_list_append(arguments, g_strdup(EXTCAP_ARGUMENT_INTERFACE));
@@ -976,8 +975,7 @@ extcap_get_if_configuration_values(const char * ifname, const char * argname, GH
     extcap_interface *interface = extcap_find_interface_for_ifname(ifname);
     if (interface)
     {
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "Extcap path %s",
-              get_extcap_dir());
+        ws_debug("Extcap path %s", get_extcap_dir());
 
         args = g_list_append(args, g_strdup(EXTCAP_ARGUMENT_CONFIG));
         args = g_list_append(args, g_strdup(EXTCAP_ARGUMENT_INTERFACE));
@@ -1113,8 +1111,7 @@ extcap_verify_capture_filter(const char *ifname, const char *filter, gchar **err
     extcap_interface *interface = extcap_find_interface_for_ifname(ifname);
     if (interface)
     {
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "Extcap path %s",
-              get_extcap_dir());
+        ws_debug("Extcap path %s", get_extcap_dir());
 
         arguments = g_list_append(arguments, g_strdup(EXTCAP_ARGUMENT_CAPTURE_FILTER));
         arguments = g_list_append(arguments, g_strdup(filter));
@@ -1175,14 +1172,12 @@ void extcap_if_cleanup(capture_options *capture_opts, gchar **errormsg)
 
         overwrite_exitcode = FALSE;
 
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
-              "Extcap [%s] - Cleaning up fifo: %s; PID: %d", interface_opts->name,
+        ws_debug("Extcap [%s] - Cleaning up fifo: %s; PID: %d", interface_opts->name,
               interface_opts->extcap_fifo, interface_opts->extcap_pid);
 #ifdef _WIN32
         if (interface_opts->extcap_pipe_h != INVALID_HANDLE_VALUE)
         {
-            g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
-                  "Extcap [%s] - Closing pipe", interface_opts->name);
+            ws_debug("Extcap [%s] - Closing pipe", interface_opts->name);
             FlushFileBuffers(interface_opts->extcap_pipe_h);
             DisconnectNamedPipe(interface_opts->extcap_pipe_h);
             CloseHandle(interface_opts->extcap_pipe_h);
@@ -1190,8 +1185,7 @@ void extcap_if_cleanup(capture_options *capture_opts, gchar **errormsg)
         }
         if (interface_opts->extcap_control_in_h != INVALID_HANDLE_VALUE)
         {
-            g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
-                  "Extcap [%s] - Closing control_in pipe", interface_opts->name);
+            ws_debug("Extcap [%s] - Closing control_in pipe", interface_opts->name);
             FlushFileBuffers(interface_opts->extcap_control_in_h);
             DisconnectNamedPipe(interface_opts->extcap_control_in_h);
             CloseHandle(interface_opts->extcap_control_in_h);
@@ -1199,8 +1193,7 @@ void extcap_if_cleanup(capture_options *capture_opts, gchar **errormsg)
         }
         if (interface_opts->extcap_control_out_h != INVALID_HANDLE_VALUE)
         {
-            g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
-                  "Extcap [%s] - Closing control_out pipe", interface_opts->name);
+            ws_debug("Extcap [%s] - Closing control_out pipe", interface_opts->name);
             FlushFileBuffers(interface_opts->extcap_control_out_h);
             DisconnectNamedPipe(interface_opts->extcap_control_out_h);
             CloseHandle(interface_opts->extcap_control_out_h);
@@ -1233,8 +1226,7 @@ void extcap_if_cleanup(capture_options *capture_opts, gchar **errormsg)
 #endif
         /* Maybe the client closed and removed fifo, but ws should check if
          * pid should be closed */
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
-              "Extcap [%s] - Closing spawned PID: %d", interface_opts->name,
+        ws_debug("Extcap [%s] - Closing spawned PID: %d", interface_opts->name,
               interface_opts->extcap_pid);
 
         pipedata = (ws_pipe_t *) interface_opts->extcap_pipedata;
@@ -1535,13 +1527,13 @@ static gboolean extcap_create_pipe(const gchar *ifname, gchar **fifo, HANDLE *ha
 
     if (*handle_out == INVALID_HANDLE_VALUE)
     {
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "\nError creating pipe => (%d)", GetLastError());
+        ws_debug("Error creating pipe => (%d)", GetLastError());
         g_free (pipename);
         return FALSE;
     }
     else
     {
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "\nWireshark Created pipe =>(%s) handle (%" G_GUINTPTR_FORMAT ")", pipename, *handle_out);
+        ws_debug("Wireshark Created pipe =>(%s) handle (%" G_GUINTPTR_FORMAT ")", pipename, *handle_out);
         *fifo = g_strdup(pipename);
     }
 
@@ -1563,8 +1555,7 @@ static gboolean extcap_create_pipe(const gchar *ifname, gchar **fifo, const gcha
 
     ws_close(fd);
 
-    g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG,
-          "Extcap - Creating fifo: %s", temp_name);
+    ws_debug("Extcap - Creating fifo: %s", temp_name);
 
     if (file_exists(temp_name))
     {
@@ -1780,12 +1771,12 @@ process_new_extcap(const char *extcap, char *output)
     /* Load interfaces from utility */
     interfaces = extcap_parse_interfaces(output, &control_items);
 
-    g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "Loading interface list for %s ", extcap);
+    ws_debug("Loading interface list for %s ", extcap);
 
     /* Seems, that there where no interfaces to be loaded */
     if ( ! interfaces || g_list_length(interfaces) == 0 )
     {
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "Cannot load interfaces for %s", extcap );
+        ws_debug("Cannot load interfaces for %s", extcap );
         g_list_free(interface_keys);
         g_free(toolname);
         return;
@@ -1795,8 +1786,7 @@ process_new_extcap(const char *extcap, char *output)
     element = extcap_ensure_interface(toolname, TRUE);
     if ( element == NULL )
     {
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_WARNING,
-            "Cannot store interface %s, already loaded as personal plugin", extcap );
+        ws_warning("Cannot store interface %s, already loaded as personal plugin", extcap );
         g_list_foreach(interfaces, remove_extcap_entry, NULL);
         g_list_free(interfaces);
         g_list_free(interface_keys);
@@ -1817,7 +1807,7 @@ process_new_extcap(const char *extcap, char *output)
         int_iter = (extcap_interface *)walker->data;
 
         if (int_iter->call != NULL)
-            g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "Interface found %s\n", int_iter->call);
+            ws_debug("Interface found %s\n", int_iter->call);
 
         /* Help is not necessarily stored with the interface, but rather with the version string.
          * As the version string allways comes in front of the interfaces, this ensures, that it get's
@@ -1825,7 +1815,7 @@ process_new_extcap(const char *extcap, char *output)
         if (int_iter->if_type == EXTCAP_SENTENCE_EXTCAP)
         {
             if (int_iter->call != NULL)
-                g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "  Extcap [%s] ", int_iter->call);
+                ws_debug("  Extcap [%s] ", int_iter->call);
 
             /* Only initialize values if none are set. Need to check only one element here */
             if ( ! element->version )
@@ -1854,14 +1844,14 @@ process_new_extcap(const char *extcap, char *output)
         {
             if ( g_list_find(interface_keys, int_iter->call) )
             {
-                g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_WARNING, "Extcap interface \"%s\" is already provided by \"%s\" ",
+                ws_warning("Extcap interface \"%s\" is already provided by \"%s\" ",
                       int_iter->call, extcap_if_executable(int_iter->call));
                 walker = g_list_next(walker);
                 continue;
             }
 
             if ((int_iter->call != NULL) && (int_iter->display))
-                g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "  Interface [%s] \"%s\" ", int_iter->call, int_iter->display);
+                ws_debug("  Interface [%s] \"%s\" ", int_iter->call, int_iter->display);
 
             int_iter->extcap_path = g_strdup(extcap);
 
diff --git a/extcap/androiddump.c b/extcap/androiddump.c
index 6011345385..1f0f21eab4 100644
--- a/extcap/androiddump.c
+++ b/extcap/androiddump.c
@@ -23,6 +23,7 @@
 #include <wsutil/privileges.h>
 #include <wsutil/report_message.h>
 #include <wsutil/please_report_bug.h>
+#include <wsutil/wslog.h>
 #include <ui/cmdarg_err.h>
 #include <wsutil/inet_addr.h>
 
@@ -362,7 +363,7 @@ static const char* interface_to_logbuf(char* interface)
 static void
 androiddump_cmdarg_err(const char *msg_format, va_list ap)
 {
-    g_logv(G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, msg_format, ap);
+    ws_logv(LOG_DOMAIN_CAPCHILD, LOG_LEVEL_WARNING, msg_format, ap);
 }
 
 static void useSndTimeout(socket_handle_t  sock) {
@@ -2527,8 +2528,19 @@ int main(int argc, char *argv[]) {
     char            *help_url;
     char            *help_header = NULL;
 
+    /* Initialize log handler early so we can have proper logging during startup. */
+    ws_log_init(NULL);
+
     cmdarg_err_init(androiddump_cmdarg_err, androiddump_cmdarg_err);
 
+    /* Command line options are parsed too late to configure logging, do it
+        manually. */
+    const char *opt_err_val;
+    if ((opt_err_val = ws_log_set_level_args(&argc, argv)) != NULL) {
+        cmdarg_err("Invalid log level \"%s\"", opt_err_val);
+        return EXIT_FAILURE;
+    }
+
     /*
      * Get credential information for later use.
      */
diff --git a/extcap/extcap-base.c b/extcap/extcap-base.c
index bc09aa6c54..0f8a5e6a51 100644
--- a/extcap/extcap-base.c
+++ b/extcap/extcap-base.c
@@ -18,6 +18,7 @@
 #include <stdint.h>
 #include <string.h>
 #include <errno.h>
+#include <wsutil/wslog.h>
 
 /*
  * If we have getopt_long() in the system library, include <getopt.h>.
@@ -53,8 +54,6 @@ typedef struct _extcap_option {
     char * optdesc;
 } extcap_option_t;
 
-FILE* custom_log = NULL;
-
 void extcap_base_register_interface(extcap_parameters * extcap, const char * interface, const char * ifdescription, uint16_t dlt, const char * dltdescription )
 {
     extcap_base_register_interface_ext(extcap, interface, ifdescription, dlt, NULL, dltdescription );
@@ -116,37 +115,16 @@ void extcap_base_set_running_with(extcap_parameters * extcap, const char *fmt, .
     va_end(ap);
 }
 
-static void extcap_custom_log(const gchar *log_domain,
-             GLogLevelFlags log_level,
-             const gchar *message,
-             gpointer user_data)
-{
-    if (log_level & G_LOG_LEVEL_DEBUG) {
-        if (!custom_log)
-            return;
-        fprintf(custom_log, "%s\n", message);
-        fflush(custom_log);
-    } else {
-        g_log_default_handler(log_domain, log_level, message, user_data);
-    }
-}
-
 uint8_t extcap_base_parse_options(extcap_parameters * extcap, int result, char * optargument)
 {
     uint8_t ret = 1;
 
     switch (result) {
         case EXTCAP_OPT_DEBUG:
-#ifdef _WIN32
-            _putenv_s("G_MESSAGES_DEBUG", "all");
-#else
-            setenv("G_MESSAGES_DEBUG", "all", 1);
-#endif
             extcap->debug = TRUE;
             break;
         case EXTCAP_OPT_DEBUG_FILE:
             extcap_init_custom_log(optargument);
-            g_log_set_default_handler(extcap_custom_log, NULL);
             break;
         case EXTCAP_OPT_LIST_INTERFACES:
             extcap->do_list_interfaces = 1;
@@ -337,11 +315,13 @@ void extcap_help_add_header(extcap_parameters * extcap, char * help_header)
 
 void extcap_init_custom_log(const char* filename)
 {
+    FILE *custom_log;
     if (!filename || strlen(filename) == 0)
         return;
     custom_log = fopen(filename, "w");
     if (!custom_log)
         g_error("Can't open custom log file: %s (%s)", filename, strerror(errno));
+    ws_log_add_custom_file(custom_log);
 }
 
 void extcap_config_debug(unsigned* count)
diff --git a/extcap/randpktdump.c b/extcap/randpktdump.c
index be7dc52810..a3336f8e7a 100644
--- a/extcap/randpktdump.c
+++ b/extcap/randpktdump.c
@@ -20,6 +20,7 @@
 #include <wsutil/privileges.h>
 #include <wsutil/socket.h>
 #include <wsutil/please_report_bug.h>
+#include <wsutil/wslog.h>
 
 #include <cli_main.h>
 #include <ui/cmdarg_err.h>
@@ -127,7 +128,7 @@ static int list_config(char *interface)
 
 static void randpktdump_cmdarg_err(const char *msg_format, va_list ap)
 {
-	g_logv(G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, msg_format, ap);
+	ws_logv(LOG_DOMAIN_CAPCHILD, LOG_LEVEL_WARNING, msg_format, ap);
 }
 
 int main(int argc, char *argv[])
@@ -150,8 +151,19 @@ int main(int argc, char *argv[])
 	char* help_url;
 	char* help_header = NULL;
 
+	/* Initialize log handler early so we can have proper logging during startup. */
+	ws_log_init(NULL);
+
 	cmdarg_err_init(randpktdump_cmdarg_err, randpktdump_cmdarg_err);
 
+	/* Command line options are parsed too late to configure logging, do it
+		manually. */
+	const char *opt_err_val;
+	if ((opt_err_val = ws_log_set_level_args(&argc, argv)) != NULL) {
+		cmdarg_err("Invalid log level \"%s\"", opt_err_val);
+		return EXIT_FAILURE;
+	}
+
 	/*
 	 * Get credential information for later use.
 	 */
diff --git a/extcap/ssh-base.c b/extcap/ssh-base.c
index 342cf6d578..98f968f657 100644
--- a/extcap/ssh-base.c
+++ b/extcap/ssh-base.c
@@ -15,10 +15,10 @@
 #include "ssh-base.h"
 
 #include <extcap/extcap-base.h>
-#include <log.h>
 #include <string.h>
 #include <libssh/callbacks.h>
 #include <ws_attributes.h>
+#include <wsutil/wslog.h>
 
 static void extcap_log(int priority _U_, const char *function, const char *buffer, void *userdata _U_)
 {
@@ -92,7 +92,7 @@ ssh_session create_ssh_connection(const ssh_params_t* ssh_params, char** err_inf
 	ssh_options_get(sshs, SSH_OPTIONS_USER, &username);
 	ssh_options_get_port(sshs, &port);
 
-	g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "Opening ssh connection to %s@%s:%u", username,
+	ws_log(LOG_DOMAIN_CAPCHILD, LOG_LEVEL_INFO, "Opening ssh connection to %s@%s:%u", username,
 		ssh_params->host, port);
 
 	ssh_string_free_char(username);
@@ -108,36 +108,36 @@ ssh_session create_ssh_connection(const ssh_params_t* ssh_params, char** err_inf
 		ssh_key pkey = ssh_key_new();
 		int ret;
 
-		g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "Connecting using public key in %s...", ssh_params->sshkey_path);
+		ws_info("Connecting using public key in %s...", ssh_params->sshkey_path);
 		ret = ssh_pki_import_privkey_file(ssh_params->sshkey_path, ssh_params->sshkey_passphrase, NULL, NULL, &pkey);
 
 		if (ret == SSH_OK) {
 			if (ssh_userauth_publickey(sshs, NULL, pkey) == SSH_AUTH_SUCCESS) {
-				g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "done");
+				ws_info("done");
 				ssh_key_free(pkey);
 				return sshs;
 			}
 		}
 		ssh_key_free(pkey);
-		g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "failed (%s)", ssh_get_error(sshs));
+		ws_info("failed (%s)", ssh_get_error(sshs));
 	}
 
 	/* Try to authenticate using standard public key */
-	g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "Connecting using standard public key...");
+	ws_info("Connecting using standard public key...");
 	if (ssh_userauth_publickey_auto(sshs, NULL, NULL) == SSH_AUTH_SUCCESS) {
-		g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "done");
+		ws_info("done");
 		return sshs;
 	}
-	g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "failed");
+	ws_info("failed");
 
 	/* If a password has been provided and all previous attempts failed, try to use it */
 	if (ssh_params->password) {
-		g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "Connecting using password...");
+		ws_info("Connecting using password...");
 		if (ssh_userauth_password(sshs, ssh_params->username, ssh_params->password) == SSH_AUTH_SUCCESS) {
-			g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "done");
+			ws_info("done");
 			return sshs;
 		}
-		g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_INFO, "failed");
+		ws_info("failed");
 	}
 
 	*err_info = g_strdup_printf("Can't find a valid authentication. Disconnecting.");
diff --git a/file.c b/file.c
index 17a01ce0d0..846880b003 100644
--- a/file.c
+++ b/file.c
@@ -813,8 +813,6 @@ cf_continue_tail(capture_file *cf, volatile int to_read, wtap_rec *rec,
   /* Don't freeze/thaw the list when doing live capture */
   /*packet_list_freeze();*/
 
-  /*g_log(NULL, G_LOG_LEVEL_MESSAGE, "cf_continue_tail: %u new: %u", cf->count, to_read);*/
-
   epan_dissect_init(&edt, cf->epan, create_proto_tree, FALSE);
 
   TRY {
@@ -866,9 +864,6 @@ cf_continue_tail(capture_file *cf, volatile int to_read, wtap_rec *rec,
 
   epan_dissect_cleanup(&edt);
 
-  /*g_log(NULL, G_LOG_LEVEL_MESSAGE, "cf_continue_tail: count %u state: %u err: %u",
-    cf->count, cf->state, *err);*/
-
   /* Don't freeze/thaw the list when doing live capture */
   /*packet_list_thaw();*/
   /* With the new packet list the first packet
diff --git a/log.h b/log.h
deleted file mode 100644
index 8eb9df96dd..0000000000
--- a/log.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/* log.h
- * log output definitions
- *
- * Wireshark - Network traffic analyzer
- * By Gerald Combs <gerald@wireshark.org>
- * Copyright 1998 Gerald Combs
- *
- * SPDX-License-Identifier: GPL-2.0-or-later
- */
-
-#ifndef __LOG_H__
-#define __LOG_H__
-
-/* capture domain (except for capture child, see below) */
-#define LOG_DOMAIN_CAPTURE          "Capture"
-
-/* capture child domain (the capture child might also contain file domain messages!) */
-#define LOG_DOMAIN_CAPTURE_CHILD  "CaptureChild"
-
-/* main domain */
-#define LOG_DOMAIN_MAIN           "Main"
-
-/* enable very verbose capture log debug output */
-/* (might slightly degrade performance) */
-/*#define LOG_CAPTURE_VERBOSE*/
-
-#endif
-
-/*
- * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
- *
- * Local variables:
- * c-basic-offset: 4
- * tab-width: 8
- * indent-tabs-mode: nil
- * End:
- *
- * vi: set shiftwidth=4 tabstop=8 expandtab:
- * :indentSize=4:tabSize=8:noTabs=true:
- */
diff --git a/rawshark.c b/rawshark.c
index 77f85eed66..28593cd263 100644
--- a/rawshark.c
+++ b/rawshark.c
@@ -60,6 +60,7 @@
 #include <wsutil/privileges.h>
 #include <wsutil/report_message.h>
 #include <wsutil/please_report_bug.h>
+#include <wsutil/wslog.h>
 #include <ui/clopts_common.h>
 
 #include "globals.h"
@@ -102,7 +103,6 @@
 #include "capture/capture-wpcap.h"
 #endif /* _WIN32 */
 #endif /* HAVE_LIBPCAP */
-#include "log.h"
 
 #if 0
 /*
@@ -208,12 +208,6 @@ print_usage(FILE *output)
     fprintf(output, "  -v                       display version info and exit\n");
 }
 
-static void
-log_func_ignore (const gchar *log_domain _U_, GLogLevelFlags log_level _U_,
-                 const gchar *message _U_, gpointer user_data _U_)
-{
-}
-
 /**
  * Open a pipe for raw input.  This is a stripped-down version of
  * pcap_loop.c:cap_pipe_open_live().
@@ -234,7 +228,7 @@ raw_pipe_open(const char *pipe_name)
 #endif
     int          rfd;
 
-    g_log(LOG_DOMAIN_CAPTURE_CHILD, G_LOG_LEVEL_DEBUG, "open_raw_pipe: %s", pipe_name);
+    ws_log(LOG_DOMAIN_CAPCHILD, LOG_LEVEL_DEBUG, "open_raw_pipe: %s", pipe_name);
 
     /*
      * XXX Rawshark blocks until we return
@@ -417,7 +411,6 @@ main(int argc, char *argv[])
     gchar               *rfilters[64];
     e_prefs             *prefs_p;
     char                 badopt;
-    int                  log_flags;
     GPtrArray           *disp_fields = g_ptr_array_new();
     guint                fc;
     gboolean             skip_pcap_header = FALSE;
@@ -454,8 +447,19 @@ main(int argc, char *argv[])
     setlocale(LC_ALL, "");
 #endif
 
+    /* Initialize log handler early so we can have proper logging during startup. */
+    ws_log_init(NULL);
+
     cmdarg_err_init(rawshark_cmdarg_err, rawshark_cmdarg_err_cont);
 
+    /* Command line options are parsed too late to configure logging,  do it
+        manually. */
+    const char *opt_err_val;
+    if ((opt_err_val = ws_log_set_level_args(&argc, argv)) != NULL) {
+        cmdarg_err("Invalid log level \"%s\"", opt_err_val);
+        return INVALID_OPTION;
+    }
+
     /* Initialize the version information. */
     ws_init_version_info("Rawshark (Wireshark)", NULL,
                          epan_get_compiled_version_info,
@@ -493,20 +497,6 @@ main(int argc, char *argv[])
                 err_msg);
     }
 
-    /* nothing more than the standard GLib handler, but without a warning */
-    log_flags =
-        G_LOG_LEVEL_WARNING |
-        G_LOG_LEVEL_MESSAGE |
-        G_LOG_LEVEL_INFO |
-        G_LOG_LEVEL_DEBUG;
-
-    g_log_set_handler(NULL,
-                      (GLogLevelFlags)log_flags,
-                      log_func_ignore, NULL /* user_data */);
-    g_log_set_handler(LOG_DOMAIN_CAPTURE_CHILD,
-                      (GLogLevelFlags)log_flags,
-                      log_func_ignore, NULL /* user_data */);
-
     init_report_message("rawshark", &rawshark_report_routines);
 
     timestamp_set_type(TS_RELATIVE);
diff --git a/sharkd.c b/sharkd.c
index 3456e0fcf8..d3c770d71d 100644
--- a/sharkd.c
+++ b/sharkd.c
@@ -29,6 +29,7 @@
 #include <wsutil/file_util.h>
 #include <wsutil/privileges.h>
 #include <wsutil/report_message.h>
+#include <wsutil/wslog.h>
 #include <version_info.h>
 #include <wiretap/wtap_opttypes.h>
 
@@ -54,8 +55,6 @@
 
 #include <wsutil/codecs.h>
 
-#include "log.h"
-
 #include <wsutil/str_util.h>
 #include <wsutil/utf8_entities.h>
 
@@ -115,8 +114,19 @@ main(int argc, char *argv[])
     cfile_close_failure_message
   };
 
+  /* Initialize log handler early so we can have proper logging during startup. */
+  ws_log_init(NULL);
+
   cmdarg_err_init(sharkd_cmdarg_err, sharkd_cmdarg_err_cont);
 
+  /* Command line options are parsed too late to configure logging, do it
+      manually. */
+  const char *opt_err_val;
+  if ((opt_err_val = ws_log_set_level_args(&argc, argv)) != NULL) {
+    cmdarg_err("Invalid log level \"%s\"", opt_err_val);
+    return INIT_FAILED;
+  }
+
   /*
    * Get credential information for later use, and drop privileges
    * before doing anything else.
diff --git a/tfshark.c b/tfshark.c
index cd15617620..c9192d4dc1 100644
--- a/tfshark.c
+++ b/tfshark.c
@@ -11,6 +11,8 @@
 
 #include <config.h>
 
+#define WS_LOG_DOMAIN  LOG_DOMAIN_MAIN
+
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
@@ -45,6 +47,7 @@
 #include <wsutil/file_util.h>
 #include <wsutil/privileges.h>
 #include <wsutil/report_message.h>
+#include <wsutil/wslog.h>
 #include <cli_main.h>
 #include <version_info.h>
 
@@ -74,7 +77,6 @@
 #include <wiretap/wtap-int.h>
 #include <wiretap/file_wrappers.h>
 
-#include "log.h"
 #include <epan/funnel.h>
 
 #ifdef HAVE_PLUGINS
@@ -250,31 +252,6 @@ glossary_option_help(void)
   fprintf(output, "\n");
 }
 
-static void
-tfshark_log_handler (const gchar *log_domain, GLogLevelFlags log_level,
-    const gchar *message, gpointer user_data)
-{
-  /* ignore log message, if log_level isn't interesting based
-     upon the console log preferences.
-     If the preferences haven't been loaded yet, display the
-     message anyway.
-
-     The default console_log_level preference value is such that only
-       ERROR, CRITICAL and WARNING level messages are processed;
-       MESSAGE, INFO and DEBUG level messages are ignored.
-
-     XXX: Aug 07, 2009: Prior tshark g_log code was hardwired to process only
-           ERROR and CRITICAL level messages so the current code is a behavioral
-           change.  The current behavior is the same as in Wireshark.
-  */
-  if (prefs_loaded && (log_level & G_LOG_LEVEL_MASK & prefs.console_log_level) == 0) {
-    return;
-  }
-
-  g_log_default_handler(log_domain, log_level, message, user_data);
-
-}
-
 static void
 print_current_user(void) {
   gchar *cur_user, *cur_group;
@@ -323,7 +300,6 @@ main(int argc, char *argv[])
   dfilter_t           *dfcode = NULL;
   gchar               *err_msg;
   e_prefs             *prefs_p;
-  int                  log_flags;
   gchar               *output_only = NULL;
 
 /*
@@ -371,8 +347,19 @@ main(int argc, char *argv[])
   setlocale(LC_ALL, "");
 #endif
 
+  /* Initialize log handler early so we can have proper logging during startup. */
+  ws_log_init(NULL);
+
   cmdarg_err_init(tfshark_cmdarg_err, tfshark_cmdarg_err_cont);
 
+  /* Command line options are parsed too late to configure logging, do it
+      manually. */
+  const char *opt_err_val;
+  if ((opt_err_val = ws_log_set_level_args(&argc, argv)) != NULL) {
+    cmdarg_err("Invalid log level \"%s\"", opt_err_val);
+    return INVALID_OPTION;
+  }
+
 #ifdef _WIN32
   create_app_running_mutex();
 #endif /* _WIN32 */
@@ -460,24 +447,6 @@ main(int argc, char *argv[])
   if (print_summary == -1)
     print_summary = (print_details || print_hex) ? FALSE : TRUE;
 
-/** Send All g_log messages to our own handler **/
-
-  log_flags =
-                    G_LOG_LEVEL_ERROR|
-                    G_LOG_LEVEL_CRITICAL|
-                    G_LOG_LEVEL_WARNING|
-                    G_LOG_LEVEL_MESSAGE|
-                    G_LOG_LEVEL_INFO|
-                    G_LOG_LEVEL_DEBUG|
-                    G_LOG_FLAG_FATAL|G_LOG_FLAG_RECURSION;
-
-  g_log_set_handler(NULL,
-                    (GLogLevelFlags)log_flags,
-                    tfshark_log_handler, NULL /* user_data */);
-  g_log_set_handler(LOG_DOMAIN_MAIN,
-                    (GLogLevelFlags)log_flags,
-                    tfshark_log_handler, NULL /* user_data */);
-
   init_report_message("tfshark", &tfshark_report_routines);
 
   timestamp_set_type(TS_RELATIVE);
diff --git a/tshark.c b/tshark.c
index fddb346c65..a224c5eaf2 100644
--- a/tshark.c
+++ b/tshark.c
@@ -12,7 +12,7 @@
 
 #include <config.h>
 
-#define G_LOG_DOMAIN "tshark"
+#define WS_LOG_DOMAIN  LOG_DOMAIN_MAIN
 
 #include <stdlib.h>
 #include <stdio.h>
@@ -117,12 +117,12 @@
 #include <capture/capture_sync.h>
 #include <ui/capture_info.h>
 #endif /* HAVE_LIBPCAP */
-#include "log.h"
 #include <epan/funnel.h>
 
 #include <wsutil/str_util.h>
 #include <wsutil/utf8_entities.h>
 #include <wsutil/json_dumper.h>
+#include <wsutil/wslog.h>
 #ifdef _WIN32
 #include <wsutil/win32-utils.h>
 #endif
@@ -530,31 +530,6 @@ glossary_option_help(void)
   fprintf(output, "\n");
 }
 
-static void
-tshark_log_handler (const gchar *log_domain, GLogLevelFlags log_level,
-    const gchar *message, gpointer user_data)
-{
-  /* ignore log message, if log_level isn't interesting based
-     upon the console log preferences.
-     If the preferences haven't been loaded yet, display the
-     message anyway.
-
-     The default console_log_level preference value is such that only
-       ERROR, CRITICAL and WARNING level messages are processed;
-       MESSAGE, INFO and DEBUG level messages are ignored.
-
-     XXX: Aug 07, 2009: Prior tshark g_log code was hardwired to process only
-           ERROR and CRITICAL level messages so the current code is a behavioral
-           change.  The current behavior is the same as in Wireshark.
-  */
-  if (prefs_loaded && (log_level & G_LOG_LEVEL_MASK & prefs.console_log_level) == 0) {
-    return;
-  }
-
-  g_log_default_handler(log_domain, log_level, message, user_data);
-
-}
-
 static void
 print_current_user(void) {
   gchar *cur_user, *cur_group;
@@ -757,7 +732,6 @@ main(int argc, char *argv[])
   dfilter_t           *rfcode = NULL;
   dfilter_t           *dfcode = NULL;
   e_prefs             *prefs_p;
-  int                  log_flags;
   gchar               *output_only = NULL;
   gchar               *volatile pdu_export_arg = NULL;
   char                *volatile exp_pdu_filename = NULL;
@@ -798,10 +772,21 @@ main(int argc, char *argv[])
   setlocale(LC_ALL, "");
 #endif
 
-  ws_debug("tshark started with %d args", argc);
+  /* Initialize log handler early so we can have proper logging during startup. */
+  ws_log_init(NULL);
 
   cmdarg_err_init(tshark_cmdarg_err, tshark_cmdarg_err_cont);
 
+  /* Command line options are parsed too late to configure logging, do it
+      manually. */
+  const char *opt_err_val;
+  if ((opt_err_val = ws_log_set_level_args(&argc, argv)) != NULL) {
+    cmdarg_err("Invalid log level \"%s\"", opt_err_val);
+    return INVALID_OPTION;
+  }
+
+  ws_debug("tshark started with %d args", argc);
+
 #ifdef _WIN32
   create_app_running_mutex();
 #endif /* _WIN32 */
@@ -922,33 +907,6 @@ main(int argc, char *argv[])
     }
   }
 
-/** Send All g_log messages to our own handler **/
-
-  log_flags =
-                    G_LOG_LEVEL_ERROR|
-                    G_LOG_LEVEL_CRITICAL|
-                    G_LOG_LEVEL_WARNING|
-                    G_LOG_LEVEL_MESSAGE|
-                    G_LOG_LEVEL_INFO|
-                    G_LOG_LEVEL_DEBUG|
-                    G_LOG_FLAG_FATAL|G_LOG_FLAG_RECURSION;
-
-  g_log_set_handler(NULL,
-                    (GLogLevelFlags)log_flags,
-                    tshark_log_handler, NULL /* user_data */);
-  g_log_set_handler(LOG_DOMAIN_MAIN,
-                    (GLogLevelFlags)log_flags,
-                    tshark_log_handler, NULL /* user_data */);
-
-#ifdef HAVE_LIBPCAP
-  g_log_set_handler(LOG_DOMAIN_CAPTURE,
-                    (GLogLevelFlags)log_flags,
-                    tshark_log_handler, NULL /* user_data */);
-  g_log_set_handler(LOG_DOMAIN_CAPTURE_CHILD,
-                    (GLogLevelFlags)log_flags,
-                    tshark_log_handler, NULL /* user_data */);
-#endif
-
   init_report_message("TShark", &tshark_report_routines);
 
 #ifdef HAVE_LIBPCAP
@@ -2403,8 +2361,6 @@ pipe_timer_cb(gpointer data)
 
   /* try to read data from the pipe only 5 times, to avoid blocking */
   while(iterations < 5) {
-    /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: new iteration");*/
-
     /* Oddly enough although Named pipes don't work on win9x,
        PeekNamedPipe does !!! */
     handle = (HANDLE) _get_osfhandle (pipe_input_p->source);
@@ -2419,18 +2375,15 @@ pipe_timer_cb(gpointer data)
        callback */
     if (!result || avail > 0 || childstatus != STILL_ACTIVE) {
 
-      /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: data avail");*/
-
       /* And call the real handler */
       if (!pipe_input_p->input_cb(pipe_input_p->source, pipe_input_p->user_data)) {
-        g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: input pipe closed, iterations: %u", iterations);
+        ws_debug("input pipe closed, iterations: %u", iterations);
         /* pipe closed, return false so that the timer is stopped */
         g_mutex_unlock (pipe_input_p->callback_running);
         return FALSE;
       }
     }
     else {
-      /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: no data avail");*/
       /* No data, stop now */
       break;
     }
@@ -2438,8 +2391,6 @@ pipe_timer_cb(gpointer data)
     iterations++;
   }
 
-  /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: finished with iterations: %u, new timer", iterations);*/
-
   g_mutex_unlock (pipe_input_p->callback_running);
 
   /* we didn't stopped the timer, so let it run */
@@ -2465,7 +2416,6 @@ pipe_input_set_handler(gint source, gpointer user_data, ws_process_id *child_pro
      this but doesn't seem to work over processes.  Attempt to do
      something similar here, start a timer and check for data on every
      timeout. */
-  /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_input_set_handler: new");*/
   pipe_input.pipe_input_id = g_timeout_add(200, pipe_timer_cb, &pipe_input);
 #endif
 }
@@ -2627,7 +2577,7 @@ capture(void)
 #endif
         /* Call the real handler */
         if (!pipe_input.input_cb(pipe_input.source, pipe_input.user_data)) {
-          g_log(NULL, G_LOG_LEVEL_DEBUG, "input pipe closed");
+          ws_debug("input pipe closed");
           ret = FALSE;
           loop_running = FALSE;
         }
@@ -2704,9 +2654,9 @@ capture_input_new_file(capture_session *cap_session, gchar *new_file)
   int      err;
 
   if (cap_session->state == CAPTURE_PREPARING) {
-    g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture started.");
+    ws_message("Capture started.");
   }
-  g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "File: \"%s\"", new_file);
+  ws_message("File: \"%s\"", new_file);
 
   g_assert(cap_session->state == CAPTURE_PREPARING || cap_session->state == CAPTURE_RUNNING);
 
diff --git a/ui/capture.c b/ui/capture.c
index 8fcf3d4123..5cf1eb6129 100644
--- a/ui/capture.c
+++ b/ui/capture.c
@@ -9,6 +9,7 @@
  */
 
 #include "config.h"
+#define WS_LOG_DOMAIN LOG_DOMAIN_CAPTURE
 
 #ifdef HAVE_LIBPCAP
 
@@ -29,7 +30,6 @@
 #include "ui/util.h"
 #include "ui/urls.h"
 #include "capture/capture-pcap-util.h"
-#include <epan/prefs.h>
 
 #ifdef _WIN32
 #include "capture/capture-wpcap.h"
@@ -41,7 +41,7 @@
 #include "wsutil/file_util.h"
 #include "wsutil/str_util.h"
 #include <wsutil/filesystem.h>
-#include "log.h"
+#include <wsutil/wslog.h>
 
 typedef struct if_stat_cache_item_s {
     char *name;
@@ -122,7 +122,7 @@ capture_start(capture_options *capture_opts, capture_session *cap_session, info_
 
     cap_session->state = CAPTURE_PREPARING;
     cap_session->count = 0;
-    g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture Start ...");
+    ws_message("Capture Start ...");
     source = get_iface_list_string(capture_opts, IFLIST_SHOW_FILTER);
     cf_set_tempfile_source((capture_file *)cap_session->cf, source->str);
     g_string_free(source, TRUE);
@@ -134,7 +134,7 @@ capture_start(capture_options *capture_opts, capture_session *cap_session, info_
             capture_opts->save_file = NULL;
         }
 
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture Start failed.");
+        ws_message("Capture Start failed.");
         cap_session->state = CAPTURE_STOPPED;
         return FALSE;
     }
@@ -174,7 +174,7 @@ capture_start(capture_options *capture_opts, capture_session *cap_session, info_
 void
 capture_stop(capture_session *cap_session)
 {
-    g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture Stop ...");
+    ws_message("Capture Stop ...");
 
     capture_callback_invoke(capture_cb_capture_stopping, cap_session);
 
@@ -186,7 +186,7 @@ capture_stop(capture_session *cap_session)
 void
 capture_kill_child(capture_session *cap_session)
 {
-    g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_INFO, "Capture Kill");
+    ws_info("Capture Kill");
 
     /* kill the capture child */
     sync_pipe_kill(cap_session->fork_child);
@@ -379,9 +379,9 @@ capture_input_new_file(capture_session *cap_session, gchar *new_file)
     gchar *err_msg;
 
     if(cap_session->state == CAPTURE_PREPARING) {
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture started");
+        ws_message("Capture started");
     }
-    g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "File: \"%s\"", new_file);
+    ws_message("File: \"%s\"", new_file);
 
     g_assert(cap_session->state == CAPTURE_PREPARING || cap_session->state == CAPTURE_RUNNING);
 
@@ -555,9 +555,9 @@ static void
 capture_input_drops(capture_session *cap_session, guint32 dropped, const char* interface_name)
 {
     if (interface_name != NULL) {
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_INFO, "%u packet%s dropped from %s", dropped, plurality(dropped, "", "s"), interface_name);
+        ws_info("%u packet%s dropped from %s", dropped, plurality(dropped, "", "s"), interface_name);
     } else {
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_INFO, "%u packet%s dropped", dropped, plurality(dropped, "", "s"));
+        ws_info("%u packet%s dropped", dropped, plurality(dropped, "", "s"));
     }
 
     g_assert(cap_session->state == CAPTURE_RUNNING);
@@ -580,8 +580,7 @@ capture_input_error(capture_session *cap_session, char *error_msg,
     gchar *safe_error_msg;
     gchar *safe_secondary_error_msg;
 
-    g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Error message from child: \"%s\", \"%s\"",
-            error_msg, secondary_error_msg);
+    ws_message("Error message from child: \"%s\", \"%s\"", error_msg, secondary_error_msg);
 
     g_assert(cap_session->state == CAPTURE_PREPARING || cap_session->state == CAPTURE_RUNNING);
 
@@ -618,7 +617,7 @@ capture_input_cfilter_error(capture_session *cap_session, guint i,
     gchar *safe_cfilter_error_msg;
     interface_options *interface_opts;
 
-    g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture filter error message from child: \"%s\"", error_message);
+    ws_message("Capture filter error message from child: \"%s\"", error_message);
 
     g_assert(cap_session->state == CAPTURE_PREPARING || cap_session->state == CAPTURE_RUNNING);
     g_assert(i < capture_opts->ifaces->len);
@@ -665,7 +664,7 @@ capture_input_closed(capture_session *cap_session, gchar *msg)
     capture_options *capture_opts = cap_session->capture_opts;
     int  err;
 
-    g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_MESSAGE, "Capture stopped.");
+    ws_message("Capture stopped.");
     g_assert(cap_session->state == CAPTURE_PREPARING || cap_session->state == CAPTURE_RUNNING);
 
     if (msg != NULL)
diff --git a/ui/console.c b/ui/console.c
index 71cd3b8ebf..1a1af2ebd7 100644
--- a/ui/console.c
+++ b/ui/console.c
@@ -18,127 +18,33 @@
 
 #include "console.h"
 
-#include "log.h"
-
-static void
-console_log_handler(const char *log_domain, GLogLevelFlags log_level,
-                    const char *message, gpointer user_data _U_)
+void
+console_log_writer(const char *message, enum ws_log_domain domain _U_,
+                    enum ws_log_level level, void *ptr _U_)
 {
-    /* ignore log message, if log_level isn't interesting based
-       upon the console log preferences.
-       If the preferences haven't been loaded loaded yet, display the
-       message anyway.
-
-       The default console_log_level preference value is such that only
-         ERROR, CRITICAL and WARNING level messages are processed;
-         MESSAGE, INFO and DEBUG level messages are ignored.  */
-    if((log_level & G_LOG_LEVEL_MASK & prefs.console_log_level) == 0 &&
-        prefs.console_log_level != 0) {
-        return;
-    }
-
+    gboolean fatal = level == LOG_LEVEL_ERROR;
 #ifdef _WIN32
-    time_t curr;
-    struct tm *today;
-    const char *level;
-    FILE *stream = stderr;
-
-    if (prefs.gui_console_open != console_open_never || log_level & G_LOG_LEVEL_ERROR) {
+    if (prefs.gui_console_open != console_open_never || fatal) {
         /* the user wants a console or the application will terminate immediately */
         create_console();
     }
+#else
+    (void)fatal;
+#endif /* _WIN32 */
 
-    switch(log_level & G_LOG_LEVEL_MASK) {
-        case G_LOG_LEVEL_ERROR:
-            level = "Err ";
-            break;
-        case G_LOG_LEVEL_CRITICAL:
-            level = "Crit";
-            break;
-        case G_LOG_LEVEL_WARNING:
-            level = "Warn";
-            break;
-        case G_LOG_LEVEL_MESSAGE:
-            level = "Msg ";
-            break;
-        case G_LOG_LEVEL_INFO:
-            level = "Info";
-            stream = stdout;
-            break;
-        case G_LOG_LEVEL_DEBUG:
-            level = "Dbg ";
-            stream = stdout;
-            break;
-        default:
-            fprintf(stderr, "unknown log_level %d\n", log_level);
-            level = NULL;
-            g_assert_not_reached();
-    }
+    FILE *fp = stderr;
+    g_assert(message);
 
-    /* create a "timestamp" */
-    time(&curr);
-    today = localtime(&curr);
-    guint64 microseconds = create_timestamp();
-    if (today != NULL) {
-            fprintf(stream, "%02d:%02d:%02d.%03" G_GUINT64_FORMAT " %8s %s %s\n",
-                    today->tm_hour, today->tm_min, today->tm_sec,
-                    microseconds % 1000000 / 1000,
-                    log_domain != NULL ? log_domain : "",
-                    level, message);
-    } else {
-            fprintf(stream, "Time not representable %8s %s %s\n",
-                    log_domain != NULL ? log_domain : "",
-                    level, message);
-    }
-    fflush(stream);
+    fputs(message, fp);
+    fputc('\n', fp);
+    fflush(fp);
 
-    if(log_level & G_LOG_LEVEL_ERROR) {
+#ifdef _WIN32
+    if (fatal) {
         /* wait for a key press before the following error handler will terminate the program
             this way the user at least can read the error message */
         printf("\n\nPress any key to exit\n");
         _getch();
     }
-#else /* _WIN32 */
-    g_log_default_handler(log_domain, log_level, message, NULL);
 #endif /* _WIN32 */
 }
-
-void set_console_log_handler(void)
-{
-    GLogLevelFlags log_flags;
-    /* Arrange that if we have no console window, and a GLib message logging
-       routine is called to log a message, we pop up a console window.
-
-       We do that by inserting our own handler for all messages logged
-       to the default domain; that handler pops up a console if necessary,
-       and then calls the default handler. */
-
-    /* We might want to have component specific log levels later ... */
-
-    log_flags = (GLogLevelFlags)
-                (G_LOG_LEVEL_ERROR|
-                 G_LOG_LEVEL_CRITICAL|
-                 G_LOG_LEVEL_WARNING|
-                 G_LOG_LEVEL_MESSAGE|
-                 G_LOG_LEVEL_INFO|
-                 G_LOG_LEVEL_DEBUG|
-                 G_LOG_FLAG_FATAL|
-                 G_LOG_FLAG_RECURSION);
-
-    g_log_set_handler(NULL,
-                      log_flags,
-                      console_log_handler, NULL /* user_data */);
-    g_log_set_handler(LOG_DOMAIN_MAIN,
-                      log_flags,
-                      console_log_handler, NULL /* user_data */);
-
-#ifdef HAVE_LIBPCAP
-    g_log_set_handler(LOG_DOMAIN_CAPTURE,
-                      log_flags,
-                      console_log_handler, NULL /* user_data */);
-    g_log_set_handler(LOG_DOMAIN_CAPTURE_CHILD,
-                    log_flags,
-                    console_log_handler, NULL /* user_data */);
-
-#endif
-}
diff --git a/ui/console.h b/ui/console.h
index 1506fa0936..196ef231f9 100644
--- a/ui/console.h
+++ b/ui/console.h
@@ -21,9 +21,13 @@
 extern "C" {
 #endif /* __cplusplus */
 
-/** Set the console log handler.
+#include <wsutil/wslog.h>
+
+/** The GUI log writer.
  */
-void set_console_log_handler(void);
+void
+console_log_writer(const char *message, enum ws_log_domain domain,
+                    enum ws_log_level level, void *ptr);
 
 #ifdef __cplusplus
 }
diff --git a/ui/iface_lists.c b/ui/iface_lists.c
index 26610bc38e..408a111ccb 100644
--- a/ui/iface_lists.c
+++ b/ui/iface_lists.c
@@ -19,11 +19,11 @@
 
 #include <epan/prefs.h>
 #include <epan/to_str.h>
+#include <wsutil/wslog.h>
 
 #include "ui/capture_ui_utils.h"
 #include "ui/capture_globals.h"
 #include "ui/iface_lists.h"
-#include "../log.h"
 
 /*
  * Try to populate the given device with options (like capture filter) from
@@ -433,7 +433,7 @@ fill_in_local_interfaces(void(*update_cb)(void))
 
     /* record the time we started, so we can log total time later */
     start_time = g_get_monotonic_time();
-    g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_INFO, "fill_in_local_interfaces() starts");
+    ws_log(LOG_DOMAIN_MAIN, LOG_LEVEL_INFO, "fill_in_local_interfaces() starts");
 
     if (!initialized) {
         /* do the actual work */
@@ -443,7 +443,7 @@ fill_in_local_interfaces(void(*update_cb)(void))
     /* log how long it took */
     elapsed = (g_get_monotonic_time() - start_time) / 1e6;
 
-    g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_INFO, "fill_in_local_interfaces() ends, taking %.3fs", elapsed);
+    ws_log(LOG_DOMAIN_MAIN, LOG_LEVEL_INFO, "fill_in_local_interfaces() ends, taking %.3fs", elapsed);
 }
 
 void
diff --git a/ui/qt/about_dialog.cpp b/ui/qt/about_dialog.cpp
index e60ef8a327..14535baa60 100644
--- a/ui/qt/about_dialog.cpp
+++ b/ui/qt/about_dialog.cpp
@@ -28,8 +28,6 @@
 #include <epan/wslua/init_wslua.h>
 #endif
 
-#include "log.h"
-
 #include "ui/alert_box.h"
 #include "ui/last_open_dir.h"
 #include "ui/help_url.h"
diff --git a/ui/qt/capture_file.cpp b/ui/qt/capture_file.cpp
index 522012482c..7b6cb97051 100644
--- a/ui/qt/capture_file.cpp
+++ b/ui/qt/capture_file.cpp
@@ -19,7 +19,6 @@
 capture_file cfile;
 
 #include "file.h"
-#include "log.h"
 
 #include "epan/epan_dissect.h"
 
diff --git a/ui/qt/extcap_argument.cpp b/ui/qt/extcap_argument.cpp
index a8d677fb52..9b0db2021c 100644
--- a/ui/qt/extcap_argument.cpp
+++ b/ui/qt/extcap_argument.cpp
@@ -32,11 +32,11 @@
 #include <QRegExp>
 
 #include <glib.h>
-#include <log.h>
 
 #include <extcap.h>
 #include <epan/prefs.h>
 #include <epan/prefs-int.h>
+#include <wsutil/wslog.h>
 #include <ui/qt/utils/color_utils.h>
 
 #include <extcap_parser.h>
@@ -542,7 +542,7 @@ QWidget * ExtArgNumber::createEditor(QWidget * parent)
                 guint tmp = extcap_complex_get_uint(_argument->range_start);
                 if (tmp > G_MAXINT)
                 {
-                    g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "Defined value for range_start of %s exceeds valid integer range", _argument->call);
+                    ws_log(LOG_DOMAIN_CAPTURE, LOG_LEVEL_DEBUG, "Defined value for range_start of %s exceeds valid integer range", _argument->call);
                     val = G_MAXINT;
                 }
                 else
@@ -553,7 +553,7 @@ QWidget * ExtArgNumber::createEditor(QWidget * parent)
         }
         if (_argument->arg_type == EXTCAP_ARG_UNSIGNED && textValidator->bottom() < 0)
         {
-            g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "%s sets negative bottom range for unsigned value, setting to 0", _argument->call);
+            ws_log(LOG_DOMAIN_CAPTURE, LOG_LEVEL_DEBUG, "%s sets negative bottom range for unsigned value, setting to 0", _argument->call);
             textValidator->setBottom(0);
         }
 
@@ -567,7 +567,7 @@ QWidget * ExtArgNumber::createEditor(QWidget * parent)
                 guint tmp = extcap_complex_get_uint(_argument->range_end);
                 if (tmp > G_MAXINT)
                 {
-                    g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "Defined value for range_end of %s exceeds valid integer range", _argument->call);
+                    ws_log(LOG_DOMAIN_CAPTURE, LOG_LEVEL_DEBUG, "Defined value for range_end of %s exceeds valid integer range", _argument->call);
                     val = G_MAXINT;
                 }
                 else
diff --git a/ui/qt/interface_toolbar.cpp b/ui/qt/interface_toolbar.cpp
index f8680866a1..601b741949 100644
--- a/ui/qt/interface_toolbar.cpp
+++ b/ui/qt/interface_toolbar.cpp
@@ -22,7 +22,6 @@
 #include "sync_pipe.h"
 #include "wsutil/file_util.h"
 
-#include "log.h"
 #ifdef _WIN32
 #include <wsutil/win32-utils.h>
 #endif
diff --git a/ui/qt/main.cpp b/ui/qt/main.cpp
index 73d855c021..53baad6b0f 100644
--- a/ui/qt/main.cpp
+++ b/ui/qt/main.cpp
@@ -41,6 +41,7 @@
 #include <wsutil/filesystem.h>
 #include <wsutil/privileges.h>
 #include <wsutil/socket.h>
+#include <wsutil/wslog.h>
 #ifdef HAVE_PLUGINS
 #include <wsutil/plugins.h>
 #endif
@@ -70,7 +71,6 @@
 /* general (not Qt specific) */
 #include "file.h"
 #include "epan/color_filters.h"
-#include "log.h"
 
 #include "epan/rtd_table.h"
 #include "epan/srt_table.h"
@@ -129,19 +129,6 @@
 #include <ui/qt/utils/qt_ui_utils.h>
 
 //#define DEBUG_STARTUP_TIME 1
-/*
-# Log level
-# Console log level (for debugging)
-# A bitmask of log levels:
-# ERROR    = 4
-# CRITICAL = 8
-# WARNING  = 16
-# MESSAGE  = 32
-# INFO     = 64
-# DEBUG    = 128
-
-#define DEBUG_STARTUP_TIME_LOGLEVEL 252
-*/
 
 /* update the main window */
 void main_window_update(void)
@@ -335,29 +322,29 @@ get_wireshark_runtime_info(GString *str)
 }
 
 static void
-g_log_message_handler(QtMsgType type, const QMessageLogContext &, const QString &msg)
+qt_log_message_handler(QtMsgType type, const QMessageLogContext &, const QString &msg)
 {
-    GLogLevelFlags log_level = G_LOG_LEVEL_DEBUG;
+    enum ws_log_level log_level = LOG_LEVEL_DEBUG;
 
     switch (type) {
     case QtInfoMsg:
-        log_level = G_LOG_LEVEL_INFO;
+        log_level = LOG_LEVEL_INFO;
         break;
     // We want qDebug() messages to show up at our default log level.
     case QtDebugMsg:
     case QtWarningMsg:
-        log_level = G_LOG_LEVEL_WARNING;
+        log_level = LOG_LEVEL_WARNING;
         break;
     case QtCriticalMsg:
-        log_level = G_LOG_LEVEL_CRITICAL;
+        log_level = LOG_LEVEL_CRITICAL;
         break;
     case QtFatalMsg:
-        log_level = G_LOG_FLAG_FATAL;
+        log_level = LOG_LEVEL_ERROR;
         break;
     default:
         break;
     }
-    g_log(LOG_DOMAIN_MAIN, log_level, "%s", qUtf8Printable(msg));
+    ws_log(LOG_DOMAIN_MAIN, log_level, "%s", qUtf8Printable(msg));
 }
 
 #ifdef HAVE_LIBPCAP
@@ -542,18 +529,16 @@ int main(int argc, char *qt_argv[])
     macos_enable_layer_backing();
 #endif
 
-    /* Enable destinations for logging earlier in startup */
-    set_console_log_handler();
-    qInstallMessageHandler(g_log_message_handler);
+    /* Initialize log handler early so we can have proper logging during startup. */
+    ws_log_init(console_log_writer);
+
+    qInstallMessageHandler(qt_log_message_handler);
+
 #ifdef _WIN32
     restore_pipes();
 #endif
 
 #ifdef DEBUG_STARTUP_TIME
-    /* At least on Windows there is a problem with the logging as the preferences is taken
-     * into account and the preferences are loaded pretty late in the startup process.
-     */
-    prefs.console_log_level = DEBUG_STARTUP_TIME_LOGLEVEL;
     prefs.gui_console_open = console_open_always;
 #endif /* DEBUG_STARTUP_TIME */
     cmdarg_err_init(wireshark_cmdarg_err, wireshark_cmdarg_err_cont);
@@ -595,6 +580,14 @@ int main(int argc, char *qt_argv[])
     create_app_running_mutex();
 #endif /* _WIN32 */
 
+    /* Command line options are parsed too late to configure logging, do it
+        manually. */
+    const char *opt_err_val;
+    if ((opt_err_val = ws_log_set_level_args(&argc, argv)) != NULL) {
+        cmdarg_err("Invalid log level \"%s\"", opt_err_val);
+        exit_application(INVALID_OPTION);
+    }
+
     /*
      * Get credential information for later use, and drop privileges
      * before doing anything else.
@@ -608,7 +601,7 @@ int main(int argc, char *qt_argv[])
      * executable file.
      */
     /* init_progfile_dir_error = */ init_progfile_dir(argv[0]);
-    /* g_log(NULL, G_LOG_LEVEL_DEBUG, "progfile_dir: %s", get_progfile_dir()); */
+    /* ws_log(NULL, LOG_LEVEL_DEBUG, "progfile_dir: %s", get_progfile_dir()); */
 
 #ifdef _WIN32
     ws_init_dll_search_path();
@@ -741,7 +734,7 @@ int main(int argc, char *qt_argv[])
     read_language_prefs();
     wsApp->loadLanguage(language);
 
-    /* g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "Translator %s", language); */
+    /* ws_log(LOG_DOMAIN_MAIN, LOG_LEVEL_DEBUG, "Translator %s", language); */
 
     // Init the main window (and splash)
     main_w = new(MainWindow);
@@ -763,7 +756,7 @@ int main(int argc, char *qt_argv[])
     }
 
 #ifdef DEBUG_STARTUP_TIME
-    g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_INFO, "set_console_log_handler, elapsed time %" G_GUINT64_FORMAT " us \n", g_get_monotonic_time() - start_time);
+    ws_log(LOG_DOMAIN_MAIN, LOG_LEVEL_INFO, "set_console_log_handler, elapsed time %" G_GUINT64_FORMAT " us \n", g_get_monotonic_time() - start_time);
 #endif
 
 #ifdef HAVE_LIBPCAP
@@ -783,7 +776,7 @@ int main(int argc, char *qt_argv[])
 
     splash_update(RA_DISSECTORS, NULL, NULL);
 #ifdef DEBUG_STARTUP_TIME
-    g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_INFO, "Calling epan init, elapsed time %" G_GUINT64_FORMAT " us \n", g_get_monotonic_time() - start_time);
+    ws_log(LOG_DOMAIN_MAIN, LOG_LEVEL_INFO, "Calling epan init, elapsed time %" G_GUINT64_FORMAT " us \n", g_get_monotonic_time() - start_time);
 #endif
     /* Register all dissectors; we must do this before checking for the
        "-G" flag, as the "-G" flag dumps information registered by the
@@ -796,9 +789,8 @@ int main(int argc, char *qt_argv[])
     }
 #ifdef DEBUG_STARTUP_TIME
     /* epan_init resets the preferences */
-    prefs.console_log_level = DEBUG_STARTUP_TIME_LOGLEVEL;
     prefs.gui_console_open = console_open_always;
-    g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_INFO, "epan done, elapsed time %" G_GUINT64_FORMAT " us \n", g_get_monotonic_time() - start_time);
+    ws_log(LOG_DOMAIN_MAIN, LOG_LEVEL_INFO, "epan done, elapsed time %" G_GUINT64_FORMAT " us \n", g_get_monotonic_time() - start_time);
 #endif
 
     /* Register all audio codecs. */
@@ -817,7 +809,7 @@ int main(int argc, char *qt_argv[])
 
     splash_update(RA_LISTENERS, NULL, NULL);
 #ifdef DEBUG_STARTUP_TIME
-    g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_INFO, "Register all tap listeners, elapsed time %" G_GUINT64_FORMAT " us \n", g_get_monotonic_time() - start_time);
+    ws_log(LOG_DOMAIN_MAIN, LOG_LEVEL_INFO, "Register all tap listeners, elapsed time %" G_GUINT64_FORMAT " us \n", g_get_monotonic_time() - start_time);
 #endif
     /* Register all tap listeners; we do this before we parse the arguments,
        as the "-z" argument can specify a registered tap. */
@@ -835,13 +827,13 @@ int main(int argc, char *qt_argv[])
     }
 
 #ifdef DEBUG_STARTUP_TIME
-    g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_INFO, "Calling extcap_register_preferences, elapsed time %" G_GUINT64_FORMAT " us \n", g_get_monotonic_time() - start_time);
+    ws_log(LOG_DOMAIN_MAIN, LOG_LEVEL_INFO, "Calling extcap_register_preferences, elapsed time %" G_GUINT64_FORMAT " us \n", g_get_monotonic_time() - start_time);
 #endif
     splash_update(RA_EXTCAP, NULL, NULL);
     extcap_register_preferences();
     splash_update(RA_PREFERENCES, NULL, NULL);
 #ifdef DEBUG_STARTUP_TIME
-    g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_INFO, "Calling module preferences, elapsed time %" G_GUINT64_FORMAT " us \n", g_get_monotonic_time() - start_time);
+    ws_log(LOG_DOMAIN_MAIN, LOG_LEVEL_INFO, "Calling module preferences, elapsed time %" G_GUINT64_FORMAT " us \n", g_get_monotonic_time() - start_time);
 #endif
 
     global_commandline_info.prefs_p = ws_app.readConfigurationFiles(false);
@@ -863,7 +855,7 @@ int main(int argc, char *qt_argv[])
 
 #ifdef HAVE_LIBPCAP
 #ifdef DEBUG_STARTUP_TIME
-    g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_INFO, "Calling fill_in_local_interfaces, elapsed time %" G_GUINT64_FORMAT " us \n", g_get_monotonic_time() - start_time);
+    ws_log(LOG_DOMAIN_MAIN, LOG_LEVEL_INFO, "Calling fill_in_local_interfaces, elapsed time %" G_GUINT64_FORMAT " us \n", g_get_monotonic_time() - start_time);
 #endif
     splash_update(RA_INTERFACES, NULL, NULL);
 
@@ -940,7 +932,7 @@ int main(int argc, char *qt_argv[])
        changed either from one of the preferences file or from the command
        line that their preferences have changed. */
 #ifdef DEBUG_STARTUP_TIME
-    g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_INFO, "Calling prefs_apply_all, elapsed time %" G_GUINT64_FORMAT " us \n", g_get_monotonic_time() - start_time);
+    ws_log(LOG_DOMAIN_MAIN, LOG_LEVEL_INFO, "Calling prefs_apply_all, elapsed time %" G_GUINT64_FORMAT " us \n", g_get_monotonic_time() - start_time);
 #endif
     prefs_apply_all();
     prefs_to_capture_opts();
@@ -986,7 +978,7 @@ int main(int argc, char *qt_argv[])
     }
 
     wsApp->allSystemsGo();
-    g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_INFO, "Wireshark is up and ready to go, elapsed time %.3fs\n", (float) (g_get_monotonic_time() - start_time) / 1000000);
+    ws_log(LOG_DOMAIN_MAIN, LOG_LEVEL_INFO, "Wireshark is up and ready to go, elapsed time %.3fs\n", (float) (g_get_monotonic_time() - start_time) / 1000000);
     SimpleDialog::displayQueuedMessages(main_w);
 
     /* User could specify filename, or display filter, or both */
diff --git a/ui/qt/main_window.cpp b/ui/qt/main_window.cpp
index 56fbd3d1b4..119950cb86 100644
--- a/ui/qt/main_window.cpp
+++ b/ui/qt/main_window.cpp
@@ -21,6 +21,7 @@ DIAG_ON(frame-larger-than=)
 #include "epan/conversation_filter.h"
 #include <epan/epan_dissect.h>
 #include <wsutil/filesystem.h>
+#include <wsutil/wslog.h>
 #include <version_info.h>
 #include <epan/prefs.h>
 #include <epan/stats_tree_priv.h>
@@ -843,7 +844,7 @@ void MainWindow::setPipeInputHandler(gint source, gpointer user_data, ws_process
        this but doesn't seem to work over processes.  Attempt to do
        something similar here, start a timer and check for data on every
        timeout. */
-       /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_input_set_handler: new");*/
+       /*ws_log(NULL, LOG_LEVEL_DEBUG, "pipe_input_set_handler: new");*/
 
     if (pipe_timer_) {
         disconnect(pipe_timer_, SIGNAL(timeout()), this, SLOT(pipeTimeout()));
diff --git a/ui/qt/main_window_slots.cpp b/ui/qt/main_window_slots.cpp
index 947914411c..d810d44e5c 100644
--- a/ui/qt/main_window_slots.cpp
+++ b/ui/qt/main_window_slots.cpp
@@ -44,6 +44,7 @@ DIAG_ON(frame-larger-than=)
 
 #include "wsutil/file_util.h"
 #include "wsutil/filesystem.h"
+#include <wsutil/wslog.h>
 
 #include "epan/addr_resolv.h"
 #include "epan/column.h"
@@ -927,8 +928,6 @@ void MainWindow::pipeTimeout() {
 
     /* try to read data from the pipe only 5 times, to avoid blocking */
     while (iterations < 5) {
-        /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: new iteration");*/
-
         /* Oddly enough although Named pipes don't work on win9x,
            PeekNamedPipe does !!! */
         handle = (HANDLE)_get_osfhandle(pipe_source_);
@@ -943,17 +942,14 @@ void MainWindow::pipeTimeout() {
            callback */
         if (!result || avail > 0 || childstatus != STILL_ACTIVE) {
 
-            /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: data avail");*/
-
             /* And call the real handler */
             if (!pipe_input_cb_(pipe_source_, pipe_user_data_)) {
-                g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: input pipe closed, iterations: %u", iterations);
+                ws_log(LOG_DOMAIN_DEFAULT, LOG_LEVEL_DEBUG, "pipe_timer_cb: input pipe closed, iterations: %u", iterations);
                 /* pipe closed, return false so that the old timer is not run again */
                 delete pipe_timer_;
                 return;
             }
         } else {
-            /*g_log(NULL, G_LOG_LEVEL_DEBUG, "pipe_timer_cb: no data avail");*/
             /* No data, stop now */
             break;
         }
diff --git a/ui/qt/models/credentials_model.cpp b/ui/qt/models/credentials_model.cpp
index 5530514a5e..747213b9b0 100644
--- a/ui/qt/models/credentials_model.cpp
+++ b/ui/qt/models/credentials_model.cpp
@@ -13,7 +13,6 @@
 #include "credentials_model.h"
 
 #include <file.h>
-#include <log.h>
 #include <ui/qt/utils/qt_ui_utils.h>
 
 CredentialsModel::CredentialsModel(QObject *parent)
diff --git a/ui/qt/sctp_chunk_statistics_dialog.cpp b/ui/qt/sctp_chunk_statistics_dialog.cpp
index 6caa180212..291a0fba7c 100644
--- a/ui/qt/sctp_chunk_statistics_dialog.cpp
+++ b/ui/qt/sctp_chunk_statistics_dialog.cpp
@@ -13,6 +13,7 @@
 #include "uat_dialog.h"
 
 #include <wsutil/strtoi.h>
+#include <wsutil/wslog.h>
 
 #include "ui/tap-sctp-analysis.h"
 #include <ui/qt/utils/qt_ui_utils.h>
@@ -89,7 +90,7 @@ void SCTPChunkStatisticsDialog::fillTable(bool all, const sctp_assoc_info_t *sel
 
     pref_t *pref = prefs_find_preference(prefs_find_module("sctp"),"statistics_chunk_types");
     if (!pref) {
-        g_log(NULL, G_LOG_LEVEL_ERROR, "Can't find preference sctp/statistics_chunk_types");
+        ws_log(LOG_DOMAIN_QTUI, LOG_LEVEL_ERROR, "Can't find preference sctp/statistics_chunk_types");
         return;
     }
     uat_t *uat = prefs_get_uat_value(pref);
@@ -105,7 +106,7 @@ void SCTPChunkStatisticsDialog::fillTable(bool all, const sctp_assoc_info_t *sel
             if (errno == ENOENT) {
                 init = true;
             } else {
-                g_log(NULL, G_LOG_LEVEL_ERROR, "Can't open %s: %s", fname, g_strerror(errno));
+                ws_log(LOG_DOMAIN_QTUI, LOG_LEVEL_ERROR, "Can't open %s: %s", fname, g_strerror(errno));
                 return;
             }
         }
@@ -213,7 +214,7 @@ void SCTPChunkStatisticsDialog::on_pushButton_clicked()
 
     pref_t *pref = prefs_find_preference(prefs_find_module("sctp"),"statistics_chunk_types");
     if (!pref) {
-        g_log(NULL, G_LOG_LEVEL_ERROR, "Can't find preference sctp/statistics_chunk_types");
+        ws_log(LOG_DOMAIN_QTUI, LOG_LEVEL_ERROR, "Can't find preference sctp/statistics_chunk_types");
         return;
     }
 
@@ -290,7 +291,7 @@ void SCTPChunkStatisticsDialog::on_actionChunkTypePreferences_triggered()
 
     pref_t *pref = prefs_find_preference(prefs_find_module("sctp"),"statistics_chunk_types");
     if (!pref) {
-        g_log(NULL, G_LOG_LEVEL_ERROR, "Can't find preference sctp/statistics_chunk_types");
+        ws_log(LOG_DOMAIN_QTUI, LOG_LEVEL_ERROR, "Can't find preference sctp/statistics_chunk_types");
         return;
     }
 
@@ -299,7 +300,7 @@ void SCTPChunkStatisticsDialog::on_actionChunkTypePreferences_triggered()
 
     if (!uat_load(uat, NULL, &err)) {
         /* XXX - report this through the GUI */
-        g_log(NULL, G_LOG_LEVEL_WARNING, "Error loading table '%s': %s", uat->name, err);
+        ws_log(LOG_DOMAIN_QTUI, LOG_LEVEL_WARNING, "Error loading table '%s': %s", uat->name, err);
         g_free(err);
     }
 
diff --git a/ui/qt/simple_dialog.cpp b/ui/qt/simple_dialog.cpp
index b1a08bc791..5e57a7bc03 100644
--- a/ui/qt/simple_dialog.cpp
+++ b/ui/qt/simple_dialog.cpp
@@ -9,7 +9,6 @@
 
 #include "simple_dialog.h"
 
-#include "log.h"
 #include "file.h"
 
 #include "epan/strutil.h"
@@ -18,6 +17,7 @@
 #include "ui/commandline.h"
 
 #include <wsutil/utf8_entities.h>
+#include <wsutil/wslog.h>
 
 #include <ui/qt/utils/qt_ui_utils.h>
 #include "wireshark_application.h"
@@ -63,7 +63,7 @@ static void visible_message_finished(QMessageBox *box, int result _U_)
     visible_messages_mutex.lock();
     for (int i = 0; i < visible_messages.size(); i++) {
         if (visible_messages[i].box == box) {
-            g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_WARNING, "%d duplicates of \"%s\" were suppressed",
+            ws_log(LOG_DOMAIN_MAIN, LOG_LEVEL_WARNING, "%d duplicates of \"%s\" were suppressed",
                 visible_messages[i].counter, box->text().toStdString().c_str());
             visible_messages.removeAt(i);
             break;
diff --git a/ui/qt/traffic_table_dialog.cpp b/ui/qt/traffic_table_dialog.cpp
index c1d7883036..0f6ab018aa 100644
--- a/ui/qt/traffic_table_dialog.cpp
+++ b/ui/qt/traffic_table_dialog.cpp
@@ -7,7 +7,6 @@
  * SPDX-License-Identifier: GPL-2.0-or-later
  */
 
-#include "log.h"
 #include "traffic_table_dialog.h"
 #include <ui_traffic_table_dialog.h>
 
diff --git a/ui/qt/widgets/wireless_timeline.cpp b/ui/qt/widgets/wireless_timeline.cpp
index 732568b2bc..eef8b8562e 100644
--- a/ui/qt/widgets/wireless_timeline.cpp
+++ b/ui/qt/widgets/wireless_timeline.cpp
@@ -23,7 +23,6 @@
 #include <cmath>
 
 #include "globals.h"
-#include "../../log.h"
 #include <epan/dissectors/packet-ieee80211-radio.h>
 
 #include <epan/color_filters.h>
diff --git a/ui/qt/wireshark_application.cpp b/ui/qt/wireshark_application.cpp
index 6c5662ced1..676b598a23 100644
--- a/ui/qt/wireshark_application.cpp
+++ b/ui/qt/wireshark_application.cpp
@@ -43,7 +43,6 @@
 #include "coloring_rules_dialog.h"
 
 #include "epan/color_filters.h"
-#include "log.h"
 #include "recent_file_status.h"
 
 #include "extcap.h"
diff --git a/ui/tap-tcp-stream.c b/ui/tap-tcp-stream.c
index e9d0bef7a1..d838c3a8de 100644
--- a/ui/tap-tcp-stream.c
+++ b/ui/tap-tcp-stream.c
@@ -105,8 +105,6 @@ graph_segment_list_get(capture_file *cf, struct tcp_graph *tg)
     GString    *error_string;
     tcp_scan_t  ts;
 
-    g_log(NULL, G_LOG_LEVEL_DEBUG, "graph_segment_list_get()");
-
     if (!cf || !tg) {
         return;
     }
diff --git a/ui/win32/console_win32.c b/ui/win32/console_win32.c
index 22b7d10a7d..744791fe7d 100644
--- a/ui/win32/console_win32.c
+++ b/ui/win32/console_win32.c
@@ -93,18 +93,6 @@ needs_redirection(int std_handle)
     return FALSE;
 }
 
-/* The code to create and desstroy console windows should not be necessary,
-   at least as I read the GLib source code, as it looks as if GLib is, on
-   Win32, *supposed* to create a console window into which to display its
-   output.
-
-   That doesn't happen, however.  I suspect there's something completely
-   broken about that code in GLib-for-Win32, and that it may be related
-   to the breakage that forces us to just call "printf()" on the message
-   rather than passing the message on to "g_log_default_handler()"
-   (which is the routine that does the aforementioned non-functional
-   console window creation).  */
-
 /*
  * If this application has no console window to which its standard output
  * would go, create one.
diff --git a/wiretap/ipfix.c b/wiretap/ipfix.c
index 64740f4cd0..020e9895f4 100644
--- a/wiretap/ipfix.c
+++ b/wiretap/ipfix.c
@@ -48,7 +48,7 @@
 
 #include "config.h"
 
-#define G_LOG_DOMAIN "wiretap"
+#define WS_LOG_DOMAIN LOG_DOMAIN_WIRETAP
 
 #include <stdlib.h>
 #include <string.h>
diff --git a/wiretap/merge.c b/wiretap/merge.c
index 7bca49627e..824c7cf6b2 100644
--- a/wiretap/merge.c
+++ b/wiretap/merge.c
@@ -14,7 +14,7 @@
 
 #include "config.h"
 
-#define G_LOG_DOMAIN "wiretap"
+#define WS_LOG_DOMAIN LOG_DOMAIN_WIRETAP
 
 #include <stdlib.h>
 #include <errno.h>
diff --git a/wiretap/pcapng.c b/wiretap/pcapng.c
index 923ad242fe..4918bdf65f 100644
--- a/wiretap/pcapng.c
+++ b/wiretap/pcapng.c
@@ -17,7 +17,7 @@
 
 #include "config.h"
 
-#define G_LOG_DOMAIN "wiretap"
+#define WS_LOG_DOMAIN LOG_DOMAIN_WIRETAP
 
 #include <stdlib.h>
 #include <string.h>
diff --git a/ws_log_domains.h b/ws_log_domains.h
new file mode 100644
index 0000000000..29ad446402
--- /dev/null
+++ b/ws_log_domains.h
@@ -0,0 +1,44 @@
+/* ws_log_domains.h
+ * log domain definitions
+ *
+ * Wireshark - Network traffic analyzer
+ * By Gerald Combs <gerald@wireshark.org>
+ * Copyright 1998 Gerald Combs
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ */
+
+#ifndef __WS_LOG_DOMAINS_H__
+#define __WS_LOG_DOMAINS_H__
+
+enum ws_log_domain {
+     /* Default domain */
+     LOG_DOMAIN_DEFAULT,
+     /* Main execution domain (wireshark, tshark, etc) */
+     LOG_DOMAIN_MAIN,
+     /* Capture domain (except for capture child, see below) */
+     LOG_DOMAIN_CAPTURE,
+     /* Capture child domain (the capture child might also contain
+      * file domain messages!) */
+     LOG_DOMAIN_CAPCHILD,
+     LOG_DOMAIN_WIRETAP,
+     LOG_DOMAIN_EPAN,
+     LOG_DOMAIN_WSUTIL,
+     LOG_DOMAIN_QTUI,
+     _LOG_DOMAIN_LAST
+};
+
+#endif /* __WS_LOG_DOMAINS_H__ */
+
+/*
+ * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
+ *
+ * Local variables:
+ * c-basic-offset: 4
+ * tab-width: 8
+ * indent-tabs-mode: nil
+ * End:
+ *
+ * vi: set shiftwidth=4 tabstop=8 expandtab:
+ * :indentSize=4:tabSize=8:noTabs=true:
+ */
diff --git a/wsutil/rsa.c b/wsutil/rsa.c
index 740173db59..632d36c908 100644
--- a/wsutil/rsa.c
+++ b/wsutil/rsa.c
@@ -10,13 +10,14 @@
  */
 
 #include "config.h"
+#define WS_LOG_DOMAIN LOG_DOMAIN_WSUTIL
 
 #include "rsa.h"
 #include <glib.h>
 #include "filesystem.h"
 #include "file_util.h"
-#include "log.h"
 #include <errno.h>
+#include <wsutil/wslog.h>
 
 
 #ifdef HAVE_LIBGNUTLS
@@ -229,7 +230,7 @@ rsa_load_pkcs12(FILE *fp, const gchar *cert_passwd, char **err)
         return NULL;
     }
 
-    g_log(NULL, G_LOG_LEVEL_INFO, "rsa_privkey_to_sexp: PKCS#12 imported\n");
+    ws_debug("grsa_privkey_to_sexp: PKCS#12 imported");
 
     /* TODO: Use gnutls_pkcs12_simple_parse, since 3.1.0 (August 2012) */
     for (i=0; ; i++) {
@@ -263,7 +264,7 @@ rsa_load_pkcs12(FILE *fp, const gchar *cert_passwd, char **err)
                                        ret);
                 goto done;
             }
-            g_log(NULL, G_LOG_LEVEL_INFO, "Bag %d/%d: %s\n", i, j, BAGTYPE(bag_type));
+            ws_debug("Bag %d/%d: %s", i, j, BAGTYPE(bag_type));
             if (bag_type == GNUTLS_BAG_ENCRYPTED) {
                 ret = gnutls_pkcs12_bag_decrypt(bag, cert_passwd);
                 if (ret == 0) {
@@ -279,7 +280,7 @@ rsa_load_pkcs12(FILE *fp, const gchar *cert_passwd, char **err)
                                                ret);
                         goto done;
                     }
-                    g_log(NULL, G_LOG_LEVEL_INFO, "Bag %d/%d decrypted: %s\n", i, j, BAGTYPE(bag_type));
+                    ws_debug("Bag %d/%d decrypted: %s", i, j, BAGTYPE(bag_type));
                 }
             }
 
diff --git a/wsutil/win32-utils.c b/wsutil/win32-utils.c
index c8917c694e..5973682a7b 100644
--- a/wsutil/win32-utils.c
+++ b/wsutil/win32-utils.c
@@ -12,11 +12,11 @@
 
 #include "win32-utils.h"
 
-#include <log.h>
-
 #include <tchar.h>
 #include <VersionHelpers.h>
 
+#include <wsutil/wslog.h>
+
 /* Quote the argument element if necessary, so that it will get
  * reconstructed correctly in the C runtime startup code.  Note that
  * the unquoting algorithm in the C runtime is really weird, and
@@ -199,7 +199,7 @@ static void win32_kill_child_on_exit(HANDLE child_handle) {
         cjo_handle = CreateJobObject(NULL, NULL);
 
         if (!cjo_handle) {
-            g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "Could not create child cleanup job object: %s",
+            ws_log(LOG_DOMAIN_CAPTURE, LOG_LEVEL_DEBUG, "Could not create child cleanup job object: %s",
                 win32strerror(GetLastError()));
             return;
         }
@@ -209,14 +209,14 @@ static void win32_kill_child_on_exit(HANDLE child_handle) {
         BOOL sijo_ret = SetInformationJobObject(cjo_handle, JobObjectExtendedLimitInformation,
             &cjo_jel_info, sizeof(cjo_jel_info));
         if (!sijo_ret) {
-            g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "Could not set child cleanup limits: %s",
+            ws_log(LOG_DOMAIN_CAPTURE, LOG_LEVEL_DEBUG, "Could not set child cleanup limits: %s",
                 win32strerror(GetLastError()));
         }
     }
 
     BOOL aptjo_ret = AssignProcessToJobObject(cjo_handle, child_handle);
     if (!aptjo_ret) {
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "Could not assign child cleanup process: %s",
+        ws_log(LOG_DOMAIN_CAPTURE, LOG_LEVEL_DEBUG, "Could not assign child cleanup process: %s",
             win32strerror(GetLastError()));
     }
 }
diff --git a/wsutil/ws_pipe.c b/wsutil/ws_pipe.c
index 0a7d26f231..500859e2a4 100644
--- a/wsutil/ws_pipe.c
+++ b/wsutil/ws_pipe.c
@@ -10,6 +10,7 @@
  */
 
 #include <config.h>
+#define WS_LOG_DOMAIN LOG_DOMAIN_CAPTURE
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -28,7 +29,6 @@
 #endif
 
 #include <glib.h>
-#include <log.h>
 
 #ifdef __linux__
 #define HAS_G_SPAWN_LINUX_THREAD_SAFETY_BUG
@@ -39,6 +39,7 @@
 
 #include "wsutil/filesystem.h"
 #include "wsutil/ws_pipe.h"
+#include "wsutil/wslog.h"
 
 #ifdef HAS_G_SPAWN_LINUX_THREAD_SAFETY_BUG
 struct linux_dirent64 {
@@ -175,7 +176,7 @@ convert_to_argv(const char *command, int args_count, char *const *args)
         // arguments would silently be ignored because protect_arg returns an
         // empty string, therefore we print a warning here.
         if (!*args[i]) {
-            g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_WARNING, "Empty argument %d in arguments list", i);
+            ws_warning("Empty argument %d in arguments list", i);
         }
         argv[1 + i] = g_strdup(args[i]);
     }
@@ -252,7 +253,7 @@ gboolean ws_pipe_spawn_sync(const gchar *working_directory, const gchar *command
     gchar **argv = convert_to_argv(command, argc, args);
     gchar *command_line = convert_to_command_line(argv);
 
-    g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "spawn_sync: %s", command_line);
+    ws_debug("command line: %s", command_line);
 
     guint64 start_time = g_get_monotonic_time();
 
@@ -265,7 +266,7 @@ gboolean ws_pipe_spawn_sync(const gchar *working_directory, const gchar *command
     {
         g_free(command_line);
         g_strfreev(argv);
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "Could not create stdout overlapped event");
+        ws_debug("Could not create stdout overlapped event");
         return FALSE;
     }
     stderr_overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
@@ -274,7 +275,7 @@ gboolean ws_pipe_spawn_sync(const gchar *working_directory, const gchar *command
         CloseHandle(stdout_overlapped.hEvent);
         g_free(command_line);
         g_strfreev(argv);
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "Could not create stderr overlapped event");
+        ws_debug("Could not create stderr overlapped event");
         return FALSE;
     }
 
@@ -289,7 +290,7 @@ gboolean ws_pipe_spawn_sync(const gchar *working_directory, const gchar *command
         CloseHandle(stderr_overlapped.hEvent);
         g_free(command_line);
         g_strfreev(argv);
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "Could not create stdout handle");
+        ws_debug("Could not create stdout handle");
         return FALSE;
     }
 
@@ -301,7 +302,7 @@ gboolean ws_pipe_spawn_sync(const gchar *working_directory, const gchar *command
         CloseHandle(child_stdout_wr);
         g_free(command_line);
         g_strfreev(argv);
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "Could not create stderr handle");
+        ws_debug("Could not create stderr handle");
         return FALSE;
     }
 
@@ -330,7 +331,7 @@ gboolean ws_pipe_spawn_sync(const gchar *working_directory, const gchar *command
         {
             if (GetLastError() != ERROR_IO_PENDING)
             {
-                g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "ReadFile on child stdout pipe failed. Error %d", GetLastError());
+                ws_debug("ReadFile on child stdout pipe failed. Error %d", GetLastError());
                 pending_stdout = FALSE;
             }
         }
@@ -339,7 +340,7 @@ gboolean ws_pipe_spawn_sync(const gchar *working_directory, const gchar *command
         {
             if (GetLastError() != ERROR_IO_PENDING)
             {
-                g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "ReadFile on child stderr pipe failed. Error %d", GetLastError());
+                ws_debug("ReadFile on child stderr pipe failed. Error %d", GetLastError());
                 pending_stderr = FALSE;
             }
         }
@@ -390,7 +391,7 @@ gboolean ws_pipe_spawn_sync(const gchar *working_directory, const gchar *command
                             pending_stdout = FALSE;
                             continue;
                         }
-                        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "GetOverlappedResult on stdout failed. Error %d", GetLastError());
+                        ws_debug("GetOverlappedResult on stdout failed. Error %d", GetLastError());
                     }
                     if (process_finished && (bytes_read == 0))
                     {
@@ -403,7 +404,7 @@ gboolean ws_pipe_spawn_sync(const gchar *working_directory, const gchar *command
                     {
                         if (GetLastError() != ERROR_IO_PENDING)
                         {
-                            g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "ReadFile on child stdout pipe failed. Error %d", GetLastError());
+                            ws_debug("ReadFile on child stdout pipe failed. Error %d", GetLastError());
                             pending_stdout = FALSE;
                         }
                     }
@@ -419,7 +420,7 @@ gboolean ws_pipe_spawn_sync(const gchar *working_directory, const gchar *command
                             pending_stderr = FALSE;
                             continue;
                         }
-                        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "GetOverlappedResult on stderr failed. Error %d", GetLastError());
+                        ws_debug("GetOverlappedResult on stderr failed. Error %d", GetLastError());
                     }
                     if (process_finished && (bytes_read == 0))
                     {
@@ -430,7 +431,7 @@ gboolean ws_pipe_spawn_sync(const gchar *working_directory, const gchar *command
                     {
                         if (GetLastError() != ERROR_IO_PENDING)
                         {
-                            g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "ReadFile on child stderr pipe failed. Error %d", GetLastError());
+                            ws_debug("ReadFile on child stderr pipe failed. Error %d", GetLastError());
                             pending_stderr = FALSE;
                         }
                     }
@@ -438,7 +439,7 @@ gboolean ws_pipe_spawn_sync(const gchar *working_directory, const gchar *command
             }
             else
             {
-                g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "WaitForMultipleObjects returned 0x%08X. Error %d", dw, GetLastError());
+                ws_debug("WaitForMultipleObjects returned 0x%08X. Error %d", dw, GetLastError());
             }
         }
 
@@ -486,12 +487,12 @@ gboolean ws_pipe_spawn_sync(const gchar *working_directory, const gchar *command
         status = FALSE;
 #endif
 
-    g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "%s finished in %.3fms", argv[0], (g_get_monotonic_time() - start_time) / 1000.0);
+    ws_debug("%s finished in %.3fms", argv[0], (g_get_monotonic_time() - start_time) / 1000.0);
 
     if (status)
     {
         if (local_output != NULL) {
-            g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "spawn output: %s", local_output);
+            ws_debug("spawn output: %s", local_output);
             if (command_output != NULL)
                 *command_output = g_strdup(local_output);
         }
@@ -534,7 +535,7 @@ GPid ws_pipe_spawn_async(ws_pipe_t *ws_pipe, GPtrArray *args)
     gchar **argv = convert_to_argv(args_array[0], args->len - 2, args_array + 1);
     gchar *command_line = convert_to_command_line(argv);
 
-    g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "spawn_async: %s", command_line);
+    ws_debug("command line: %s", command_line);
 
 #ifdef _WIN32
     sa.nLength = sizeof(SECURITY_ATTRIBUTES);
@@ -545,7 +546,7 @@ GPid ws_pipe_spawn_async(ws_pipe_t *ws_pipe, GPtrArray *args)
     {
         g_free(command_line);
         g_strfreev(argv);
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "Could not create stdin handle");
+        ws_debug("Could not create stdin handle");
         return WS_INVALID_PID;
     }
 
@@ -555,7 +556,7 @@ GPid ws_pipe_spawn_async(ws_pipe_t *ws_pipe, GPtrArray *args)
         CloseHandle(child_stdin_wr);
         g_free(command_line);
         g_strfreev(argv);
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "Could not create stdout handle");
+        ws_debug("Could not create stdout handle");
         return WS_INVALID_PID;
     }
 
@@ -567,7 +568,7 @@ GPid ws_pipe_spawn_async(ws_pipe_t *ws_pipe, GPtrArray *args)
         CloseHandle(child_stdout_wr);
         g_free(command_line);
         g_strfreev(argv);
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "Could not create stderr handle");
+        ws_debug("Could not create stderr handle");
         return WS_INVALID_PID;
     }
 
@@ -602,7 +603,7 @@ GPid ws_pipe_spawn_async(ws_pipe_t *ws_pipe, GPtrArray *args)
                              flags, child_setup, NULL,
                              &pid, &ws_pipe->stdin_fd, &ws_pipe->stdout_fd, &ws_pipe->stderr_fd, &error);
     if (!spawned) {
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "Error creating async pipe: %s", error->message);
+        ws_debug("Error creating async pipe: %s", error->message);
         g_free(error->message);
     }
 #endif
@@ -646,7 +647,7 @@ ws_pipe_wait_for_pipe(HANDLE * pipe_handles, int num_pipe_handles, HANDLE pid)
 
     if (num_pipe_handles == 0 || num_pipe_handles > 3)
     {
-        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "Invalid number of pipes given as argument.");
+        ws_debug("Invalid number of pipes given as argument.");
         return FALSE;
     }
 
@@ -655,7 +656,7 @@ ws_pipe_wait_for_pipe(HANDLE * pipe_handles, int num_pipe_handles, HANDLE pid)
         pipeinsts[i].ol.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
         if (!pipeinsts[i].ol.hEvent)
         {
-            g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "Could not create overlapped event");
+            ws_debug("Could not create overlapped event");
             for (int j = 0; j < i; j++)
             {
                 CloseHandle(pipeinsts[j].ol.hEvent);
@@ -683,7 +684,7 @@ ws_pipe_wait_for_pipe(HANDLE * pipe_handles, int num_pipe_handles, HANDLE pid)
                 break;
 
             default:
-                g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "ConnectNamedPipe failed with %d\n.", error);
+                ws_debug("ConnectNamedPipe failed with %d\n.", error);
                 result = FALSE;
             }
         }
@@ -714,7 +715,7 @@ ws_pipe_wait_for_pipe(HANDLE * pipe_handles, int num_pipe_handles, HANDLE pid)
         int handle_idx = dw - WAIT_OBJECT_0;
         if (dw == WAIT_TIMEOUT)
         {
-            g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "extcap didn't connect to pipe within 30 seconds.");
+            ws_debug("extcap didn't connect to pipe within 30 seconds.");
             result = FALSE;
             break;
         }
@@ -723,7 +724,7 @@ ws_pipe_wait_for_pipe(HANDLE * pipe_handles, int num_pipe_handles, HANDLE pid)
         {
             if (handles[handle_idx] == pid)
             {
-                g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "extcap terminated without connecting to pipe.");
+                ws_debug("extcap terminated without connecting to pipe.");
                 result = FALSE;
             }
             for (int i = 0; i < num_pipe_handles; ++i)
@@ -738,7 +739,7 @@ ws_pipe_wait_for_pipe(HANDLE * pipe_handles, int num_pipe_handles, HANDLE pid)
                         TRUE);                     // wait
                     if (!success)
                     {
-                        g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "Error %d \n.", GetLastError());
+                        ws_debug("Error %d \n.", GetLastError());
                         result = FALSE;
                     }
                     pipeinsts[i].pendingIO = FALSE;
@@ -747,7 +748,7 @@ ws_pipe_wait_for_pipe(HANDLE * pipe_handles, int num_pipe_handles, HANDLE pid)
         }
         else
         {
-            g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "WaitForMultipleObjects returned 0x%08X. Error %d", dw, GetLastError());
+            ws_debug("WaitForMultipleObjects returned 0x%08X. Error %d", dw, GetLastError());
             result = FALSE;
         }
     }
@@ -836,7 +837,7 @@ ws_read_string_from_pipe(ws_pipe_handle read_pipe, gchar *buffer,
         if (buffer_bytes_remaining == 0)
         {
             /* The string won't fit in the buffer. */
-            g_log(LOG_DOMAIN_CAPTURE, G_LOG_LEVEL_DEBUG, "Buffer too small (%zd).", buffer_size);
+            ws_debug("Buffer too small (%zd).", buffer_size);
             break;
         }
 
diff --git a/wsutil/wsjson.c b/wsutil/wsjson.c
index 567fa2dd5c..474c9246b6 100644
--- a/wsutil/wsjson.c
+++ b/wsutil/wsjson.c
@@ -11,6 +11,7 @@
  */
 
 #include "config.h"
+#define WS_LOG_DOMAIN LOG_DOMAIN_MAIN
 
 #include "wsjson.h"
 
@@ -19,7 +20,7 @@
 #include <wsutil/jsmn.h>
 #include <wsutil/str_util.h>
 #include <wsutil/unicode-utils.h>
-#include "log.h"
+#include <wsutil/wslog.h>
 
 gboolean
 json_validate(const guint8 *buf, const size_t len)
@@ -39,11 +40,11 @@ json_validate(const guint8 *buf, const size_t len)
      * XXX - should we check for NULs anywhere in the buffer?
      */
     if (len == 0) {
-        g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "jsmn: JSON string is empty");
+        ws_debug("JSON string is empty");
         return FALSE;
     }
     if (buf[0] == '\0') {
-        g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "jsmn: invalid character inside JSON string");
+        ws_debug("invalid character inside JSON string");
         return FALSE;
     }
 
@@ -57,17 +58,17 @@ json_validate(const guint8 *buf, const size_t len)
     if (rcode < 0) {
         switch (rcode) {
             case JSMN_ERROR_NOMEM:
-                g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "jsmn: not enough tokens were provided");
+                ws_debug("not enough tokens were provided");
                 break;
             case JSMN_ERROR_INVAL:
-                g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "jsmn: invalid character inside JSON string");
+                ws_debug("invalid character inside JSON string");
                 break;
             case JSMN_ERROR_PART:
-                g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "jsmn: the string is not a full JSON packet, "
+                ws_debug("the string is not a full JSON packet, "
                     "more bytes expected");
                 break;
             default:
-                g_log(LOG_DOMAIN_MAIN, G_LOG_LEVEL_DEBUG, "jsmn: unexpected error");
+                ws_debug("unexpected error");
                 break;
         }
         ret = FALSE;
diff --git a/wsutil/wslog.c b/wsutil/wslog.c
index 1d282ca621..ee93565437 100644
--- a/wsutil/wslog.c
+++ b/wsutil/wslog.c
@@ -9,21 +9,378 @@
 #include "config.h"
 #include "wslog.h"
 
-#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
 #include <stdarg.h>
+#include <ws_attributes.h>
+
+#include <wsutil/ws_assert.h>
+#include <wsutil/time_util.h>
 
 #define LOGBUFSIZE  256
 
-void ws_log_full(const char *log_domain, GLogLevelFlags log_level,
+#define LOGENVVAR "WS_LOG_LEVEL"
+
+
+/* TODO: Add filtering by domain. */
+
+static enum ws_log_level current_log_level = LOG_LEVEL_MESSAGE;
+
+static ws_log_writer_t *current_log_writer = ws_log_default_writer;
+
+static void *current_log_writer_data = NULL;
+
+static ws_log_writer_free_data_t *current_log_writer_data_free = NULL;
+
+static FILE *custom_log = NULL;
+
+
+static void ws_log_cleanup(void);
+
+
+static void
+log_default_writer_do_work(FILE *fp, const char *message)
+{
+    ws_assert(message);
+    fputs(message, fp);
+    fputc('\n', fp);
+    fflush(fp);
+}
+
+
+void
+ws_log_default_writer(const char *message,
+                       enum ws_log_domain domain _U_,
+                       enum ws_log_level level _U_,
+                       void *user_data _U_)
+{
+    log_default_writer_do_work(stderr, message);
+}
+
+
+const char *ws_log_level_to_string(enum ws_log_level level)
+{
+    switch (level) {
+        case LOG_LEVEL_NONE:
+            return "(none)";
+        case LOG_LEVEL_ERROR:
+            return "ERROR";
+        case LOG_LEVEL_CRITICAL:
+            return "CRITICAL";
+        case LOG_LEVEL_WARNING:
+            return "WARNING";
+        case LOG_LEVEL_MESSAGE:
+            return "MESSAGE";
+        case LOG_LEVEL_INFO:
+            return "INFO";
+        case LOG_LEVEL_DEBUG:
+            return "DEBUG";
+        default:
+            return "(BOGUS LOG LEVEL)";
+    }
+}
+
+
+const char *ws_log_domain_to_string(enum ws_log_domain domain)
+{
+    switch (domain) {
+        case LOG_DOMAIN_DEFAULT:
+            return "Default";
+        case LOG_DOMAIN_MAIN:
+            return "Main";
+        case LOG_DOMAIN_CAPTURE:
+            return "Capture";
+        case LOG_DOMAIN_CAPCHILD:
+            return "CapChild";
+        case LOG_DOMAIN_WIRETAP:
+            return "Wiretap";
+        case LOG_DOMAIN_EPAN:
+            return "Epan";
+        case LOG_DOMAIN_WSUTIL:
+            return "Util";
+        case LOG_DOMAIN_QTUI:
+            return "GUI";
+        default:
+            return "(BOGUS LOG DOMAIN)";
+    }
+}
+
+
+gboolean ws_log_level_is_active(enum ws_log_level level)
+{
+    return level <= current_log_level;
+}
+
+
+enum ws_log_level ws_log_get_level(void)
+{
+    return current_log_level;
+}
+
+
+enum ws_log_level ws_log_set_level(enum ws_log_level log_level)
+{
+    ws_assert(log_level > LOG_LEVEL_NONE && log_level < _LOG_LEVEL_LAST);
+
+    current_log_level = log_level;
+    return current_log_level;
+}
+
+
+enum ws_log_level ws_log_set_level_str(const char *str_level)
+{
+    enum ws_log_level level;
+
+    if (!str_level)
+        return LOG_LEVEL_NONE;
+
+    if (g_ascii_strcasecmp(str_level, "debug") == 0)
+        level = LOG_LEVEL_DEBUG;
+    else if (g_ascii_strcasecmp(str_level, "info") == 0)
+        level = LOG_LEVEL_INFO;
+    else if (g_ascii_strcasecmp(str_level, "message") == 0)
+        level = LOG_LEVEL_MESSAGE;
+    else if (g_ascii_strcasecmp(str_level, "warning") == 0)
+        level = LOG_LEVEL_WARNING;
+    else if (g_ascii_strcasecmp(str_level, "critical") == 0)
+        level = LOG_LEVEL_CRITICAL;
+    else if (g_ascii_strcasecmp(str_level, "error") == 0)
+        level = LOG_LEVEL_ERROR;
+    else
+        return LOG_LEVEL_NONE;
+
+    current_log_level = level;
+    return current_log_level;
+}
+
+
+static const char *set_level_and_prune_argv(int count, char **ptr, int prune_extra,
+                                const char *optarg, int *ret_argc)
+{
+    if (optarg && ws_log_set_level_str(optarg) != LOG_LEVEL_NONE)
+        optarg = NULL; /* success */
+
+    /*
+     * We found a "--log-level" option. We will remove it from
+     * the argv by moving up the other strings in the array. This is
+     * so that it doesn't generate an unrecognized option
+     * error further along in the initialization process.
+     */
+
+    /* Include the terminating NULL in the memmove. */
+    memmove(ptr, ptr + 1 + prune_extra, (count - prune_extra) * sizeof(*ptr));
+    *ret_argc -= (1 + prune_extra);
+    return optarg;
+}
+
+const char *ws_log_set_level_args(int *argc_ptr, char *argv[])
+{
+    char **p;
+    int c;
+    const char *opt = "--log-level";
+    size_t len = strlen(opt);
+    const char *optarg;
+
+    for (p = argv, c = *argc_ptr; *p != NULL; p++, c--) {
+        if (strncmp(*p, opt, len) == 0) {
+            optarg = *p + len;
+            /* Two possibilities:
+             *      --log_level <level>
+             * or
+             *      --log-level=<level>
+             */
+            if (optarg[0] == '\0') {
+                /* value is separated with blank space */
+                optarg = *(p + 1);
+
+                /* If the option value after the blank is missing or stars with '-' just ignore it.
+                 * But we should probably signal an error (missing required value). */
+                if (optarg == NULL || !*optarg || *optarg == '-') {
+                    return set_level_and_prune_argv(c, p, 0, NULL, argc_ptr);
+                }
+                return set_level_and_prune_argv(c, p, 1, optarg, argc_ptr);
+            }
+            else if (optarg[0] == '=') {
+                /* value is after equals */
+                optarg += 1;
+                return set_level_and_prune_argv(c, p, 0, optarg, argc_ptr);
+            }
+            /* we didn't find what we want */
+        }
+    }
+    return NULL; /* No log-level option, ignore and return success. */
+}
+
+
+void ws_log_init(ws_log_writer_t *_writer)
+{
+    if (_writer) {
+        current_log_writer = _writer;
+    }
+
+    const char *env = g_getenv(LOGENVVAR);
+    if (env && ws_log_set_level_str(env) == LOG_LEVEL_NONE) {
+        fprintf(stderr, "Ignoring invalid environment value %s=\"%s\"\n", LOGENVVAR, env);
+    }
+
+    atexit(ws_log_cleanup);
+}
+
+
+void ws_log_init_with_data(ws_log_writer_t *writer, void *user_data,
+                              ws_log_writer_free_data_t *free_user_data)
+{
+    current_log_writer_data = user_data;
+    current_log_writer_data_free = free_user_data;
+    ws_log_init(writer);
+}
+
+
+static inline const char *_level_to_string(enum ws_log_level level)
+{
+    switch (level) {
+        case LOG_LEVEL_NONE:       return "NUL";
+        case LOG_LEVEL_ERROR:      return "ERR";
+        case LOG_LEVEL_CRITICAL:   return "CRI";
+        case LOG_LEVEL_WARNING:    return "WRN";
+        case LOG_LEVEL_MESSAGE:    return "MSG";
+        case LOG_LEVEL_INFO:       return "NFO";
+        case LOG_LEVEL_DEBUG:      return "DBG";
+        default:
+            return "(BOGUS LOG LEVEL)";
+    }
+}
+
+
+static inline const char *_domain_to_string(enum ws_log_domain domain)
+{
+    switch (domain) {
+        case LOG_DOMAIN_DEFAULT:   return "Dflt";
+        case LOG_DOMAIN_MAIN:      return "Main";
+        case LOG_DOMAIN_CAPTURE:   return "Capt";
+        case LOG_DOMAIN_CAPCHILD:  return "CChd";
+        case LOG_DOMAIN_WIRETAP:   return "Wtap";
+        case LOG_DOMAIN_EPAN:      return "Epan";
+        case LOG_DOMAIN_WSUTIL:    return "Util";
+        case LOG_DOMAIN_QTUI:      return "Qtui";
+        default:
+            return "(BOGUS LOG DOMAIN)";
+    }
+}
+
+
+static void ws_log_writev(enum ws_log_domain domain, enum ws_log_level level,
+                            const char *location, const char *format, va_list ap)
+{
+    char timestamp[sizeof("00:00:00.000")];
+    char user_string[LOGBUFSIZE];
+    char message[LOGBUFSIZE*2];
+    time_t curr;
+    struct tm *today;
+
+    /* create a "timestamp" */
+    time(&curr);
+    today = localtime(&curr);
+    guint64 microseconds = create_timestamp();
+    if (today != NULL) {
+        snprintf(timestamp, sizeof(timestamp), "%02d:%02d:%02d.%03" G_GUINT64_FORMAT,
+                    today->tm_hour, today->tm_min, today->tm_sec,
+                    microseconds % 1000000 / 1000);
+    }
+    else {
+        snprintf(timestamp, sizeof(timestamp), "(notime)");
+    }
+
+    vsnprintf(user_string, sizeof(user_string), format, ap);
+
+    snprintf(message, sizeof(message), "%s %s-%s %s : %s",
+                timestamp,
+                _domain_to_string(domain),
+                _level_to_string(level),
+                location ? location : "(nofile)",
+                user_string);
+
+    /* Call the registered writer, or the default if one wasn't registered. */
+    current_log_writer(message, domain, level, current_log_writer_data);
+
+    /* If we have a custom file, write to it _also_. */
+    if (custom_log) {
+        log_default_writer_do_work(custom_log, message);
+    }
+
+    if (level == LOG_LEVEL_ERROR) {
+        G_BREAKPOINT();
+        ws_assert_not_reached();
+    }
+}
+
+
+void ws_logv(enum ws_log_domain domain, enum ws_log_level level,
+                    const char *format, va_list ap)
+{
+    if (!ws_log_level_is_active(level))
+        return;
+
+    ws_log_writev(domain, level, NULL, format, ap);
+}
+
+
+void ws_log(enum ws_log_domain domain, enum ws_log_level level,
+                    const char *format, ...)
+{
+    va_list ap;
+
+    if (!ws_log_level_is_active(level))
+        return;
+
+    va_start(ap, format);
+    ws_log_writev(domain, level, NULL, format, ap);
+    va_end(ap);
+}
+
+
+void ws_log_full(enum ws_log_domain domain, enum ws_log_level level,
                     const char *file, int line, const char *func,
                     const char *format, ...)
 {
     va_list ap;
-    char log_msg[LOGBUFSIZE];
+    char location[LOGBUFSIZE];
+
+    if (!ws_log_level_is_active(level))
+        return;
+
+    if (func)
+        snprintf(location, sizeof(location), "%s(%d) %s()", file, line, func);
+    else
+        snprintf(location, sizeof(location), "%s(%d)", file, line);
 
     va_start(ap, format);
-    vsnprintf(log_msg, sizeof(log_msg), format, ap);
+    ws_log_writev(domain, level, location, format, ap);
     va_end(ap);
-
-    g_log(log_domain, log_level, "%s(%d):%s: %s", file, line, func, log_msg);
+}
+
+
+static void ws_log_cleanup(void)
+{
+    if (current_log_writer_data_free) {
+        current_log_writer_data_free(current_log_writer_data);
+        current_log_writer_data = NULL;
+    }
+    if (custom_log) {
+        fclose(custom_log);
+        custom_log = NULL;
+    }
+}
+
+
+void ws_log_add_custom_file(FILE *fp)
+{
+        if (custom_log != NULL) {
+            fclose(custom_log);
+            custom_log = NULL;
+        }
+        if (fp != NULL) {
+            custom_log = fp;
+        }
 }
diff --git a/wsutil/wslog.h b/wsutil/wslog.h
index 3629c89bbd..9f9bcc7f7f 100644
--- a/wsutil/wslog.h
+++ b/wsutil/wslog.h
@@ -11,36 +11,211 @@
 
 #include <ws_symbol_export.h>
 #include <glib.h>
+#include <stdio.h>
+#include <stdarg.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
 
 /*
- * XXX This API should be consolidated with ui/console.h. The way this works
- * (or doesn't) with prefs->console_log_level is also weird, because not all
- * log domains are using the same log handler. The function ws_log_full()
- * currently ignores the console log level preference.
+ * Descending order by priority needs to be maintained. Higher priorities have
+ * lower values.
  */
+enum ws_log_level {
+     LOG_LEVEL_NONE,       /* not user facing */
+     LOG_LEVEL_ERROR,      /* "error" is always fatal (aborts) */
+     LOG_LEVEL_CRITICAL,
+     LOG_LEVEL_WARNING,
+     LOG_LEVEL_MESSAGE,
+     LOG_LEVEL_INFO,
+     LOG_LEVEL_DEBUG,
+     _LOG_LEVEL_LAST
+};
+
+#include <ws_log_domains.h>
+
+#ifndef WS_LOG_DOMAIN
+#define WS_LOG_DOMAIN LOG_DOMAIN_DEFAULT
+#endif
+
+
+/** Signature for registering a log writer. */
+typedef void (ws_log_writer_t)(const char *message,
+                                   enum ws_log_domain domain,
+                                   enum ws_log_level level,
+                                   void *user_data);
+
+
+typedef void (ws_log_writer_free_data_t)(void *user_data);
+
 
 WS_DLL_PUBLIC
-void ws_log_full(const char *log_domain, GLogLevelFlags log_level,
+void ws_log_default_writer(const char *message,
+                                   enum ws_log_domain domain,
+                                   enum ws_log_level level,
+                                   void *user_data);
+
+
+/** Convert a numerical level to its string representation. */
+WS_DLL_PUBLIC
+const char *ws_log_level_to_string(enum ws_log_level level);
+
+
+/** Convert a numerical domain to its string representation. */
+WS_DLL_PUBLIC
+const char *ws_log_domain_to_string(enum ws_log_domain domain);
+
+
+/** Checks if the active log level would discard a message for the given
+ * log domain.
+ *
+ * Returns TRUE if a message will be discarded for the domain/log_level combo.
+ */
+WS_DLL_PUBLIC
+gboolean ws_log_level_is_active(enum ws_log_level level);
+
+
+/** Return the currently active log level. */
+WS_DLL_PUBLIC
+enum ws_log_level ws_log_get_level(void);
+
+
+/** Set the actice log level. Returns the same value (the active level). */
+WS_DLL_PUBLIC
+enum ws_log_level ws_log_set_level(enum ws_log_level log_level);
+
+
+/** Set the actice log level from a string.
+ *
+ * String levels are "error", "critical", "warning", "message", "info" and
+ * "debug" (case insensitive).
+ * Returns the new log level or WS_LOG_LEVEL NONE if the string representation
+ * is invalid.
+ */
+WS_DLL_PUBLIC
+enum ws_log_level ws_log_set_level_str(const char *str_level);
+
+
+/** Set the active log level from an argv vector.
+ *
+ * Will search the arv for the option parameter "--log-level=<string>".
+ * If it finds the parameter and the string is valid sets the log level and
+ * returns NULL (success). Othwerise returns the invalid option argument after '='.
+ */
+WS_DLL_PUBLIC
+const char *ws_log_set_level_args(int *argcp, char **argv);
+
+
+/** Initializes the logging code.
+ *
+ * Must be called at startup before using the log API. If provided the
+ * ws_log_writer_t pointer will be used to write every message. If the writer
+ * is NULL the default log writer is used.
+ */
+WS_DLL_PUBLIC
+void ws_log_init(ws_log_writer_t *writer);
+
+
+/** Initializes the logging code.
+ *
+ * Can be used instead of wslog_init(). Takes an extra user data pointer. This
+ * pointer is passed to the writer with each invocation. If a free function
+ * is passed it will be called with user_data when the program terminates.
+ */
+WS_DLL_PUBLIC
+void ws_log_init_with_data(ws_log_writer_t *writer, void *user_data,
+                              ws_log_writer_free_data_t *free_user_data);
+
+
+/** This function is called to output a message to the log.
+ *
+ * Takes a format string and a variable number of arguments.
+ */
+WS_DLL_PUBLIC
+void ws_log(enum ws_log_domain domain, enum ws_log_level level,
+                    const char *format, ...) G_GNUC_PRINTF(3,4);
+
+/** This function is called to output a message to the log.
+ *
+ * Takes a format string and a 'va_list'.
+ */
+WS_DLL_PUBLIC
+void ws_logv(enum ws_log_domain domain, enum ws_log_level level,
+                    const char *format, va_list ap);
+
+
+/** This function is called to output a message to the log.
+ *
+ * In addition to the message this function accepts file/line/function
+ * information. 'func' may be NULL.
+ */
+WS_DLL_PUBLIC
+void ws_log_full(enum ws_log_domain domain, enum ws_log_level level,
                     const char *file, int line, const char *func,
                     const char *format, ...) G_GNUC_PRINTF(6,7);
 
-/*
- * To output debug information use the environment variable
- *   G_MESSAGES_DEBUG="<domain1> <domain2> ..." (separated with spaces)
- * to produce output for specic domains, or G_MESSAGES_DEBUG="all" for
- * all domains.
+
+#define _LOG_FULL(level, ...) ws_log_full(WS_LOG_DOMAIN, level,  \
+                                   __FILE__, __LINE__, G_STRFUNC, __VA_ARGS__)
+
+/** Logs with "error" level.
+ *
+ * Accepts a format string and includes the file and function name.
+ *
+ * "error" is always fatal and terminates the program with a coredump.
+ */
+#define ws_error(...)    _LOG_FULL(LOG_LEVEL_ERROR, __VA_ARGS__)
+
+/** Logs with "critical" level.
+ *
+ * Accepts a format string and includes the file and function name.
+ */
+#define ws_critical(...) _LOG_FULL(LOG_LEVEL_CRITICAL, __VA_ARGS__)
+
+/** Logs with "warning" level.
+ *
+ * Accepts a format string and includes the file and function name.
+ */
+#define ws_warning(...)  _LOG_FULL(LOG_LEVEL_WARNING, __VA_ARGS__)
+
+/** Logs with "message" level.
+ *
+ * Accepts a format string and includes the file and function name.
+ */
+#define ws_message(...)  _LOG_FULL(LOG_LEVEL_MESSAGE, __VA_ARGS__)
+
+/** Logs with "info" level.
+ *
+ * Accepts a format string and includes the file and function name.
+ */
+#define ws_info(...)     _LOG_FULL(LOG_LEVEL_INFO, __VA_ARGS__)
+
+/** Logs with "debug" level.
+ *
+ * Accepts a format string and includes the file and function name.
  */
 #ifndef WS_DISABLE_DEBUG
-#define ws_debug(...)   ws_log_full(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,        \
-                                            __FILE__, __LINE__, G_STRFUNC,  \
-                                            __VA_ARGS__)
+#define ws_debug(...)    _LOG_FULL(LOG_LEVEL_DEBUG, __VA_ARGS__)
 #else
 /* This avoids -Wunused warnings for variables referenced by ws_debug()
  * only. The compiler will optimize it away. */
-#define ws_debug(...)    \
-     G_STMT_START { if (0) ws_log_full(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,    \
-               __FILE__, __LINE__, G_STRFUNC, __VA_ARGS__); } G_STMT_END
+#define ws_debug(...) \
+          G_STMT_START { \
+               if (0) _LOG_FULL(LOG_LEVEL_DEBUG, __VA_ARGS__); \
+          } G_STMT_END
 #endif
 
+
+/** Define an auxilliary file pointer where messages should be written.
+ *
+ * This file, if set, functions in addition to the registered log writer.
+ */
+WS_DLL_PUBLIC
+void ws_log_add_custom_file(FILE *fp);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
 #endif /* __WSLOG_H__ */