utils: introduce new logging API and remove msg API

19 files changed, 106 insertions, 107 deletions

diff --git a/host/lib/rfnoc/block_ctrl_base.cpp b/host/lib/rfnoc/block_ctrl_base.cpp
index 2a486ac31..efd723fcb 100644
--- a/host/lib/rfnoc/block_ctrl_base.cpp
+++ b/host/lib/rfnoc/block_ctrl_base.cpp
@@ -20,7 +20,7 @@
 
 #include "ctrl_iface.hpp"
 #include "nocscript/block_iface.hpp"
-#include <uhd/utils/msg.hpp>
+
 #include <uhd/utils/log.hpp>
 #include <uhd/convert.hpp>
 #include <uhd/rfnoc/block_ctrl_base.hpp>
@@ -28,7 +28,7 @@
 #include <boost/format.hpp>
 #include <boost/bind.hpp>
 
-#define UHD_BLOCK_LOG() UHD_LOGV(never)
+#define UHD_BLOCK_LOG() UHD_LOGGER_TRACE("RFNOC")
 
 using namespace uhd;
 using namespace uhd::rfnoc;
@@ -50,13 +50,13 @@ block_ctrl_base::block_ctrl_base(
     _ctrl_ifaces(make_args.ctrl_ifaces),
     _base_address(make_args.base_address & 0xFFF0)
 {
-    UHD_BLOCK_LOG() << "block_ctrl_base()" << std::endl;
+    UHD_BLOCK_LOG() << "block_ctrl_base()" ;
 
     /*** Identify this block (NoC-ID, block-ID, and block definition) *******/
     // Read NoC-ID (name is passed in through make_args):
     uint64_t noc_id = sr_read64(SR_READBACK_REG_ID);
     _block_def = blockdef::make_from_noc_id(noc_id);
-    if (_block_def) UHD_BLOCK_LOG() <<  "Found valid blockdef" << std::endl;
+    if (_block_def) UHD_BLOCK_LOG() <<  "Found valid blockdef" ;
     if (not _block_def)
         _block_def = blockdef::make_from_noc_id(DEFAULT_NOC_ID);
     UHD_ASSERT_THROW(_block_def);
@@ -68,7 +68,7 @@ block_ctrl_base::block_ctrl_base(
     }
     UHD_BLOCK_LOG()
         << "NOC ID: " << str(boost::format("0x%016X  ") % noc_id)
-        << "Block ID: " << _block_id << std::endl;
+        << "Block ID: " << _block_id ;
 
     /*** Initialize property tree *******************************************/
     _root_path = "xbar/" + _block_id.get_local();
@@ -114,10 +114,10 @@ block_ctrl_base::block_ctrl_base(
     _init_port_defs("out", _block_def->get_output_ports());
     // FIXME this warning always fails until the input buffer code above is fixed
     if (_tree->list(_root_path / "ports/in").size() != n_valid_input_buffers) {
-        UHD_MSG(warning) <<
+        UHD_LOGGER_WARNING("RFNOC") <<
             boost::format("[%s] defines %d input buffer sizes, but %d input ports")
             % get_block_id().get() % n_valid_input_buffers % _tree->list(_root_path / "ports/in").size()
-            << std::endl;
+            ;
     }
 
     /*** Init default block args ********************************************/
@@ -143,7 +143,7 @@ void block_ctrl_base::_init_port_defs(
         }
         UHD_RFNOC_BLOCK_TRACE()  << "Adding port definition at " << port_path
             << boost::format(": type = '%s' pkt_size = '%s' vlen = '%s'") % port_def["type"] % port_def["pkt_size"] % port_def["vlen"]
-            << std::endl;
+            ;
         _tree->access<blockdef::port_t>(port_path).set(port_def);
         port_index++;
     }
@@ -225,7 +225,7 @@ std::vector<size_t> block_ctrl_base::get_ctrl_ports() const
 void block_ctrl_base::sr_write(const uint32_t reg, const uint32_t data, const size_t port)
 {
     //UHD_BLOCK_LOG() << "  ";
-    //UHD_RFNOC_BLOCK_TRACE() << boost::format("sr_write(%d, %08X, %d)") % reg % data % port << std::endl;
+    //UHD_RFNOC_BLOCK_TRACE() << boost::format("sr_write(%d, %08X, %d)") % reg % data % port ;
     if (not _ctrl_ifaces.count(port)) {
         throw uhd::key_error(str(boost::format("[%s] sr_write(): No such port: %d") % get_block_id().get() % port));
     }
@@ -252,7 +252,7 @@ void block_ctrl_base::sr_write(const std::string &reg, const uint32_t data, cons
         reg_addr = uint32_t(_tree->access<size_t>(_root_path / "registers" / "sr" / reg).get());
     }
     UHD_BLOCK_LOG() << "  ";
-    UHD_RFNOC_BLOCK_TRACE() << boost::format("sr_write(%s, %08X) ==> ") % reg % data << std::endl;
+    UHD_RFNOC_BLOCK_TRACE() << boost::format("sr_write(%s, %08X) ==> ") % reg % data ;
     return sr_write(reg_addr, data, port);
 }
 
@@ -409,7 +409,7 @@ void block_ctrl_base::clear_command_time(const size_t port)
 
 void block_ctrl_base::clear()
 {
-    UHD_RFNOC_BLOCK_TRACE() << "block_ctrl_base::clear() " << std::endl;
+    UHD_RFNOC_BLOCK_TRACE() << "block_ctrl_base::clear() " ;
     // Call parent...
     node_ctrl_base::clear();
     // ...then child
@@ -532,7 +532,7 @@ stream_sig_t block_ctrl_base::_resolve_port_def(const blockdef::port_t &port_def
     } else {
         stream_sig.item_type = port_def["type"];
     }
-    //UHD_RFNOC_BLOCK_TRACE() << "  item type: " << stream_sig.item_type << std::endl;
+    //UHD_RFNOC_BLOCK_TRACE() << "  item type: " << stream_sig.item_type ;
 
     // Vector length
     if (port_def.is_variable("vlen")) {
@@ -543,7 +543,7 @@ stream_sig_t block_ctrl_base::_resolve_port_def(const blockdef::port_t &port_def
     } else {
         stream_sig.vlen = boost::lexical_cast<size_t>(port_def["vlen"]);
     }
-    //UHD_RFNOC_BLOCK_TRACE() << "  vector length: " << stream_sig.vlen << std::endl;
+    //UHD_RFNOC_BLOCK_TRACE() << "  vector length: " << stream_sig.vlen ;
 
     // Packet size
     if (port_def.is_variable("pkt_size")) {
@@ -565,7 +565,7 @@ stream_sig_t block_ctrl_base::_resolve_port_def(const blockdef::port_t &port_def
     } else {
         stream_sig.packet_size = boost::lexical_cast<size_t>(port_def["pkt_size"]);
     }
-    //UHD_RFNOC_BLOCK_TRACE() << "  packet size: " << stream_sig.vlen << std::endl;
+    //UHD_RFNOC_BLOCK_TRACE() << "  packet size: " << stream_sig.vlen ;
 
     return stream_sig;
 }
@@ -576,7 +576,7 @@ stream_sig_t block_ctrl_base::_resolve_port_def(const blockdef::port_t &port_def
  **********************************************************************/
 void block_ctrl_base::_clear(const size_t port)
 {
-    UHD_RFNOC_BLOCK_TRACE() << "block_ctrl_base::_clear() " << std::endl;
+    UHD_RFNOC_BLOCK_TRACE() << "block_ctrl_base::_clear() " ;
     sr_write(SR_CLEAR_TX_FC, 0x00C1EA12, port); // 'CLEAR', but we can write anything, really
     sr_write(SR_CLEAR_RX_FC, 0x00C1EA12, port); // 'CLEAR', but we can write anything, really
 }
diff --git a/host/lib/rfnoc/block_ctrl_base_factory.cpp b/host/lib/rfnoc/block_ctrl_base_factory.cpp
index 0e2d5ae03..9e32b81d7 100644
--- a/host/lib/rfnoc/block_ctrl_base_factory.cpp
+++ b/host/lib/rfnoc/block_ctrl_base_factory.cpp
@@ -16,12 +16,12 @@
 //
 
 #include <boost/format.hpp>
-#include <uhd/utils/msg.hpp>
+
 #include <uhd/utils/log.hpp>
 #include <uhd/rfnoc/blockdef.hpp>
 #include <uhd/rfnoc/block_ctrl_base.hpp>
 
-#define UHD_FACTORY_LOG() UHD_LOGV(never)
+#define UHD_FACTORY_LOG() UHD_LOGGER_TRACE("RFNOC")
 
 using namespace uhd;
 using namespace uhd::rfnoc;
@@ -59,7 +59,7 @@ static void lookup_block_key(uint64_t noc_id, make_args_t &make_args)
         make_args.block_name = bd->get_name();
         return;
     } catch (std::exception &e) {
-        UHD_MSG(warning) << str(boost::format("Error while looking up name for NoC-ID %016X.\n%s") % noc_id % e.what()) << std::endl;
+        UHD_LOGGER_WARNING("RFNOC") << str(boost::format("Error while looking up name for NoC-ID %016X.\n%s") % noc_id % e.what()) ;
     }
 
     make_args.block_key  = DEFAULT_BLOCK_NAME;
@@ -71,7 +71,7 @@ block_ctrl_base::sptr block_ctrl_base::make(
         const make_args_t &make_args_,
         uint64_t noc_id
 ) {
-    UHD_FACTORY_LOG() << "[RFNoC Factory] block_ctrl_base::make() " << std::endl;
+    UHD_FACTORY_LOG() << "[RFNoC Factory] block_ctrl_base::make() " ;
     make_args_t make_args = make_args_;
 
     // Check if a block key was specified, in this case, we *must* either
@@ -90,7 +90,7 @@ block_ctrl_base::sptr block_ctrl_base::make(
         make_args.block_name = make_args.block_key;
     }
 
-    UHD_FACTORY_LOG() << "[RFNoC Factory] Using controller key '" << make_args.block_key << "' and block name '" << make_args.block_name << "'" << std::endl;
+    UHD_FACTORY_LOG() << "[RFNoC Factory] Using controller key '" << make_args.block_key << "' and block name '" << make_args.block_name << "'" ;
     return get_block_fcn_regs()[make_args.block_key](make_args);
 }
 
diff --git a/host/lib/rfnoc/blockdef_xml_impl.cpp b/host/lib/rfnoc/blockdef_xml_impl.cpp
index 9c56d82a6..5f8af232d 100644
--- a/host/lib/rfnoc/blockdef_xml_impl.cpp
+++ b/host/lib/rfnoc/blockdef_xml_impl.cpp
@@ -18,7 +18,7 @@
 #include <uhd/exception.hpp>
 #include <uhd/rfnoc/constants.hpp>
 #include <uhd/rfnoc/blockdef.hpp>
-#include <uhd/utils/msg.hpp>
+#include <uhd/utils/log.hpp>
 #include <uhd/utils/paths.hpp>
 #include <boost/assign/list_of.hpp>
 #include <boost/format.hpp>
@@ -223,7 +223,7 @@ public:
                 }
             }
         } catch (std::exception &e) {
-            UHD_MSG(warning) << "has_noc_id(): caught exception " << e.what() << std::endl;
+            UHD_LOGGER_WARNING("RFNOC") << "has_noc_id(): caught exception " << e.what() ;
             return false;
         }
         return false;
@@ -233,7 +233,7 @@ public:
         _type(type),
         _noc_id(noc_id)
     {
-        //UHD_MSG(status) << "Reading XML file: " << filename.string().c_str() << std::endl;
+        //UHD_LOGGER_INFO("RFNOC") << "Reading XML file: " << filename.string().c_str() ;
         read_xml(filename.string(), _pt);
         try {
             // Check key is valid
@@ -362,7 +362,7 @@ public:
                 arg["type"] = "string";
             }
             if (not arg.is_valid()) {
-                UHD_MSG(warning) << boost::format("Found invalid argument: %s") % arg.to_string() << std::endl;
+                UHD_LOGGER_WARNING("RFNOC") << boost::format("Found invalid argument: %s") % arg.to_string() ;
                 is_valid = false;
             }
             args.push_back(arg);
diff --git a/host/lib/rfnoc/ctrl_iface.cpp b/host/lib/rfnoc/ctrl_iface.cpp
index 8e4474af7..3a16f7ec1 100644
--- a/host/lib/rfnoc/ctrl_iface.cpp
+++ b/host/lib/rfnoc/ctrl_iface.cpp
@@ -17,7 +17,7 @@
 
 #include "ctrl_iface.hpp"
 #include <uhd/exception.hpp>
-#include <uhd/utils/msg.hpp>
+
 #include <uhd/utils/byteswap.hpp>
 #include <uhd/utils/safe_call.hpp>
 #include <uhd/transport/bounded_buffer.hpp>
@@ -168,7 +168,7 @@ private:
         //load payload
         pkt[packet_info.num_header_words32+0] = (_bige)? uhd::htonx(addr) : uhd::htowx(addr);
         pkt[packet_info.num_header_words32+1] = (_bige)? uhd::htonx(data) : uhd::htowx(data);
-        //UHD_MSG(status) << boost::format("0x%08x, 0x%08x\n") % addr % data;
+        //UHD_LOGGER_INFO("RFNOC") << boost::format("0x%08x, 0x%08x\n") % addr % data;
         //send the buffer over the interface
         _outstanding_seqs.push(_seq_out);
         buff->commit(sizeof(uint32_t)*(packet_info.num_packet_words32));
@@ -212,15 +212,15 @@ private:
             }
             catch(const std::exception &ex)
             {
-                UHD_MSG(error) << "[" << _name << "] Block ctrl bad VITA packet: " << ex.what() << std::endl;
+                UHD_LOGGER_ERROR("RFNOC") << "[" << _name << "] Block ctrl bad VITA packet: " << ex.what() ;
                 if (buff){
-                    UHD_MSG(status) << boost::format("%08X") % pkt[0] << std::endl;
-                    UHD_MSG(status) << boost::format("%08X") % pkt[1] << std::endl;
-                    UHD_MSG(status) << boost::format("%08X") % pkt[2] << std::endl;
-                    UHD_MSG(status) << boost::format("%08X") % pkt[3] << std::endl;
+                    UHD_LOGGER_INFO("RFNOC") << boost::format("%08X") % pkt[0] ;
+                    UHD_LOGGER_INFO("RFNOC") << boost::format("%08X") % pkt[1] ;
+                    UHD_LOGGER_INFO("RFNOC") << boost::format("%08X") % pkt[2] ;
+                    UHD_LOGGER_INFO("RFNOC") << boost::format("%08X") % pkt[3] ;
                 }
                 else{
-                    UHD_MSG(status) << "buff is NULL" << std::endl;
+                    UHD_LOGGER_INFO("RFNOC") << "buff is NULL" ;
                 }
             }
 
diff --git a/host/lib/rfnoc/ddc_block_ctrl_impl.cpp b/host/lib/rfnoc/ddc_block_ctrl_impl.cpp
index fb70b6f45..830664e5c 100644
--- a/host/lib/rfnoc/ddc_block_ctrl_impl.cpp
+++ b/host/lib/rfnoc/ddc_block_ctrl_impl.cpp
@@ -17,7 +17,7 @@
 
 #include "dsp_core_utils.hpp"
 #include <uhd/rfnoc/ddc_block_ctrl.hpp>
-#include <uhd/utils/msg.hpp>
+#include <uhd/utils/log.hpp>
 #include <uhd/convert.hpp>
 #include <uhd/types/ranges.hpp>
 #include <boost/math/special_functions/round.hpp>
@@ -141,10 +141,10 @@ public:
             const uhd::stream_cmd_t &stream_cmd_,
             const size_t chan
     ) {
-        UHD_RFNOC_BLOCK_TRACE() << "ddc_block_ctrl_base::issue_stream_cmd()" << std::endl;
+        UHD_RFNOC_BLOCK_TRACE() << "ddc_block_ctrl_base::issue_stream_cmd()" ;
 
         if (list_upstream_nodes().count(chan) == 0) {
-            UHD_MSG(status) << "No upstream blocks." << std::endl;
+            UHD_LOGGER_INFO("RFNOC") << "No upstream blocks." ;
             return;
         }
 
@@ -232,7 +232,7 @@ private:
         sr_write("M", 1, chan);
 
         if (decim > 1 and hb_enable == 0) {
-            UHD_MSG(warning) << boost::format(
+            UHD_LOGGER_WARNING("RFNOC") << boost::format(
                 "The requested decimation is odd; the user should expect passband CIC rolloff.\n"
                 "Select an even decimation to ensure that a halfband filter is enabled.\n"
                 "Decimations factorable by 4 will enable 2 halfbands, those factorable by 8 will enable 3 halfbands.\n"
diff --git a/host/lib/rfnoc/dma_fifo_block_ctrl_impl.cpp b/host/lib/rfnoc/dma_fifo_block_ctrl_impl.cpp
index aea7c591c..93f599314 100644
--- a/host/lib/rfnoc/dma_fifo_block_ctrl_impl.cpp
+++ b/host/lib/rfnoc/dma_fifo_block_ctrl_impl.cpp
@@ -19,7 +19,7 @@
 #include "dma_fifo_core_3000.hpp"
 #include "wb_iface_adapter.hpp"
 #include <uhd/convert.hpp>
-#include <uhd/utils/msg.hpp>
+#include <uhd/utils/log.hpp>
 #include <uhd/types/wb_iface.hpp>
 #include <boost/make_shared.hpp>
 #include <boost/thread/mutex.hpp>
@@ -64,18 +64,18 @@ public:
             _perifs[i].depth = DEFAULT_SIZE;
             _perifs[i].core = dma_fifo_core_3000::make(_perifs[i].ctrl, USER_SR_BASE, USER_RB_BASE);
             _perifs[i].core->resize(_perifs[i].base_addr, _perifs[i].depth);
-            UHD_MSG(status) << boost::format("[DMA FIFO] Running BIST for FIFO %d... ") % i;
+            UHD_LOGGER_INFO("RFNOC") << boost::format("[DMA FIFO] Running BIST for FIFO %d... ") % i;
             if (_perifs[i].core->ext_bist_supported()) {
                 uint32_t bisterr = _perifs[i].core->run_bist();
                 if (bisterr != 0) {
                     throw uhd::runtime_error(str(boost::format("BIST failed! (code: %d)\n") % bisterr));
                 } else {
                     double throughput = _perifs[i].core->get_bist_throughput(BUS_CLK_RATE);
-                    UHD_MSG(status) << (boost::format("pass (Throughput: %.1fMB/s)") % (throughput/1e6)) << std::endl;
+                    UHD_LOGGER_INFO("RFNOC") << (boost::format("pass (Throughput: %.1fMB/s)") % (throughput/1e6)) ;
                 }
             } else {
                 if (_perifs[i].core->run_bist() == 0) {
-                    UHD_MSG(status) << "pass\n";
+                    UHD_LOGGER_INFO("RFNOC") << "pass\n";
                 } else {
                     throw uhd::runtime_error("BIST failed!\n");
                 }
diff --git a/host/lib/rfnoc/duc_block_ctrl_impl.cpp b/host/lib/rfnoc/duc_block_ctrl_impl.cpp
index 6a3f32eaf..07279ed47 100644
--- a/host/lib/rfnoc/duc_block_ctrl_impl.cpp
+++ b/host/lib/rfnoc/duc_block_ctrl_impl.cpp
@@ -17,7 +17,7 @@
 
 #include "dsp_core_utils.hpp"
 #include <uhd/rfnoc/duc_block_ctrl.hpp>
-#include <uhd/utils/msg.hpp>
+#include <uhd/utils/log.hpp>
 #include <uhd/convert.hpp>
 #include <uhd/types/ranges.hpp>
 #include <boost/math/special_functions/round.hpp>
@@ -132,7 +132,7 @@ public:
             const uhd::stream_cmd_t &stream_cmd_,
             const size_t chan
     ) {
-        UHD_RFNOC_BLOCK_TRACE() << "duc_block_ctrl_base::issue_stream_cmd()" << std::endl;
+        UHD_RFNOC_BLOCK_TRACE() << "duc_block_ctrl_base::issue_stream_cmd()" ;
 
         uhd::stream_cmd_t stream_cmd = stream_cmd_;
         if (stream_cmd.stream_mode == uhd::stream_cmd_t::STREAM_MODE_NUM_SAMPS_AND_DONE or
@@ -217,7 +217,7 @@ private:
         sr_write("M", std::pow(2.0, double(hb_enable)) * (interp & 0xff), chan);
 
         if (interp > 1 and hb_enable == 0) {
-            UHD_MSG(warning) << boost::format(
+            UHD_LOGGER_WARNING("RFNOC") << boost::format(
                 "The requested interpolation is odd; the user should expect passband CIC rolloff.\n"
                 "Select an even interpolation to ensure that a halfband filter is enabled.\n"
                 "interpolation = dsp_rate/samp_rate -> %d = (%f MHz)/(%f MHz)\n"
diff --git a/host/lib/rfnoc/graph_impl.cpp b/host/lib/rfnoc/graph_impl.cpp
index 64c6f6abe..005e23815 100644
--- a/host/lib/rfnoc/graph_impl.cpp
+++ b/host/lib/rfnoc/graph_impl.cpp
@@ -18,7 +18,7 @@
 #include "graph_impl.hpp"
 #include <uhd/rfnoc/source_block_ctrl_base.hpp>
 #include <uhd/rfnoc/sink_block_ctrl_base.hpp>
-#include <uhd/utils/msg.hpp>
+#include <uhd/utils/log.hpp>
 
 using namespace uhd::rfnoc;
 
@@ -85,10 +85,10 @@ void graph_impl::connect(
     dst->set_upstream_port(actual_dst_block_port, actual_src_block_port);
     // At this point, ports are locked and no one else can simply connect
     // into them.
-    //UHD_MSG(status)
+    //UHD_LOGGER_INFO("RFNOC")
         //<< "[" << _name << "] Connecting "
         //<< src_block << ":" << actual_src_block_port << " --> "
-        //<< dst_block << ":" << actual_dst_block_port << std::endl;
+        //<< dst_block << ":" << actual_dst_block_port ;
 
     /********************************************************************
      * 2. Check IO signatures match
@@ -120,7 +120,7 @@ void graph_impl::connect(
      ********************************************************************/
     size_t pkt_size = (pkt_size_ != 0) ? pkt_size_ : src->get_output_signature(src_block_port).packet_size;
     if (pkt_size == 0) { // Unspecified packet rate. Assume max packet size.
-        UHD_MSG(status) << "Assuming max packet size for " << src->get_block_id() << std::endl;
+        UHD_LOGGER_INFO("RFNOC") << "Assuming max packet size for " << src->get_block_id() ;
         pkt_size = uhd::rfnoc::MAX_PACKET_SIZE;
     }
     // FC window (in packets) depends on FIFO size...          ...and packet size.
diff --git a/host/lib/rfnoc/legacy_compat.cpp b/host/lib/rfnoc/legacy_compat.cpp
index 8d64cb51a..dc711b909 100644
--- a/host/lib/rfnoc/legacy_compat.cpp
+++ b/host/lib/rfnoc/legacy_compat.cpp
@@ -26,14 +26,14 @@
 #include <uhd/types/stream_cmd.hpp>
 #include <uhd/types/direction.hpp>
 #include <uhd/types/ranges.hpp>
-#include <uhd/utils/msg.hpp>
+
 #include <uhd/utils/log.hpp>
 #include <uhd/transport/chdr.hpp>
 #include <uhd/usrp/multi_usrp.hpp>
 #include <boost/make_shared.hpp>
 #include <boost/assign.hpp>
 
-#define UHD_LEGACY_LOG() UHD_LOGV(never)
+#define UHD_LEGACY_LOG() UHD_LOGGER_TRACE("RFNOC")
 
 using namespace uhd::rfnoc;
 using uhd::usrp::subdev_spec_t;
@@ -143,21 +143,21 @@ public:
         }
         connect_blocks();
         if (args.has_key("skip_ddc")) {
-            UHD_LEGACY_LOG() << "[legacy_compat] Skipping DDCs by user request." << std::endl;
+            UHD_LEGACY_LOG() << "[legacy_compat] Skipping DDCs by user request." ;
         } else if (not _has_ddcs) {
-            UHD_MSG(warning)
+            UHD_LOGGER_WARNING("RFNOC")
                 << "[legacy_compat] No DDCs detected. You will only be able to receive at the radio frontend rate."
-                << std::endl;
+                ;
         }
         if (args.has_key("skip_duc")) {
-            UHD_LEGACY_LOG() << "[legacy_compat] Skipping DUCs by user request." << std::endl;
+            UHD_LEGACY_LOG() << "[legacy_compat] Skipping DUCs by user request." ;
         } else if (not _has_ducs) {
-            UHD_MSG(warning) << "[legacy_compat] No DUCs detected. You will only be able to transmit at the radio frontend rate." << std::endl;
+            UHD_LOGGER_WARNING("RFNOC") << "[legacy_compat] No DUCs detected. You will only be able to transmit at the radio frontend rate." ;
         }
         if (args.has_key("skip_dram")) {
-            UHD_LEGACY_LOG() << "[legacy_compat] Skipping DRAM by user request." << std::endl;
+            UHD_LEGACY_LOG() << "[legacy_compat] Skipping DRAM by user request." ;
         } else if (not _has_dmafifo) {
-            UHD_MSG(warning) << "[legacy_compat] No DMA FIFO detected. You will only be able to transmit at slow rates." << std::endl;
+            UHD_LOGGER_WARNING("RFNOC") << "[legacy_compat] No DMA FIFO detected. You will only be able to transmit at slow rates." ;
         }
 
         for (size_t mboard = 0; mboard < _num_mboards; mboard++) {
@@ -241,7 +241,7 @@ public:
 
     void issue_stream_cmd(const stream_cmd_t &stream_cmd, size_t mboard, size_t chan)
     {
-        UHD_LEGACY_LOG() << "[legacy_compat] issue_stream_cmd() " << std::endl;
+        UHD_LEGACY_LOG() << "[legacy_compat] issue_stream_cmd() " ;
         const size_t &radio_index = _rx_channel_map[mboard][chan].radio_index;
         const size_t &port_index  = _rx_channel_map[mboard][chan].port_index;
         if (_has_ddcs) {
@@ -259,7 +259,7 @@ public:
             args.otw_format = "sc16";
         }
         _update_stream_args_for_streaming<uhd::RX_DIRECTION>(args, _rx_channel_map);
-        UHD_LEGACY_LOG() << "[legacy_compat] rx stream args: " << args.args.to_string() << std::endl;
+        UHD_LEGACY_LOG() << "[legacy_compat] rx stream args: " << args.args.to_string() ;
         uhd::rx_streamer::sptr streamer = _device->get_rx_stream(args);
         for(const size_t chan:  args.channels) {
             _rx_stream_cache[chan] = streamer;
@@ -276,7 +276,7 @@ public:
             args.otw_format = "sc16";
         }
         _update_stream_args_for_streaming<uhd::TX_DIRECTION>(args, _tx_channel_map);
-        UHD_LEGACY_LOG() << "[legacy_compat] tx stream args: " << args.args.to_string() << std::endl;
+        UHD_LEGACY_LOG() << "[legacy_compat] tx stream args: " << args.args.to_string() ;
         uhd::tx_streamer::sptr streamer = _device->get_tx_stream(args);
         for(const size_t chan:  args.channels) {
             _tx_stream_cache[chan] = streamer;
@@ -573,7 +573,7 @@ private: // methods
 
                 const size_t this_spp = get_block_ctrl<radio_ctrl>(i, RADIO_BLOCK_NAME, k)->get_arg<int>("spp");
                 if (this_spp != _rx_spp) {
-                    UHD_LOG << str(
+                    UHD_LOGGER_WARNING("RFNOC") << str(
                             boost::format("[legacy compat] Radios have differing spp values: %s has %d, others have %d. UHD will use smaller spp value for all connections. Performance might be not optimal.")
                             % radio_block_id.to_string() % this_spp % _rx_spp
                     );
@@ -865,7 +865,7 @@ legacy_compat::sptr legacy_compat::make(
     if (legacy_cache.count(device.get()) and not legacy_cache.at(device.get()).expired()) {
         legacy_compat::sptr legacy_compat_copy = legacy_cache.at(device.get()).lock();
         UHD_ASSERT_THROW(bool(legacy_compat_copy));
-        UHD_LEGACY_LOG() << "[legacy_compat] Using existing legacy compat object for this device." << std::endl;
+        UHD_LEGACY_LOG() << "[legacy_compat] Using existing legacy compat object for this device." ;
         return legacy_compat_copy;
     }
 
diff --git a/host/lib/rfnoc/nocscript/block_iface.cpp b/host/lib/rfnoc/nocscript/block_iface.cpp
index 0d301e5bc..544593def 100644
--- a/host/lib/rfnoc/nocscript/block_iface.cpp
+++ b/host/lib/rfnoc/nocscript/block_iface.cpp
@@ -18,12 +18,12 @@
 #include "block_iface.hpp"
 #include "function_table.hpp"
 #include <uhd/exception.hpp>
-#include <uhd/utils/msg.hpp>
+#include <uhd/utils/log.hpp>
 #include <boost/assign.hpp>
 #include <boost/bind.hpp>
 #include <boost/format.hpp>
 
-#define UHD_NOCSCRIPT_LOG() UHD_LOGV(never)
+#define UHD_NOCSCRIPT_LOG() UHD_LOGGER_TRACE("RFNOC")
 
 using namespace uhd::rfnoc;
 using namespace uhd::rfnoc::nocscript;
@@ -116,7 +116,7 @@ void block_iface::run_and_check(const std::string &code, const std::string &erro
 {
     boost::mutex::scoped_lock local_interpreter_lock(_lil_mutex);
 
-    UHD_NOCSCRIPT_LOG() << "[NocScript] Executing and asserting code: " << code << std::endl;
+    UHD_NOCSCRIPT_LOG() << "[NocScript] Executing and asserting code: " << code ;
     expression::sptr e = _parser->create_expr_tree(code);
     expression_literal result = e->eval();
     if (not result.to_bool()) {
@@ -143,12 +143,12 @@ expression_literal block_iface::_nocscript__sr_write(expression_container::expr_
     const uint32_t reg_val = uint32_t(args[1]->eval().get_int());
     bool result = true;
     try {
-        UHD_NOCSCRIPT_LOG() << "[NocScript] Executing SR_WRITE() " << std::endl;
+        UHD_NOCSCRIPT_LOG() << "[NocScript] Executing SR_WRITE() " ;
         _block_ptr->sr_write(reg_name, reg_val);
     } catch (const uhd::exception &e) {
-        UHD_MSG(error) << boost::format("[NocScript] Error while executing SR_WRITE(%s, 0x%X):\n%s")
+        UHD_LOGGER_ERROR("RFNOC") << boost::format("[NocScript] Error while executing SR_WRITE(%s, 0x%X):\n%s")
                           % reg_name % reg_val % e.what()
-                       << std::endl;
+                       ;
         result = false;
     }
 
@@ -195,7 +195,7 @@ expression_literal block_iface::_nocscript__arg_set_int(const expression_contain
     if (args.size() == 3) {
         port = size_t(args[2]->eval().get_int());
     }
-    UHD_NOCSCRIPT_LOG() << "[NocScript] Setting $" << var_name << std::endl;
+    UHD_NOCSCRIPT_LOG() << "[NocScript] Setting $" << var_name ;
     _block_ptr->set_arg<int>(var_name, val, port);
     return expression_literal(true);
 }
@@ -208,7 +208,7 @@ expression_literal block_iface::_nocscript__arg_set_string(const expression_cont
     if (args.size() == 3) {
         port = size_t(args[2]->eval().get_int());
     }
-    UHD_NOCSCRIPT_LOG() << "[NocScript] Setting $" << var_name << std::endl;
+    UHD_NOCSCRIPT_LOG() << "[NocScript] Setting $" << var_name ;
     _block_ptr->set_arg<std::string>(var_name, val, port);
     return expression_literal(true);
 }
@@ -221,7 +221,7 @@ expression_literal block_iface::_nocscript__arg_set_double(const expression_cont
     if (args.size() == 3) {
         port = size_t(args[2]->eval().get_int());
     }
-    UHD_NOCSCRIPT_LOG() << "[NocScript] Setting $" << var_name << std::endl;
+    UHD_NOCSCRIPT_LOG() << "[NocScript] Setting $" << var_name ;
     _block_ptr->set_arg<double>(var_name, val, port);
     return expression_literal(true);
 }
@@ -239,8 +239,8 @@ block_iface::sptr block_iface::make(uhd::rfnoc::block_ctrl_base* block_ptr)
 expression_literal block_iface::_nocscript__var_get(const expression_container::expr_list_type &args)
 {
     expression_literal expr = _vars[args[0]->eval().get_string()];
-    //std::cout << "[NocScript] Getting var " << args[0]->eval().get_string() << " == " << expr << std::endl;
-    //std::cout << "[NocScript] Type " << expr.infer_type() << std::endl;
+    //std::cout << "[NocScript] Getting var " << args[0]->eval().get_string() << " == " << expr ;
+    //std::cout << "[NocScript] Type " << expr.infer_type() ;
     //return _vars[args[0]->eval().get_string()];
     return expr;
 }
@@ -248,8 +248,8 @@ expression_literal block_iface::_nocscript__var_get(const expression_container::
 expression_literal block_iface::_nocscript__var_set(const expression_container::expr_list_type &args)
 {
     _vars[args[0]->eval().get_string()] = args[1]->eval();
-    //std::cout << "[NocScript] Set var " << args[0]->eval().get_string() << " to " << _vars[args[0]->eval().get_string()] << std::endl;
-    //std::cout << "[NocScript] Type " << _vars[args[0]->eval().get_string()].infer_type() << std::endl;
+    //std::cout << "[NocScript] Set var " << args[0]->eval().get_string() << " to " << _vars[args[0]->eval().get_string()] ;
+    //std::cout << "[NocScript] Type " << _vars[args[0]->eval().get_string()].infer_type() ;
     return expression_literal(true);
 }
 
diff --git a/host/lib/rfnoc/node_ctrl_base.cpp b/host/lib/rfnoc/node_ctrl_base.cpp
index b4d0a30ff..e9424d319 100644
--- a/host/lib/rfnoc/node_ctrl_base.cpp
+++ b/host/lib/rfnoc/node_ctrl_base.cpp
@@ -16,7 +16,7 @@
 //
 
 #include <uhd/rfnoc/node_ctrl_base.hpp>
-#include <uhd/utils/msg.hpp>
+#include <uhd/utils/log.hpp>
 #include <boost/range/adaptor/map.hpp>
 
 using namespace uhd::rfnoc;
@@ -30,7 +30,7 @@ std::string node_ctrl_base::unique_id() const
 
 void node_ctrl_base::clear()
 {
-    UHD_RFNOC_BLOCK_TRACE() << "node_ctrl_base::clear() " << std::endl;
+    UHD_RFNOC_BLOCK_TRACE() << "node_ctrl_base::clear() " ;
     // Reset connections:
     _upstream_nodes.clear();
     _downstream_nodes.clear();
diff --git a/host/lib/rfnoc/radio_ctrl_impl.cpp b/host/lib/rfnoc/radio_ctrl_impl.cpp
index 7a3cae79c..0dc5cd168 100644
--- a/host/lib/rfnoc/radio_ctrl_impl.cpp
+++ b/host/lib/rfnoc/radio_ctrl_impl.cpp
@@ -19,7 +19,7 @@
 #include <boost/format.hpp>
 #include <boost/bind.hpp>
 #include <uhd/convert.hpp>
-#include <uhd/utils/msg.hpp>
+#include <uhd/utils/log.hpp>
 #include <uhd/types/ranges.hpp>
 #include <uhd/types/direction.hpp>
 #include "radio_ctrl_impl.hpp"
@@ -136,7 +136,6 @@ radio_ctrl_impl::radio_ctrl_impl() :
 
 void radio_ctrl_impl::_register_loopback_self_test(size_t chan)
 {
-    UHD_MSG(status) << "[RFNoC Radio] Performing register loopback test... " << std::flush;
     size_t hash = size_t(time(NULL));
     for (size_t i = 0; i < 100; i++)
     {
@@ -144,12 +143,12 @@ void radio_ctrl_impl::_register_loopback_self_test(size_t chan)
         sr_write(regs::TEST, uint32_t(hash), chan);
         uint32_t result = user_reg_read32(regs::RB_TEST, chan);
         if (result != uint32_t(hash)) {
-            UHD_MSG(status) << "fail" << std::endl;
-            UHD_MSG(status) << boost::format("expected: %x result: %x") % uint32_t(hash) % result << std::endl;
+            UHD_LOGGER_ERROR("RFNOC RADIO") << "Register loopback test failed";
+            UHD_LOGGER_ERROR("RFNOC RADIO") << boost::format("expected: %x result: %x") % uint32_t(hash) % result ;
             return; // exit on any failure
         }
     }
-    UHD_MSG(status) << "pass" << std::endl;
+    UHD_LOGGER_INFO("RFNOC RADIO") << "Register loopback test passed";
 }
 
 /****************************************************************************
@@ -241,9 +240,9 @@ double radio_ctrl_impl::get_rx_gain(const size_t chan) /* const */
 void radio_ctrl_impl::issue_stream_cmd(const uhd::stream_cmd_t &stream_cmd, const size_t chan)
 {
     boost::mutex::scoped_lock lock(_mutex);
-    UHD_RFNOC_BLOCK_TRACE() << "radio_ctrl_impl::issue_stream_cmd() " << chan << " " << char(stream_cmd.stream_mode) << std::endl;
+    UHD_RFNOC_BLOCK_TRACE() << "radio_ctrl_impl::issue_stream_cmd() " << chan << " " << char(stream_cmd.stream_mode) ;
     if (not _is_streamer_active(uhd::RX_DIRECTION, chan)) {
-        UHD_RFNOC_BLOCK_TRACE() << "radio_ctrl_impl::issue_stream_cmd() called on inactive channel. Skipping." << std::endl;
+        UHD_RFNOC_BLOCK_TRACE() << "radio_ctrl_impl::issue_stream_cmd() called on inactive channel. Skipping." ;
         return;
     }
     UHD_ASSERT_THROW(stream_cmd.num_samps <= 0x0fffffff);
@@ -295,7 +294,7 @@ std::vector<size_t> radio_ctrl_impl::get_active_rx_ports()
  **********************************************************************/
 void radio_ctrl_impl::set_rx_streamer(bool active, const size_t port)
 {
-    UHD_RFNOC_BLOCK_TRACE() << "radio_ctrl_impl::set_rx_streamer() " << port << " -> " << active << std::endl;
+    UHD_RFNOC_BLOCK_TRACE() << "radio_ctrl_impl::set_rx_streamer() " << port << " -> " << active ;
     if (port > _num_rx_channels) {
         throw uhd::value_error(str(
             boost::format("[%s] Can't (un)register RX streamer on port %d (invalid port)")
@@ -313,7 +312,7 @@ void radio_ctrl_impl::set_rx_streamer(bool active, const size_t port)
 
 void radio_ctrl_impl::set_tx_streamer(bool active, const size_t port)
 {
-    UHD_RFNOC_BLOCK_TRACE() << "radio_ctrl_impl::set_tx_streamer() " << port << " -> " << active << std::endl;
+    UHD_RFNOC_BLOCK_TRACE() << "radio_ctrl_impl::set_tx_streamer() " << port << " -> " << active ;
     if (port > _num_tx_channels) {
         throw uhd::value_error(str(
             boost::format("[%s] Can't (un)register TX streamer on port %d (invalid port)")
@@ -334,11 +333,11 @@ void radio_ctrl_impl::set_tx_streamer(bool active, const size_t port)
 void radio_ctrl_impl::_update_spp(int spp)
 {
     boost::mutex::scoped_lock lock(_mutex);
-    UHD_RFNOC_BLOCK_TRACE() << "radio_ctrl_impl::_update_spp(): Requested spp: " << spp << std::endl;
+    UHD_RFNOC_BLOCK_TRACE() << "radio_ctrl_impl::_update_spp(): Requested spp: " << spp ;
     if (spp == 0) {
         spp = DEFAULT_PACKET_SIZE / BYTES_PER_SAMPLE;
     }
-    UHD_RFNOC_BLOCK_TRACE() << "radio_ctrl_impl::_update_spp(): Setting spp to: " << spp << std::endl;
+    UHD_RFNOC_BLOCK_TRACE() << "radio_ctrl_impl::_update_spp(): Setting spp to: " << spp ;
     for (size_t i = 0; i < _num_rx_channels; i++) {
         sr_write(regs::RX_CTRL_MAXLEN, uint32_t(spp), i);
     }
diff --git a/host/lib/rfnoc/rx_stream_terminator.cpp b/host/lib/rfnoc/rx_stream_terminator.cpp
index 52803d6b6..e05d9cd49 100644
--- a/host/lib/rfnoc/rx_stream_terminator.cpp
+++ b/host/lib/rfnoc/rx_stream_terminator.cpp
@@ -18,7 +18,7 @@
 #include "rx_stream_terminator.hpp"
 #include "radio_ctrl_impl.hpp"
 #include "../transport/super_recv_packet_handler.hpp"
-#include <uhd/utils/msg.hpp>
+#include <uhd/utils/log.hpp>
 #include <uhd/rfnoc/source_node_ctrl.hpp>
 #include <boost/format.hpp>
 
@@ -47,7 +47,7 @@ void rx_stream_terminator::set_tx_streamer(bool, const size_t)
 void rx_stream_terminator::set_rx_streamer(bool active, const size_t)
 {
     // TODO this is identical to source_node_ctrl::set_rx_streamer() -> factor out
-    UHD_RFNOC_BLOCK_TRACE() << "rx_stream_terminator::set_rx_streamer() " << active << std::endl;
+    UHD_RFNOC_BLOCK_TRACE() << "rx_stream_terminator::set_rx_streamer() " << active;
     for(const node_ctrl_base::node_map_pair_t upstream_node:  _upstream_nodes) {
         source_node_ctrl::sptr curr_upstream_block_ctrl =
             boost::dynamic_pointer_cast<source_node_ctrl>(upstream_node.second.lock());
@@ -70,7 +70,7 @@ void rx_stream_terminator::handle_overrun(boost::weak_ptr<uhd::rx_streamer> stre
         return;
     }
 
-    UHD_RFNOC_BLOCK_TRACE() << "rx_stream_terminator::handle_overrun()" << std::endl;
+    UHD_RFNOC_BLOCK_TRACE() << "rx_stream_terminator::handle_overrun()" ;
     boost::shared_ptr<uhd::transport::sph::recv_packet_streamer> my_streamer =
             boost::dynamic_pointer_cast<uhd::transport::sph::recv_packet_streamer>(streamer.lock());
     if (not my_streamer) return; //If the rx_streamer has expired then overflow handling makes no sense.
@@ -125,7 +125,7 @@ void rx_stream_terminator::handle_overrun(boost::weak_ptr<uhd::rx_streamer> stre
 
 rx_stream_terminator::~rx_stream_terminator()
 {
-    UHD_RFNOC_BLOCK_TRACE() << "rx_stream_terminator::~rx_stream_terminator() " << std::endl;
+    UHD_RFNOC_BLOCK_TRACE() << "rx_stream_terminator::~rx_stream_terminator() " ;
     set_rx_streamer(false, 0);
 }
 
diff --git a/host/lib/rfnoc/sink_block_ctrl_base.cpp b/host/lib/rfnoc/sink_block_ctrl_base.cpp
index 4b4eec20d..48291e02f 100644
--- a/host/lib/rfnoc/sink_block_ctrl_base.cpp
+++ b/host/lib/rfnoc/sink_block_ctrl_base.cpp
@@ -18,7 +18,7 @@
 #include "utils.hpp"
 #include <uhd/rfnoc/sink_block_ctrl_base.hpp>
 #include <uhd/rfnoc/constants.hpp>
-#include <uhd/utils/msg.hpp>
+#include <uhd/utils/log.hpp>
 
 using namespace uhd;
 using namespace uhd::rfnoc;
@@ -66,7 +66,7 @@ void sink_block_ctrl_base::configure_flow_control_in(
         size_t packets,
         size_t block_port
 ) {
-    UHD_RFNOC_BLOCK_TRACE() << boost::format("sink_block_ctrl_base::configure_flow_control_in(cycles=%d, packets=%d)") % cycles % packets << std::endl;
+    UHD_RFNOC_BLOCK_TRACE() << boost::format("sink_block_ctrl_base::configure_flow_control_in(cycles=%d, packets=%d)") % cycles % packets ;
     uint32_t cycles_word = 0;
     if (cycles) {
         cycles_word = (1<<31) | cycles;
diff --git a/host/lib/rfnoc/sink_node_ctrl.cpp b/host/lib/rfnoc/sink_node_ctrl.cpp
index 2915369f3..c570b8eca 100644
--- a/host/lib/rfnoc/sink_node_ctrl.cpp
+++ b/host/lib/rfnoc/sink_node_ctrl.cpp
@@ -16,7 +16,7 @@
 //
 
 #include "utils.hpp"
-#include <uhd/utils/msg.hpp>
+#include <uhd/utils/log.hpp>
 #include <uhd/rfnoc/sink_node_ctrl.hpp>
 #include <uhd/rfnoc/source_node_ctrl.hpp>
 
@@ -35,7 +35,7 @@ size_t sink_node_ctrl::connect_upstream(
 
 void sink_node_ctrl::set_tx_streamer(bool active, const size_t port)
 {
-    UHD_RFNOC_BLOCK_TRACE() << "sink_node_ctrl::set_tx_streamer() " << active << " " << port << std::endl;
+    UHD_RFNOC_BLOCK_TRACE() << "sink_node_ctrl::set_tx_streamer() " << active << " " << port ;
 
     /* Enable all downstream connections:
     for(const node_ctrl_base::node_map_pair_t downstream_node:  list_downstream_nodes()) {
diff --git a/host/lib/rfnoc/source_block_ctrl_base.cpp b/host/lib/rfnoc/source_block_ctrl_base.cpp
index 3d5d2b2b6..4cc889545 100644
--- a/host/lib/rfnoc/source_block_ctrl_base.cpp
+++ b/host/lib/rfnoc/source_block_ctrl_base.cpp
@@ -17,7 +17,7 @@
 
 #include "utils.hpp"
 #include <uhd/rfnoc/source_block_ctrl_base.hpp>
-#include <uhd/utils/msg.hpp>
+#include <uhd/utils/log.hpp>
 #include <uhd/rfnoc/constants.hpp>
 
 using namespace uhd;
@@ -30,9 +30,9 @@ void source_block_ctrl_base::issue_stream_cmd(
         const uhd::stream_cmd_t &stream_cmd,
         const size_t chan
 ) {
-    UHD_RFNOC_BLOCK_TRACE() << "source_block_ctrl_base::issue_stream_cmd()" << std::endl;
+    UHD_RFNOC_BLOCK_TRACE() << "source_block_ctrl_base::issue_stream_cmd()" ;
     if (_upstream_nodes.empty()) {
-        UHD_MSG(warning) << "issue_stream_cmd() not implemented for " << get_block_id() << std::endl;
+        UHD_LOGGER_WARNING("RFNOC") << "issue_stream_cmd() not implemented for " << get_block_id() ;
         return;
     }
 
@@ -77,10 +77,10 @@ void source_block_ctrl_base::set_destination(
         uint32_t next_address,
         size_t output_block_port
 ) {
-    UHD_RFNOC_BLOCK_TRACE() << "source_block_ctrl_base::set_destination() " << uhd::sid_t(next_address) << std::endl;
+    UHD_RFNOC_BLOCK_TRACE() << "source_block_ctrl_base::set_destination() " << uhd::sid_t(next_address) ;
     sid_t new_sid(next_address);
     new_sid.set_src(get_address(output_block_port));
-    UHD_RFNOC_BLOCK_TRACE() << "  Setting SID: " << new_sid << std::endl << "  ";
+    UHD_RFNOC_BLOCK_TRACE() << "  Setting SID: " << new_sid  << "  ";
     sr_write(SR_NEXT_DST_SID, (1<<16) | next_address, output_block_port);
 }
 
@@ -89,7 +89,7 @@ void source_block_ctrl_base::configure_flow_control_out(
             size_t block_port,
             UHD_UNUSED(const uhd::sid_t &sid)
 ) {
-    UHD_RFNOC_BLOCK_TRACE() << "source_block_ctrl_base::configure_flow_control_out() buf_size_pkts==" << buf_size_pkts << std::endl;
+    UHD_RFNOC_BLOCK_TRACE() << "source_block_ctrl_base::configure_flow_control_out() buf_size_pkts==" << buf_size_pkts ;
     if (buf_size_pkts < 2) {
       throw uhd::runtime_error(str(
               boost::format("Invalid window size %d for block %s. Window size must at least be 2.")
diff --git a/host/lib/rfnoc/source_node_ctrl.cpp b/host/lib/rfnoc/source_node_ctrl.cpp
index b3cc5e640..1b9d427b9 100644
--- a/host/lib/rfnoc/source_node_ctrl.cpp
+++ b/host/lib/rfnoc/source_node_ctrl.cpp
@@ -16,7 +16,7 @@
 //
 
 #include "utils.hpp"
-#include <uhd/utils/msg.hpp>
+#include <uhd/utils/log.hpp>
 #include <uhd/rfnoc/source_node_ctrl.hpp>
 #include <uhd/rfnoc/sink_node_ctrl.hpp>
 
@@ -35,7 +35,7 @@ size_t source_node_ctrl::connect_downstream(
 
 void source_node_ctrl::set_rx_streamer(bool active, const size_t port)
 {
-    UHD_RFNOC_BLOCK_TRACE() << "source_node_ctrl::set_rx_streamer() " << port << " -> " << active << std::endl;
+    UHD_RFNOC_BLOCK_TRACE() << "source_node_ctrl::set_rx_streamer() " << port << " -> " << active ;
 
     /* This will enable all upstream blocks:
     for(const node_ctrl_base::node_map_pair_t upstream_node:  list_upstream_nodes()) {
diff --git a/host/lib/rfnoc/tx_stream_terminator.cpp b/host/lib/rfnoc/tx_stream_terminator.cpp
index 8544b945d..1d2653d47 100644
--- a/host/lib/rfnoc/tx_stream_terminator.cpp
+++ b/host/lib/rfnoc/tx_stream_terminator.cpp
@@ -44,7 +44,7 @@ void tx_stream_terminator::set_rx_streamer(bool, const size_t)
 void tx_stream_terminator::set_tx_streamer(bool active, const size_t /* port */)
 {
     // TODO this is identical to sink_node_ctrl::set_tx_streamer() -> factor out
-    UHD_RFNOC_BLOCK_TRACE() << "tx_stream_terminator::set_tx_streamer() " << active << std::endl;
+    UHD_RFNOC_BLOCK_TRACE() << "tx_stream_terminator::set_tx_streamer() " << active;
     for(const node_ctrl_base::node_map_pair_t downstream_node:  _downstream_nodes) {
         sink_node_ctrl::sptr curr_downstream_block_ctrl =
             boost::dynamic_pointer_cast<sink_node_ctrl>(downstream_node.second.lock());
@@ -61,7 +61,7 @@ void tx_stream_terminator::set_tx_streamer(bool active, const size_t /* port */)
 
 tx_stream_terminator::~tx_stream_terminator()
 {
-    UHD_RFNOC_BLOCK_TRACE() << "tx_stream_terminator::~tx_stream_terminator() " << std::endl;
+    UHD_RFNOC_BLOCK_TRACE() << "tx_stream_terminator::~tx_stream_terminator() " ;
     set_tx_streamer(false, 0);
 }
 
diff --git a/host/lib/rfnoc/tx_stream_terminator.hpp b/host/lib/rfnoc/tx_stream_terminator.hpp
index 169d7cd6a..dd2b991f6 100644
--- a/host/lib/rfnoc/tx_stream_terminator.hpp
+++ b/host/lib/rfnoc/tx_stream_terminator.hpp
@@ -24,7 +24,7 @@
 #include <uhd/rfnoc/scalar_node_ctrl.hpp>
 #include <uhd/rfnoc/terminator_node_ctrl.hpp>
 #include <uhd/rfnoc/block_ctrl_base.hpp> // For the block macros
-#include <uhd/utils/msg.hpp>
+#include <uhd/utils/log.hpp>
 
 namespace uhd {
     namespace rfnoc {
@@ -51,7 +51,7 @@ public:
 
     void issue_stream_cmd(const uhd::stream_cmd_t &, const size_t)
     {
-        UHD_RFNOC_BLOCK_TRACE() << "tx_stream_terminator::issue_stream_cmd()" << std::endl;
+        UHD_RFNOC_BLOCK_TRACE() << "tx_stream_terminator::issue_stream_cmd()" ;
     }
 
     // If this is called, then by a send terminator at the other end