diff --git a/configfiles/Dummy/ToolChainConfig b/configfiles/Dummy/ToolChainConfig
index ba9a9f2..e19f771 100644
--- a/configfiles/Dummy/ToolChainConfig
+++ b/configfiles/Dummy/ToolChainConfig
@@ -45,6 +45,7 @@ mon_port 5000                   # remote multicast port to send monitoring messa
 multicast_send_period 5000      # logging & monitoring messages will be sent as a batch once per this period
 alarm_cooldown_ms 1000          # alarms with the same device and message will be limited to this rate
 mon_merge_period 5000           # monitoring messages with the same device and subject will be limited to this rate
+MTU 1500                        # MTU of interface used for logging/monitoring
 
 ##### Tools To Add #####
 Tools_File configfiles/Dummy/ToolsConfig    # list of tools to run and their config files
diff --git a/configfiles/template/ToolChainConfig b/configfiles/template/ToolChainConfig
index b4dd22b..21a9768 100644
--- a/configfiles/template/ToolChainConfig
+++ b/configfiles/template/ToolChainConfig
@@ -45,6 +45,7 @@ mon_port 5000                   # remote multicast port to send monitoring messa
 multicast_send_period 5000      # logging & monitoring messages will be sent as a batch once per this period
 alarm_cooldown_ms 1000          # alarms with the same device and message will be limited to this rate
 mon_merge_period 5000           # monitoring messages with the same device and subject will be limited to this rate
+MTU 1500                        # MTU of interface used for logging/monitoring
 
 ##### Tools To Add #####
 Tools_File configfiles/ToolsConfig    # list of tools to run and their config files
diff --git a/src/RemoteControl/RemoteControl.cpp b/src/RemoteControl/RemoteControl.cpp
index 20a7ddc..6997e66 100644
--- a/src/RemoteControl/RemoteControl.cpp
+++ b/src/RemoteControl/RemoteControl.cpp
@@ -5,6 +5,8 @@
 
 #include "ServiceDiscovery.h"
 #include "zmq.hpp"
+#include <zstd.h>
+#include "zstd_helpers.h"
 
 #include <boost/uuid/uuid.hpp>            // uuid class
 #include <boost/uuid/uuid_generators.hpp> // generators
@@ -30,6 +32,7 @@ int main(int argc, char** argv){
    
    
    zmq::context_t context(3);
+   ZSTD_DCtx* zstd_dctx = ZSTD_createDCtx();
 
   //std::string address(argv[1]);
   // std::stringstream tmp (argv[2]);
@@ -236,14 +239,17 @@ int main(int argc, char** argv){
 	  
 	  zmq::message_t receive;
 	  if(ServiceSend.recv(&receive)){
-	    std::istringstream iss(static_cast<char*>(receive.data()));
-	    
 	    std::string answer;
-	    answer=iss.str();
+	    if(!ZstdDecompress(zstd_dctx, (char*)receive.data(), receive.size(), answer)){
+	      std::cerr<<"failed to decompress reply!: "<<answer<<std::endl;
+	      
+	    } else {
+	      Store rr;
+	      rr.JsonParser(answer);
+	      if(rr.Get<std::string>("msg_type")=="Command Reply") std::cout<<std::endl<<rr.Get<std::string>("msg_value")<<std::endl<<std::endl;
+	      
+	    }
 	    
-	    Store rr;
-	    rr.JsonParser(answer);
-	    if(rr.Get<std::string>("msg_type")=="Command Reply") std::cout<<std::endl<<(rr.Get<std::string>("msg_value"))<<std::endl<<std::endl;
 	  }
 	  else std::cout<<std::endl<<"message timed out"<<std::endl; 
 	  
@@ -364,15 +370,18 @@ int main(int argc, char** argv){
 	    
 	    zmq::message_t receive;
 	    if(ServiceSend.recv(&receive)){
-	      std::istringstream iss(static_cast<char*>(receive.data()));
-	      
 	      std::string answer;
-	      answer=iss.str();
-	      
-	      Store rr;
-	      rr.JsonParser(answer);
-	      if(rr.Get<std::string>("msg_type")=="Command Reply") std::cout<<std::endl<<rr.Get<std::string>("msg_value")<<std::endl<<std::endl;
+	      if(!ZstdDecompress(zstd_dctx, (char*)receive.data(), receive.size(), answer)){
+	        std::cerr<<"failed to decompress reply!"<<std::endl;
+	        
+	      } else {
+	        Store rr;
+	        rr.JsonParser(answer);
+	        if(rr.Get<std::string>("msg_type")=="Command Reply") std::cout<<std::endl<<rr.Get<std::string>("msg_value")<<std::endl<<std::endl;
+	        
+	      }
 	    }
+	    
 	  }
 	}
 	
@@ -392,3 +401,5 @@ int main(int argc, char** argv){
   return 0;
   
 }
+
+
diff --git a/src/ServiceDiscovery/Services.cpp b/src/ServiceDiscovery/Services.cpp
index cec329d..241f129 100644
--- a/src/ServiceDiscovery/Services.cpp
+++ b/src/ServiceDiscovery/Services.cpp
@@ -3,8 +3,9 @@
 using namespace ToolFramework;
 
 namespace {
-  constexpr uint32_t MAX_UDP_PACKET_SIZE = 655355;
+  constexpr uint32_t MAX_UDP_PACKET_SIZE = 65507;
   constexpr size_t MAX_MSG_SIZE = MAX_UDP_PACKET_SIZE-100; // 100 chars for JSON keys, timestamp string and quotes/commas
+  uint32_t MSS_SIZE=1472; // for standard MTU of 1500 bytes
 }
 
 Services::Services(){
@@ -55,6 +56,7 @@ bool Services::Init(Store &m_variables, zmq::context_t* context_in, SlowControlC
   m_variables.Get("multicast_send_period_ms",multicast_send_period_ms);
   m_variables.Get("alarm_cooldown_ms",alarm_cooldown_ms);
   m_variables.Get("verbose",m_verbose);
+  if(m_variables.Get("MTU",MSS_SIZE)) MSS_SIZE -= 28; // account for headers
   
   sc_vars->InitThreadedReceiver(m_context, sc_port, 100, new_service, alert_receive_port, alerts_receive, alert_send_port, alerts_send);
   m_backend_client.SetUp(m_context);
@@ -65,7 +67,7 @@ bool Services::Init(Store &m_variables, zmq::context_t* context_in, SlowControlC
   sc_vars->Add("LoadConfig",SlowControlElementType(COMMAND),std::bind(&Services::LoadConfigSlowControlFunc, this, std::placeholders::_1),0,false,false);
   AlertSubscribe("LoadConfig", std::bind(&Services::LoadConfigAlertFunc, this,  std::placeholders::_1, std::placeholders::_2));
 
-  sc_vars->Add("LocalConfig",SlowControlElementType(INFO),std::bind(&Services::SCLocalConfig, this, std::placeholders::_1),0,false,false);
+  sc_vars->Add("LocalConfig",SlowControlElementType(INFO),0,std::bind(&Services::SCLocalConfig, this, std::placeholders::_1),false,true); // FIXME hidden until Control page supports JSON
 
   
   if(!m_variables.Get("service_name",m_name)) m_name="test_service";
@@ -106,6 +108,13 @@ bool Services::Init(Store &m_variables, zmq::context_t* context_in, SlowControlC
     return false;
   }
   
+  // fewer, larger packets are better for network performance, so we batch logging and monitoring messages.
+  // on the other hand, if packet size exceeds the MTU, they will fragment, increasing packets and reducing reliability
+  // so, try to batch up to the MTU size. In order to do that, we need to know the MTU.
+  //std::set<std::string> interfaces = GetInterfaces();
+  //if(interfaces.size()) MSS_SIZE = GetMTU(interfaces[??]); // but which interface?
+  // just get MTU from config variable. *sigh*
+  
   return true;
 }
 
@@ -978,24 +987,35 @@ bool Services::SendLog(const std::string& message, LogLevel severity, const std:
   
   const std::string& name = (device=="") ? m_name : device;
   
-  // FIXME we should be able to relax this check if compression is enabled...
-  if((message.length()+name.length())>MAX_MSG_SIZE){
-    if(m_verbose) std::cerr<<"Logging message is too long!"<<std::endl;
-    return false;
-  }
+  // grab timestamp at time of call if 0
+  time_t ts = (timestamp!=0) ? timestamp : time(nullptr)*1000;
   
   std::unique_lock<std::mutex> locker(logging_buf_mtx);
   
+  // merge identical logging messages back-to-back
   if(logging_buf.size() && name==logging_buf.back().device && message==logging_buf.back().message){
     ++logging_buf.back().repeats;
     return true;
   }
   
-  // grab timestamp at time of call if 0
-  time_t ts = (timestamp!=0) ? timestamp : time(nullptr)*1000;
+  // reject if this message is too big to fit in a UDP datagram even with compression
+  size_t compressed_bytes = ZSTD_compressBound(message.length()+name.length());
+  if(ZSTD_isError(compressed_bytes) || compressed_bytes > MAX_MSG_SIZE){
+    if(m_verbose) std::cerr<<"Logging message is too long!"<<std::endl;
+    return false;
+  }
+  
+  // if appending this message to the batch may put the batch over the UDP datagram size limit,
+  // we need to send current contents first.
+  // actually, let's be more conservative and send before we go over MSS to prevent fragmentation if we can
+  if((compressed_bytes+thread_args.logging_batch_bytes) > MSS_SIZE){
+    BatchAndSendMulticast(&thread_args, false, true); // don't try to lock logging buffer, we've got it
+  }
   
   logging_buf.emplace_back(message, severity, name, ts);
   
+  thread_args.logging_batch_bytes += compressed_bytes;
+  
   return true;
 }
 
@@ -1017,24 +1037,38 @@ bool Services::SendMonitoringData(const std::string& json_data, const std::strin
   
   const std::string& name = (device=="") ? m_name : device;
   
-  if((json_data.length()+name.length()+subject.length())>MAX_MSG_SIZE){
-    if(m_verbose) std::cerr<<"Monitoring message is too long!"<<std::endl;
-    return false;
-  }
-  
   // grab timestamp at time of call if 0
   time_t ts = (timestamp!=0) ? timestamp : time(nullptr)*1000;
   
   std::unique_lock<std::mutex> locker(monitoring_buf_mtx);
   
-  // take first of repeated monitoring sends within buffer period
+  // only accept the first of repeated monitoring sends within buffer period
   auto it = monitoring_buf.find(name+subject);
   if(it!=monitoring_buf.end() && (ts - it->second.timestamp)<mon_merge_period_ms) return true;
   
+  // reject if this message is too big to fit in a UDP datagram even with compression
+  size_t compressed_bytes = ZSTD_compressBound(json_data.length()+name.length()+subject.length());
+  if(ZSTD_isError(compressed_bytes) || compressed_bytes > MAX_MSG_SIZE){
+    if(m_verbose) std::cerr<<"Monitoring message is too long!"<<std::endl;
+    return false;
+  }
+  
+  // if appending this message to the batch may put the batch over the UDP datagram size limit,
+  // we need to send current contents first.
+  // actually, let's be more conservative and send before we go over MTU to prevent fragmentation if we can
+  // (this is a little conservative as it assumes each message is compressed independently,
+  // rather than as a batch, which probably gets a better compression ratio.. but we want to avoid
+  // incurring the merge+compress overhead without actually sending)
+  if((compressed_bytes+thread_args.monitoring_batch_bytes) > MSS_SIZE){
+    BatchAndSendMulticast(&thread_args, true, false); // don't try to lock monitoring buffer, we've got it
+  }
+  
   monitoring_buf.emplace(std::piecewise_construct,
                          std::forward_as_tuple(name+subject),
                          std::forward_as_tuple(json_data, subject, name, ts));
   
+  thread_args.monitoring_batch_bytes += compressed_bytes;
+  
   return true;
 }
 
@@ -1062,8 +1096,9 @@ bool Services::SendROOTplotMulticast(const std::string& plot_name, const std::st
                          + ", \"lifetime\":"+std::to_string(lifetime)
                          + ", \"data\":"+ json_data+"}";
   
-  if(cmd_string.length()>MAX_UDP_PACKET_SIZE){
-    if(m_verbose) std::cerr<<"ROOT plot json is too long! Maximum length may be MAX_UDP_PACKET_SIZE bytes"<<std::endl;
+  size_t compressed_bytes = ZSTD_compressBound(cmd_string.length());
+  if(ZSTD_isError(compressed_bytes) || compressed_bytes > MAX_UDP_PACKET_SIZE){
+    if(m_verbose) std::cerr<<"ROOT plot json is too long!"<<std::endl;
     return false;
   }
   
@@ -1175,10 +1210,12 @@ bool Services::LoadConfigAlertFunc(const char* alert, const char* payload){
   tmp.JsonParser(payload);
   uint64_t base_config_id=0;
   uint64_t run_mode_config_id=0;
+  bool testing=false;
   short count = 0;
   
   tmp.Get("Base",base_config_id);
   tmp.Get("RunMode",run_mode_config_id);
+  tmp.Get("Testing", testing);
   
   if(run_mode_config_id!=m_run_mode_config_id || base_config_id!=m_base_config_id){
     
@@ -1194,49 +1231,20 @@ bool Services::LoadConfigAlertFunc(const char* alert, const char* payload){
     (*sc_vars)["NewConfig"]->SetValue(1);
     m_base_config_id = base_config_id;
     m_run_mode_config_id = run_mode_config_id;
+    m_testing = testing;
+    
   }
   
   return true;
   
 }
 
-std::string Services::LoadConfigSlowControlFunc(const char* control){
+std::string Services::LoadConfigSlowControlFunc(const char* payload){
   
-  std::string payload = (*sc_vars)[control]->GetValue<std::string>();
-  Store tmp;
-  tmp.JsonParser(payload);
-  uint64_t base_config_id=0;
-  uint64_t run_mode_config_id=0;
-  
-  short count = 0;
-  std::stringstream ret;
-  
-  
-  tmp.Get("Base",base_config_id);
-  tmp.Get("RunMode",run_mode_config_id);
-  
-  if(run_mode_config_id!=m_run_mode_config_id || base_config_id!=m_base_config_id){
-    
-    while(count<5){
-      if(!GetCachedDeviceConfig(m_local_config, base_config_id, run_mode_config_id, config_devicename)){
-	usleep(100000);
-	count++;
-      }
-      else count=99;
-    }
-
-    if(count==5){
-      ret <<"Failed to load config "<<base_config_id<<":"<<run_mode_config_id;
-      return ret.str();
-    }
-    
-    (*sc_vars)["NewConfig"]->SetValue(1);
-    m_base_config_id = base_config_id;
-    m_run_mode_config_id = run_mode_config_id;
-    ret <<"Loaded config "<<base_config_id<<":"<<run_mode_config_id;
-  }
+  bool success = LoadConfigAlertFunc("",payload);
   
-  return ret.str();
+  if(!success) return std::string("Failed to load config: ")+payload;
+  return std::string("Loaded config: ")+payload;
   
 }
 
@@ -1252,11 +1260,19 @@ void Services::ResetConfigIDs(){
 void Services::BufferThread(Thread_args* args){
   
   BufferThreadArgs* m_args = dynamic_cast<BufferThreadArgs*>(args);
+  BatchAndSendMulticast(m_args, true, true);
+  std::this_thread::sleep_until(m_args->last_send+m_args->multicast_send_period_ms);
+  return;
+  
+}
+
+bool Services::BatchAndSendMulticast(BufferThreadArgs* m_args, bool log_lock, bool mon_lock){
   
   m_args->last_send = std::chrono::steady_clock::now();
   
   m_args->local_merge_buf.clear();
-  std::unique_lock<std::mutex> locker(*m_args->logging_buf_mtx);
+  std::unique_lock<std::mutex> locker(*m_args->logging_buf_mtx, std::defer_lock);
+  if(log_lock) locker.lock();
   
   // merge into a batch
   bool first=true;
@@ -1274,13 +1290,16 @@ void Services::BufferThread(Thread_args* args){
   }
   
   // send
-  if(m_args->local_merge_buf.empty() || m_args->services->SendLog(m_args->local_merge_buf)){
-    m_args->logging_buf->clear(); // FIXME do we not clear on error...? does it depend on the error...?
+  if(!m_args->local_merge_buf.empty()){
+    m_args->services->SendLog(m_args->local_merge_buf);
+    m_args->logging_buf->clear();
+    m_args->logging_batch_bytes = 0;
   }
   
   // repeat for monitoring messages
   m_args->local_merge_buf.clear();
-  locker = std::unique_lock<std::mutex>(*m_args->monitoring_buf_mtx);
+  locker = std::unique_lock<std::mutex>(*m_args->monitoring_buf_mtx, std::defer_lock);
+  if(mon_lock) locker.lock();
   
   first=true;
   for(std::pair<const std::string, MonitoringMsg>& msg : *m_args->monitoring_buf){
@@ -1295,8 +1314,10 @@ void Services::BufferThread(Thread_args* args){
   }
   
   // send
-  if(m_args->local_merge_buf.empty() || m_args->services->SendMonitoringData(m_args->local_merge_buf)){
-    m_args->monitoring_buf->clear(); // FIXME do we not clear on error...? does it depend on the error...?
+  if(!m_args->local_merge_buf.empty()){
+    m_args->services->SendMonitoringData(m_args->local_merge_buf);
+    m_args->monitoring_buf->clear();
+    m_args->monitoring_batch_bytes = 0;
   }
   
   // our other sevice task: prune the alarm buffer.
@@ -1309,12 +1330,7 @@ void Services::BufferThread(Thread_args* args){
     else ++it;
   }
   
-  // release mtx
-  locker.unlock();
-  
-  std::this_thread::sleep_until(m_args->last_send+m_args->multicast_send_period_ms);
-  
-  return;
+  return true;
 }
 
 std::string Services::JsonEscape(std::string s){
@@ -1333,9 +1349,9 @@ std::string Services::GetLocalConfig(){
 
 }
 
-std::string Services::SCLocalConfig(const char* data){
+std::string Services::SCLocalConfig(const char*){
 
-  return "["+std::to_string(m_base_config_id)+","+std::to_string(m_run_mode_config_id)+"]: "+m_local_config;
+  return "base: "+std::to_string(m_base_config_id)+", runmode:"+std::to_string(m_run_mode_config_id)+", config: "+m_local_config;
 
 }
 
@@ -1365,7 +1381,10 @@ bool Services::SetChangeConfigFunc(std::function<bool(std::string)> func){
   
   // 1.
   allgood = AlertSubscribe("ChangeConfig", [this, func](const char*, const char*) -> bool{
+    bool old_testing = sc_vars->GetTesting();
+    sc_vars->SetTesting(m_testing);
     if(func(m_local_config)) return true;
+    sc_vars->SetTesting(old_testing); // on error, revert
     sc_vars->SetWarning(true);
     std::cerr<<"ChangeConfig Error"<<std::endl;
     SendLog("ChangeConfig Error", LogLevel::Error);
@@ -1379,39 +1398,48 @@ bool Services::SetChangeConfigFunc(std::function<bool(std::string)> func){
               [this, func](const char*) -> std::string {
                 (*sc_vars)["Config"]->SetValue((int)ConfigState::ChangeStart);
                 bool ok = func(m_local_config);
+                int new_state;
                 if(!ok){
-		  std::cerr<<"ChangeConfig Error"<<std::endl;
-		  SendLog("ChangeConfig Error", LogLevel::Error);
-		  sc_vars->SetWarning(true);
-		}
-                int new_state = ok ? (int)ConfigState::ChangeEnd : (int)ConfigState::ChangeFail;
+                  new_state = (int)ConfigState::ChangeFail;
+                  std::cerr<<"ChangeConfig Error"<<std::endl;
+                  SendLog("ChangeConfig Error", LogLevel::Error);
+                  sc_vars->SetWarning(true);
+                } else {
+                  new_state = (int)ConfigState::ChangeEnd;
+                  sc_vars->SetTesting(m_testing);
+                }
                 (*sc_vars)["Config"]->SetValue(new_state);
                 (*sc_vars)["NewConfig"]->SetValue(0);
                 return (ok ? "OK" : "Error");
-              },
-              0,
-              false); // this version will not be locked during non-testing runs,
-                      // since it only allows loading configurations in line with the current run type.
+              },  // setter
+              0,  // getter
+              false,  // not locked during non-testing runs, as it only allows loading configurations in line with the current run type
+              false); // not hidden
   
   // 3.
   allgood = allgood &&
   sc_vars->Add("ChangeToConfig",
               COMMAND,
-              [this, func](const char* name) -> std::string {
+              [this, func](const char* payload) -> std::string {
                 (*sc_vars)["Config"]->SetValue((int)ConfigState::ChangeStart);
-                bool ok = func((*sc_vars)[name]->GetValue<std::string>());
+                bool ok = func(payload);
                 int new_state = ok ? (int)ConfigState::ChangeEnd : (int)ConfigState::ChangeFail;
                 (*sc_vars)["Config"]->SetValue(new_state);
+                if(ok && m_local_config.compare(payload) !=0){
+                  m_local_config = payload;
+                  m_base_config_id = 0;
+                  m_run_mode_config_id = 0;
+                }
                 if(!ok){
-		  sc_vars->SetWarning(true);
-		  std::cerr<<"ChangeConfig Error"<<std::endl;
-		  SendLog("ChangeConfig Error", LogLevel::Error);
-		}
+                  sc_vars->SetWarning(true);
+                  std::cerr<<"ChangeConfig Error"<<std::endl;
+                  SendLog("ChangeConfig Error", LogLevel::Error);
+                }
                 return (ok ? "OK" : "Error");
-              },
-              0,
-              true); // this version will be locked during non-testing runs,
-                     // since it allows loading arbitrary configurations
+              },  // setter
+              0,  // getter
+              true,   // locked during non-testing runs as it allows loading arbitrary configurations
+              false); // not hidden
   
   return allgood;
   
@@ -1452,10 +1480,10 @@ bool Services::SetRunStopFunc(std::function<bool()> func){
                 }
                 (*sc_vars)["Config"]->SetValue((int)ConfigState::Unconfigured);
                 return (ok ? "OK" : "Error");
-              },
-              0,
-              false); // this version will not be locked during non-testing runs,
-                      // since it is a fallback control in case the alert gets missed
+              }, // setter
+              0, // getter
+              false,  // not locked during non-testing runs: it is a fallback control in case alert gets missed
+              false); // not hidden
   
   return allgood;
   
@@ -1472,9 +1500,9 @@ bool Services::SetExportConfigFunc(std::function<bool(std::string&)> func){
   allgood = AlertSubscribe("ExportConfig", [this, func](const char*, const char*) -> bool{
     if(func(tmp_config)){
       if(tmp_config.compare(m_local_config) !=0){
-	m_local_config = tmp_config;
-	m_base_config_id = 0;
-	m_run_mode_config_id = 0;
+        m_local_config = tmp_config;
+        m_base_config_id = 0;
+        m_run_mode_config_id = 0;
       }
       return true;
     }
@@ -1502,12 +1530,60 @@ bool Services::SetExportConfigFunc(std::function<bool(std::string&)> func){
                   m_run_mode_config_id = 0;
                 }
                 
-                return tmp_config; 
-              },
-              0,
-              false); // not be locked during non-testing runs, since it does not change configuration
+                return tmp_config;
+              }, // setter
+              0, // getter
+              false, // not be locked during non-testing runs, since it does not change configuration
+              true); // hidden, since it would return JSON and for now, web doesn't support that
   
   
   return allgood;
   
 }
+
+/*
+#include <sys/types.h>
+#include <ifaddrs.h>
+#include <netdb.h>
+
+#include <sys/ioctl.h>
+#include <net/if.h>
+// header size constants
+#include <netinet/ip.h>
+#include <netinet/udp.h>
+
+size_t Services::GetMTU(int f_socket, std::string iface_name){
+    struct ifreq ifr;
+    memset(&ifr, 0, sizeof(ifr));
+    strncpy(ifr.ifr_name, iface_name.c_str(), sizeof(ifr.ifr_name));
+    int f_socket = socket(AF_INET, SOCK_DGRAM, 0);
+    if(ioctl(f_socket.get(), SIOCGIFMTU, &ifr) == 0)
+    {
+        size_t f_mtu_size = ifr.ifr_mtu - sizeof(iphdr) - sizeof(udphdr); // subtract header sizes from MTU to get MSS
+        close(f_socket);
+        return f_mtu_size;
+    }
+    return 0;  // errno set by ioctl()
+}
+
+std::set<std::string> Services::GetInterfaces(){
+    std::set<std::string> ifnames;
+    struct ifaddrs *ifaddr;
+    if(getifaddrs(&ifaddr)==-1){
+        std::cerr<<"getifaddrs couldn't find any network interfaces!"<<std::endl;
+        return ifnames;
+    }
+    for(struct ifaddrs *ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next){
+        
+        if(ifa->ifa_addr == nullptr) continue; // ignore if no IP address; e.g. if interface down/unconfigured
+        
+        int family = ifa->ifa_addr->sa_family;
+        if(family!=AF_INET && family!=AF_INET6) continue; // ignore AP_PACKET/AF_PACKET interfaces
+        
+        ifnames.emplace(ifa->ifa_name);
+    }
+    // we're responsible for freeing the list
+    freeifaddrs(ifaddr);
+    return ifnames;
+}
+*/
diff --git a/src/ServiceDiscovery/Services.h b/src/ServiceDiscovery/Services.h
index 4376b0e..5ae0177 100644
--- a/src/ServiceDiscovery/Services.h
+++ b/src/ServiceDiscovery/Services.h
@@ -7,6 +7,7 @@
 #include <string>
 #include <vector>
 #include <unordered_map>
+#include <set>
 #include <thread>
 #include <chrono>
 #include <functional>
@@ -62,6 +63,8 @@ namespace ToolFramework {
     std::chrono::milliseconds multicast_send_period_ms;
     std::chrono::steady_clock::time_point last_send;
     std::string local_merge_buf;
+    size_t logging_batch_bytes=0;
+    size_t monitoring_batch_bytes=0;
     uint32_t alarm_cooldown_ms;
   };
   
@@ -140,7 +143,11 @@ namespace ToolFramework {
     bool SendLog(std::string& msg);
     bool SendMonitoringData(std::string& msg);
     static void BufferThread(Thread_args* args);
-    std::string SCLocalConfig(const char* data);
+    static bool BatchAndSendMulticast(BufferThreadArgs* m_args, bool log_lock, bool mon_lock);
+    std::string SCLocalConfig(const char*);
+    
+    //size_t GetMTU(std::string iface_name);
+    //std::set<std::string> GetInterfaces();
     
     std::string m_name;
     std::string config_devicename;
@@ -149,6 +156,7 @@ namespace ToolFramework {
     ServicesBackend m_backend_client;
     uint64_t m_base_config_id;
     uint64_t m_run_mode_config_id;
+    bool m_testing;
     std::string m_local_config;
 
     Utilities m_utils;
diff --git a/src/ServiceDiscovery/ServicesBackend.cpp b/src/ServiceDiscovery/ServicesBackend.cpp
index 2c50868..bbaf6fc 100644
--- a/src/ServiceDiscovery/ServicesBackend.cpp
+++ b/src/ServiceDiscovery/ServicesBackend.cpp
@@ -1,9 +1,9 @@
 #include "ServicesBackend.h"
+#include "zstd_helpers.h"
 
 namespace {
-	const uint32_t MAX_UDP_PACKET_SIZE = 655355;
-	const uint32_t MAX_DECOMPRESSED_MSG_SIZE = 655355;
-	const unsigned char ZSTD_MAGIC_BYTES[4] = {0x28,0xB5,0x2F,0xFD}; // ZSTD_MAGICNUMBER from zstd.h BUT REVERSED!
+	const uint32_t MAX_UDP_PACKET_SIZE = 65507; // limit from UDP message length field
+	const uint32_t MAX_DECOMPRESSED_MSG_SIZE = 104857600; // 100MB limit. I'm sure we can spare that much RAM.
 }
 
 using namespace ToolFramework;
@@ -142,7 +142,7 @@ bool ServicesBackend::Initialise(Store &variables_in){
 	
 	if(msg_compression){
 		zstd_cctx = ZSTD_createCCtx();
-		compressed_msg_buf = new char[ZSTD_compressBound(MAX_UDP_PACKET_SIZE)];
+		compressed_msg_buf = new char[MAX_UDP_PACKET_SIZE];
 		zstd_dctx = ZSTD_createDCtx();
 	}
 	
@@ -236,7 +236,6 @@ bool ServicesBackend::InitZMQ(){
 		clt_dlr_socket->setsockopt(ZMQ_RCVTIMEO, clt_dlr_socket_timeout);
 		clt_dlr_socket->setsockopt(ZMQ_IDENTITY, clt_ID.c_str(), clt_ID.length());
 		clt_dlr_socket->setsockopt(ZMQ_IMMEDIATE,1);
-		clt_dlr_socket->setsockopt(ZMQ_LINGER, 10);
 		clt_dlr_socket->bind(std::string("tcp://*:")+std::to_string(clt_dlr_port));
 	} catch(zmq::error_t& e){
 		std::cerr<<"ServicesBackend caught "<<e.what()<<" creating dealer socket on port "<<clt_dlr_port<<std::endl;
@@ -362,9 +361,9 @@ bool ServicesBackend::RegisterServices(){
 void ServicesBackend::Log(std::string msg, int msg_verb, int verbosity){
 	//if(verbosity==-999) verbosity=m_verbosity;
 	// this is normally defined in Tool.h
-	if(m_log) m_log(msg, msg_verb, verbosity);
+	if(m_log) m_log(clt_ID+": "+msg, msg_verb, verbosity);
 	// FIXME we need to be able to turn off all stderr output for cgi scripts...
-	else if(m_verbosity && msg_verb<=verbosity) std::cout<<msg<<std::endl;
+	else if(m_verbosity && msg_verb<=verbosity) std::cout<<clt_ID<<": "<<msg<<std::endl;
 	return;
 }
 
@@ -414,43 +413,28 @@ bool ServicesBackend::SendMulticast(MulticastType type, std::string command, std
 	}
 	
 	// compress the message if applicable
-	msg_to_send=nullptr;
-	std::unique_lock<std::mutex> locker(msg_buf_mtx, std::defer_lock);
-	if(zstd_cctx){
-		locker.lock();
-		bytes_to_send = ZSTD_compressCCtx(zstd_cctx, compressed_msg_buf, MAX_UDP_PACKET_SIZE, command.data(), command.size(), compression_level);
-		if(ZSTD_isError(bytes_to_send)){
-			locker.unlock();
-			std::string errmsg = std::string{"Warning: error compressing multicast message "}+ZSTD_getErrorName(bytes_to_send);
-			Log(errmsg,v_error,m_verbosity);  // XXX should send to MM uncompressed, along with other errors
-			if(err) *err= errmsg;
-		} else {
-			msg_to_send = compressed_msg_buf;
-		}
-	}
-	if(!msg_to_send){
-		msg_to_send = const_cast<char*>(command.c_str());
-		bytes_to_send = command.length();
+	std::unique_lock<std::mutex> locker(msg_buf_mtx);
+	std::pair<const char*, size_t> out = ZstdCompress(zstd_cctx, command.data(), command.size(), compressed_msg_buf, MAX_UDP_PACKET_SIZE, compression_threshold, compression_level);
+	
+	// check we're not going to exceed multicast message size limit
+	if(out.second > MAX_UDP_PACKET_SIZE){
+		// we can't send this on multicast.
+		locker.unlock();
+		std::string errmsg = "Error: message exceeds maximum bytes of "+std::to_string(MAX_UDP_PACKET_SIZE);
+		Log(errmsg,v_error,m_verbosity);  // XXX should send to MM uncompressed, along with other errors
+		if(err) *err= errmsg;
+		return false;
 	}
 	
-	/*
-	// check for listeners...? - seems redundant, multicast can always send
-	zmq::poll(&multicast_poller,1, 0);   // timeout 0 = return immediately...
-	if(multicast_poller.revents & ZMQ_POLLOUT){
-	*/
-		
-		// got a listener - ship it
-		socket_mtx->lock();
-		int cnt = sendto(multicast_socket, msg_to_send, bytes_to_send, 0, (struct sockaddr*)multicast_addr, multicast_addrlen);
-		socket_mtx->unlock();
-		if(cnt < 0){
-			std::string errmsg = "Error sending multicast message: "+std::string{strerror(errno)};
-			Log(errmsg,v_error,m_verbosity);
-			if(err) *err= errmsg; //zmq_strerror(errno);
-			return false;
-		}
-		
-	//}
+	socket_mtx->lock();
+	int cnt = sendto(multicast_socket, out.first, out.second, 0, (struct sockaddr*)multicast_addr, multicast_addrlen);
+	socket_mtx->unlock();
+	if(cnt < 0){
+		std::string errmsg = "Error sending multicast message: "+std::string{strerror(errno)};
+		Log(errmsg,v_error,m_verbosity);
+		if(err) *err= errmsg; //zmq_strerror(errno);
+		return false;
+	}
 	
 	return true;
 }
@@ -488,32 +472,16 @@ bool ServicesBackend::SendCommand(const std::string& topic, const std::string& c
 	}
 	
 	// compress the message if applicable
-	msg_to_send=nullptr;
-	std::unique_lock<std::mutex> locker(msg_buf_mtx, std::defer_lock);
-	if(zstd_cctx){
-		locker.lock();
-		bytes_to_send = ZSTD_compressCCtx(zstd_cctx, compressed_msg_buf, MAX_UDP_PACKET_SIZE, command.data(), command.size(), compression_level);
-		if(ZSTD_isError(bytes_to_send)){
-			locker.unlock();
-			std::string errmsg = std::string{"Warning: error compressing multicast message "}+ZSTD_getErrorName(bytes_to_send);
-			Log(errmsg,v_error,m_verbosity);  // XXX should send to MM uncompressed, along with other errors
-			if(err) *err= errmsg;
-		} else {
-			msg_to_send = compressed_msg_buf;
-		}
-	}
-	if(!msg_to_send){
-		msg_to_send = const_cast<char*>(command.c_str());
-		bytes_to_send = command.length();
-	}
+	std::unique_lock<std::mutex> locker(msg_buf_mtx);
+	std::pair<const char*, size_t> out = ZstdCompress(zstd_cctx, command.data(), command.size(), compressed_msg_buf, MAX_UDP_PACKET_SIZE, compression_threshold, compression_level);
 	
 	// In the case of pub sockets, we specify a 'topic' that the recipient can use with ZMQ_SUBSCRIBE
 	// to filter out particular messages.
 	// In fact it's useful to indicate a topic in all cases, even when the actual message will
 	// (for now) go over a dealer/router combination that cannot filter on the topic.
 	// forward the timeout to the Command (and thus zmq::poll in PollAndSend...) ... is this sensible? HMMMMM FIXME
-	Command cmd{std::string(msg_to_send,bytes_to_send), type, topic,timeout};
-	if(locker.owns_lock()) locker.unlock(); // must check or it throws an exception
+	Command cmd{std::string(out.first,out.second), type, topic,timeout};
+	locker.unlock();
 	
 	// wrap our attempt to get the response in try/catch, just in case?
 	try {
@@ -616,7 +584,7 @@ bool ServicesBackend::DoCommand(Command& cmd, uint32_t timeout_ms){
 		// sending timed out
 		if(cmd.type=='w') ++write_commands_failed;
 		else if(cmd.type=='r') ++read_commands_failed;
-		Log("Timed out sending command "+std::to_string(thismsgid),v_error,m_verbosity);
+		Log("Timed out sending command "+cmd.command+", msg ID: "+std::to_string(thismsgid),v_error,m_verbosity);
 		cmd.success = false;
 		cmd.err = "Timed out sending command";
 		
@@ -753,46 +721,19 @@ bool ServicesBackend::GetNextResponse(){
 	// if we also had further parts, fetch those
 	// if the command failed the response contains an error message (which will only ever be one part)
 	for(unsigned int i=2; i<response.size(); ++i){
-		if(zstd_dctx && response.at(i).size()>4 && std::memcmp(response.at(i).data(),ZSTD_MAGIC_BYTES,4)==0){
-			
-			// compressed - decompress it
-			next_bytes = ZSTD_getFrameContentSize(response.at(i).data(), response.at(i).size());
-			if(next_bytes==ZSTD_CONTENTSIZE_UNKNOWN || next_bytes==ZSTD_CONTENTSIZE_ERROR){
-				// bad response
-				cmd.success = false;
-				cmd.err="Received corrupt zstd response size, zmq reponse size: "+std::to_string(response.at(i).size());
-				Log(cmd.err,v_warning,m_verbosity);
-				break;
-			}
-			if(next_bytes > MAX_DECOMPRESSED_MSG_SIZE){
-				cmd.success = false;
-				cmd.err="Received oversized zstd response: "+std::to_string(next_bytes)+" bytes";
-				Log(cmd.err,v_warning,m_verbosity);
-				break;
-			}
-			decompress_buffer.resize(next_bytes);
-			next_bytes = ZSTD_decompressDCtx(zstd_dctx,(void*)decompress_buffer.data(),next_bytes, response.at(i).data(), response.at(i).size());
-			if(ZSTD_isError(next_bytes)){
-				cmd.success = false;
-				cmd.err=std::string{"zstd error decompressing response: "}+ZSTD_getErrorName(next_bytes);
-				Log(cmd.err,v_warning,m_verbosity);
-				break;
-			}
-			
-			next_part = decompress_buffer.data();
-			
+		
+		bool decompress_ok = ZstdDecompress(zstd_dctx, (char*)response.at(i).data(), response.at(i).size(), cmd.err, MAX_DECOMPRESSED_MSG_SIZE);
+		if(!decompress_ok){
+			cmd.success = false;
+			Log(cmd.err, v_warning, m_verbosity);
+			break;
 		} else {
-			
-			next_bytes = response.at(i).size();
-			next_part = (const char*)response.at(i).data();
-			
+			cmd.response.push_back(std::move(cmd.err));
+			cmd.err = "";
 		}
 		
-		if(cmd.success) cmd.response.emplace_back(next_part, next_bytes);
-		else cmd.err.assign(next_part, next_bytes);
 	}
 	
-	
 	if(m_verbosity>3){
 		std::stringstream logmsg;
 		logmsg << "ServicesBackend::GetNextResponse received response to command "<<message_id_rcvd
@@ -1024,7 +965,7 @@ int ServicesBackend::PollAndReceive(zmq::socket_t* sock, zmq::pollitem_t poll, u
 	try {
 		get_ok = zmq::poll(&poll, 1, timeout);
 	} catch (zmq::error_t& err){
-		if(m_verbosity) std::cerr<<"ServicesBackend::PollAndReceive poller caught "<<err.what()<<std::endl;
+		if(m_verbosity>1) std::cerr<<"ServicesBackend::PollAndReceive poller caught "<<err.what()<<std::endl;
 		get_ok = -1;
 	}
 	if(get_ok<0){
@@ -1080,7 +1021,7 @@ bool ServicesBackend::Ready(int timeout){
 	
 //	printf("ServicesBackend waiting for up to %d ms for connection to middleman\n",timeout);
 	std::chrono::time_point<std::chrono::steady_clock> start = std::chrono::steady_clock::now();
-
+	
 	// poll DEALER socket until it returns we have a listener
 	int ret;
 	try {
@@ -1101,7 +1042,7 @@ bool ServicesBackend::Ready(int timeout){
 //		printf("ServicesBackend::Ready - no one connected (%s)\n", zmq_strerror(errno));
 		return false;
 	}
-	if(m_verbosity) printf("Dealer connected after %ld/%d ms\n", std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - start).count(), timeout);
+	if(m_verbosity>1) printf("Dealer connected after %ld/%d ms\n", std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - start).count(), timeout);
 	
 	// the above doesn't work for the PUB socket as they always report having a listener via POLLOUT.
 	// instead use socket monitor to listen for the connected event.
@@ -1111,7 +1052,7 @@ bool ServicesBackend::Ready(int timeout){
 		printf("ServicesBackend::Ready - pub socket didn't get connected event\n");
 		return false;
 	}
-	if(m_verbosity) printf("Pub connected after %ld/%d ms\n", std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - start).count(), timeout);
+	if(m_verbosity>1) printf("Pub connected after %ld/%d ms\n", std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - start).count(), timeout);
 	// send test pub queries until one gets a reply - this may be redundant
 	std::string resp;
 	std::chrono::milliseconds time_left = std::chrono::duration_cast<std::chrono::milliseconds>(end-std::chrono::steady_clock::now());
@@ -1120,7 +1061,7 @@ bool ServicesBackend::Ready(int timeout){
 		if(!SendCommand("W_QUERY"," select now()", &resp, std::min(decltype(time_left.count())(500), time_left.count()))){
 			if(m_verbosity) std::cerr<<"timeout waiting on test pub"<<std::endl;
 		} else {
-			if(m_verbosity) std::cout<<"test pub repsonse: "<<resp<<std::endl;
+			if(m_verbosity>1) std::cout<<"test pub repsonse: "<<resp<<std::endl;
 			return true;
 		}
 		time_left = std::chrono::duration_cast<std::chrono::milliseconds>(end-std::chrono::steady_clock::now());
@@ -1139,7 +1080,7 @@ void ServicesBackend::CheckSocketEvents(int timeout_ms){
 			if(tmp.more()){
 				monitor_socket->recv(&tmp2);
 			} else {
-				if(m_verbosity) std::cerr<<"MonitorSocket got only one part?"<<std::endl;
+				if(m_verbosity>1) std::cerr<<"MonitorSocket got only one part?"<<std::endl;
 				return;
 			}
 			uint16_t event_id;
diff --git a/src/ServiceDiscovery/ServicesBackend.h b/src/ServiceDiscovery/ServicesBackend.h
index a1bd796..1a51494 100644
--- a/src/ServiceDiscovery/ServicesBackend.h
+++ b/src/ServiceDiscovery/ServicesBackend.h
@@ -142,9 +142,6 @@ class ServicesBackend {
 	int v_message=2;
 	int v_debug=3;
 	int get_ok;
-	boost::posix_time::time_duration elapsed_time;
-	std::string hostname;   // for printing with stats
-	int execute_iterations=0;
 	
 	// ZMQ socket identities - we really only need the reply socket one
 	// since that's the one the middleman needs to know to send replies back
@@ -159,10 +156,8 @@ class ServicesBackend {
 	ZSTD_CCtx* zstd_cctx=nullptr;
 	ZSTD_DCtx* zstd_dctx=nullptr;
 	int compression_level=1;
+	size_t compression_threshold=50;
 	char* compressed_msg_buf=nullptr;
-	std::string decompress_buffer;
-	size_t next_bytes;
-	const char* next_part;
 	std::mutex msg_buf_mtx; // we'll share this buffer, since it's kind of a large buffer to keep allocating for every call
 	// and we shouldn't be spamming the Send calls so fast mutex contention becomes a problem
 	
diff --git a/src/ServiceDiscovery/SlowControlCollection.cpp b/src/ServiceDiscovery/SlowControlCollection.cpp
index 206e1de..f44a9ae 100644
--- a/src/ServiceDiscovery/SlowControlCollection.cpp
+++ b/src/ServiceDiscovery/SlowControlCollection.cpp
@@ -1,4 +1,5 @@
 #include <SlowControlCollection.h>
+#include "zstd_helpers.h"
 
 using namespace ToolFramework;
 
@@ -12,9 +13,6 @@ SlowControlCollectionThread_args::SlowControlCollectionThread_args(){
   alert_functions_mutex=0;
   SC_vars=0;
   
-  m_pub = 0;
-  pub_monitor_socket = 0;
-  pub_connected_mtx = 0;
   
 }
 
@@ -55,6 +53,9 @@ SlowControlCollection::SlowControlCollection(){
   Add("NewConfig",SlowControlElementType(INFO),0,0,false,false);
   SC_vars["NewConfig"]->SetValue(0);
   
+  zstd_cctx = ZSTD_createCCtx();
+  zstd_dctx = ZSTD_createDCtx();
+  
 }
 
 SlowControlCollection::~SlowControlCollection(){
@@ -289,10 +290,16 @@ void SlowControlCollection::Thread(Thread_args* arg){
       return;
     }
     
-    std::istringstream iss(static_cast<char*>(message.data()));
+    std::string payload;
+    std::unique_lock<std::mutex> locker(args->SCC->zstd_dctx_mtx);
+    if(!ZstdDecompress(args->SCC->zstd_dctx, (char*)message.data(), message.size(), payload, args->SCC->MAX_DECOMPRESSED_SIZE)){
+      std::cerr<<"failed to decompress slow control message: "<<payload<<std::endl;
+      return;
+    }
+    locker.unlock();
+    
     Store tmp;
-    //printf("iss=%s\n",iss.str().c_str());
-    tmp.JsonParser(iss.str());
+    tmp.JsonParser(payload);
     //tmp.Print();
     if(!tmp.Has("msg_value")){
       std::cerr<<"error: Poorly formatted slowcontrol input [no msg_value]"<<std::endl;
@@ -371,13 +378,16 @@ void SlowControlCollection::Thread(Thread_args* arg){
     std::string tmp2="";
     rr>>tmp2;
     //printf("reply message is= %s \n",tmp2.c_str());
-    zmq::message_t send(tmp2.length()+1);
-    snprintf ((char *) send.data(), tmp2.length()+1 , "%s" ,tmp2.c_str()) ;
     
+    locker = std::unique_lock<std::mutex>(args->SCC->zstd_cctx_mtx);
+    std::string compress_buffer;
+    std::pair<const char*, size_t> output = ZstdCompress(args->SCC->zstd_cctx, tmp2.data(), tmp2.size(), compress_buffer);
+    zmq::message_t zmsg(output.second);
+    memcpy(zmsg.data(), output.first, output.second);
     
     bool tmp_ok = args->sock->send(identity, ZMQ_SNDMORE);
     if(tmp_ok) tmp_ok = tmp_ok && args->sock->send(blank, ZMQ_SNDMORE);
-    if(tmp_ok) tmp_ok= tmp_ok && args->sock->send(send);
+    if(tmp_ok) tmp_ok= tmp_ok && args->sock->send(zmsg);
     if(!tmp_ok){
       std::cerr<<"failed to send '"<<reply<<"' to '"<<key<<"'"<<std::endl;
       return;
@@ -405,27 +415,27 @@ void SlowControlCollection::Thread(Thread_args* arg){
       ok = args->sub->recv(&message);
       if(ok==0){
         // FIXME this case should be handled! what do we do?
-        std::cerr<<"failed to receive alert payload!"<<std::endl;
+        std::cerr<<"failed to receive "<<iss.str() << " alert payload!"<<std::endl;
+        return;
+      }
+      if(!ZstdDecompress(args->SCC->zstd_dctx, (char*)message.data(), message.size(), payload)){
+        std::cerr<<"failed to decompress "<<iss.str() << " alert payload!"<<std::endl;
+        return;
       }
-      payload.resize(message.size(),'\0');
-      memcpy((void*)payload.data(),message.data(),message.size());
       has_data=true;
     }
     
     //int a=0;
     while(message.more()){
       
-      args->sub->recv(&message);
+      args->sub->recv(&message); // FIXME do we want any warnings or handling here?
       //memcpy((void*)payload.data(),message.data(),message.size());
       //a++;
     }
     
-    //std::cout<<iss.str()<<std::endl;
-    args->alert_functions_mutex->lock();
     if(iss.str() == "LoadConfig") (*args->SC_vars)["Config"]->SetValue((int)ConfigState::LoadStart);
     else if(iss.str() == "ChangeConfig"){
        if((*args->SC_vars)["NewConfig"]->GetValue<int>() == 0){
-         args->alert_functions_mutex->unlock();
          return;
        }
       (*args->SC_vars)["Config"]->SetValue((int)ConfigState::ChangeStart);
@@ -433,6 +443,7 @@ void SlowControlCollection::Thread(Thread_args* arg){
     
     
     bool error = false;
+    std::unique_lock<std::mutex> locker(*args->alert_functions_mutex);
     
     if(args->alert_functions->count(iss.str())){
       if(has_data){
@@ -487,9 +498,6 @@ void SlowControlCollection::Thread(Thread_args* arg){
       
     }
     
- 
-    args->alert_functions_mutex->unlock();
-    
     //if(payload!=nullptr) free(payload);
   }
   
@@ -592,8 +600,12 @@ bool SlowControlCollection::AlertSend(std::string alert, std::string payload){
   // if we didn't return, we have a payload as well
   bool ok = m_pub->send(message, ZMQ_SNDMORE);
   if(!ok) return false; // err: "zmq send "+zmq_strerror(errno)
-  zmq::message_t message2(payload.length()+1);
-  snprintf((char*) message2.data(), payload.length()+1, "%s", payload.c_str());
+  
+  std::unique_lock<std::mutex>locker(args->SCC->zstd_cctx_mtx);
+  std::string compress_buffer;
+  std::pair<const char*, size_t> output = ZstdCompress(args->SCC->zstd_cctx, payload.data(), payload.size(), compress_buffer);
+  zmq::message_t message2(output.second);
+  memcpy(message2.data(), output.first, output.second);
   return m_pub->send(message2);  // err: "zmq send "+zmq_strerror(errno)
   
 }
@@ -646,8 +658,8 @@ void SlowControlCollection::Unpack(std::string in, std::map<std::string, std::st
           //tmp<<counter;
           Store tmp;
           tmp.JsonParser(it->second.substr(first,i-first+1));
-          out[header+tmp.Get<std::string>("name")]=it->second.substr(first,i-first+1);          
-          //          counter++;
+          out[header+tmp.Get<std::string>("name")]=it->second.substr(first,i-first+1);
+          //counter++;
         }
         
       }
@@ -784,6 +796,14 @@ void SlowControlCollection::TestingDisable(){
   m_testing=false;
 }
 
+void SlowControlCollection::SetTesting(bool testing){
+  m_testing=testing;
+}
+
+bool SlowControlCollection::GetTesting(){
+  return m_testing;
+}
+
 // non-blocking function to check if alert send socket is connected
 void SlowControlCollection::CheckReady(zmq::socket_t**& mon_sock_ptr, std::timed_mutex* connected_mtx, zmq::socket_t* m_pub){
   // FIXME we could extend this like the ServicesBackend to wait until all sockets are ready, not just the alert send
@@ -868,3 +888,5 @@ void SlowControlCollection::ClearState(){
   SC_vars["State"]->SetValue(m_state);
   return;
 }
+
+
diff --git a/src/ServiceDiscovery/SlowControlCollection.h b/src/ServiceDiscovery/SlowControlCollection.h
index c2a43b1..be7411e 100644
--- a/src/ServiceDiscovery/SlowControlCollection.h
+++ b/src/ServiceDiscovery/SlowControlCollection.h
@@ -5,6 +5,8 @@
 #include <zmq.hpp>
 #include "DAQUtilities.h"
 #include <functional>
+#include <mutex>
+#include <zstd.h>
 
 namespace ToolFramework{
 
@@ -61,6 +63,8 @@ namespace ToolFramework{
     std::string PrintJSON();
     void Stop();
     void JsonParser(std::string json);
+    void SetTesting(bool testing);
+    bool GetTesting();
     void TestingEnable();
     void TestingDisable();
     bool Ready(int timeout_ms);
@@ -81,6 +85,15 @@ namespace ToolFramework{
     std::map<std::string, AlertFunction>  m_alert_functions;
     std::mutex m_alert_functions_mutex;
     
+    ZSTD_CCtx* zstd_cctx;
+    std::mutex zstd_cctx_mtx;
+    ZSTD_DCtx* zstd_dctx;
+    std::mutex zstd_dctx_mtx;
+    int zstd_compression_level=1;
+    uint32_t COMPRESS_THRESHOLD=50; // compress any send messages > this many bytes
+    uint32_t MAX_DECOMPRESSED_SIZE=104857600; // refuse to decompress messages that will exceed this size once decompressed
+    // defautl 100MB; I'm sure we can spare that much RAM.
+    
     DAQUtilities* m_util;
     zmq::context_t* m_context;
     zmq::socket_t* m_pub;
diff --git a/src/ServiceDiscovery/zstd.h b/src/ServiceDiscovery/zstd.h
index 8504694..65fe248 100644
--- a/src/ServiceDiscovery/zstd.h
+++ b/src/ServiceDiscovery/zstd.h
@@ -143,6 +143,8 @@ ZSTDLIB_API const char* ZSTD_versionString(void);
 #define ZSTD_MAGIC_DICTIONARY       0xEC30A437    /* valid since v0.7.0 */
 #define ZSTD_MAGIC_SKIPPABLE_START  0x184D2A50    /* all 16 values, from 0x184D2A50 to 0x184D2A5F, signal the beginning of a skippable frame */
 #define ZSTD_MAGIC_SKIPPABLE_MASK   0xFFFFFFF0
+const unsigned char ZSTD_MAGIC_BYTES[4] = {0x28,0xB5,0x2F,0xFD}; // ZSTD_MAGICNUMBER from zstd.h BUT REVERSED!
+// used to check if a byte array is compressed
 
 #define ZSTD_BLOCKSIZELOG_MAX  17
 #define ZSTD_BLOCKSIZE_MAX     (1<<ZSTD_BLOCKSIZELOG_MAX)
diff --git a/src/ServiceDiscovery/zstd_helpers.cpp b/src/ServiceDiscovery/zstd_helpers.cpp
new file mode 100644
index 0000000..07457db
--- /dev/null
+++ b/src/ServiceDiscovery/zstd_helpers.cpp
@@ -0,0 +1,109 @@
+#include "zstd_helpers.h"
+#include <cstring>
+#include <iostream>
+
+namespace ToolFramework {
+
+std::pair<const char*, size_t>  ZstdCompress(ZSTD_CCtx* zstd_cctx, const char* msg, size_t msg_len, char* compress_buffer, size_t MAX_COMPRESSED_SIZE, std::string* compress_buffer2, size_t COMPRESS_THRESHOLD, int zstd_compression_level){
+	std::string errmsg="";
+	size_t bytes_to_send = msg_len;
+	
+	if(msg_len<COMPRESS_THRESHOLD){
+		goto send_uncompressed;
+	}
+	
+	bytes_to_send = ZSTD_compressBound(msg_len); // this can fail too!
+	if(ZSTD_isError(bytes_to_send)){
+		errmsg = std::string{"Warning: error calculating compressed size: "}+ZSTD_getErrorName(bytes_to_send);
+		goto send_uncompressed;
+	}
+	
+	if(compress_buffer2!=nullptr){
+		compress_buffer2->resize(bytes_to_send);
+		compress_buffer = (char*)compress_buffer2->data();
+		MAX_COMPRESSED_SIZE = bytes_to_send;
+	} else if(compress_buffer!=nullptr && bytes_to_send>MAX_COMPRESSED_SIZE){
+		errmsg = "Warning: compressed size "+std::to_string(bytes_to_send)+" exceeds compression buffer size "+std::to_string(MAX_COMPRESSED_SIZE);
+		goto send_uncompressed;
+	}
+	
+	bytes_to_send = ZSTD_compressCCtx(zstd_cctx, (void*)compress_buffer, MAX_COMPRESSED_SIZE, msg, msg_len, zstd_compression_level);
+	if(ZSTD_isError(bytes_to_send)){
+		errmsg = std::string{"Warning: error compressing message "}+ZSTD_getErrorName(bytes_to_send);
+		goto send_uncompressed;
+	}
+	
+	return std::pair<const char*, size_t>{compress_buffer, bytes_to_send};
+	
+	send_uncompressed:
+	if(!errmsg.empty())std::cerr << errmsg << std::endl; // FIXME is this appropriate?
+	return std::pair<const char*, size_t>{msg, msg_len};
+}
+
+
+// accept compression buffer char array, return pointer and size of data to send
+std::pair<const char*, size_t>  ZstdCompress(ZSTD_CCtx* zstd_cctx, const char* msg, size_t msg_len, char* compress_buffer, size_t MAX_COMPRESSED_SIZE, size_t COMPRESS_THRESHOLD, int zstd_compression_level){
+	return ZstdCompress(zstd_cctx, msg, msg_len, compress_buffer, MAX_COMPRESSED_SIZE, 0, COMPRESS_THRESHOLD, zstd_compression_level);
+}
+
+// accept compression buffer string, return pointer and size of data to send
+std::pair<const char*, size_t>  ZstdCompress(ZSTD_CCtx* zstd_cctx, const char* msg, size_t msg_len, std::string& compress_buffer, size_t COMPRESS_THRESHOLD, int zstd_compression_level){
+	return ZstdCompress(zstd_cctx, msg, msg_len, 0, 0, &compress_buffer, COMPRESS_THRESHOLD, zstd_compression_level);
+}
+
+/*
+// accept compression buffer char array, return zmq::message_t
+zmq::message_t ZstdCompress(ZSTD_CCtx* zstd_cctx, const char* msg, size_t msg_len, char* compress_buffer, size_t MAX_COMPRESSED_SIZE, size_t COMPRESS_THRESHOLD, int zstd_compression_level){
+	
+	std::pair<const char*, size_t> output = ZstdCompress(zstd_cctx, msg, msg_len, compress_buffer, MAX_COMPRESSED_SIZE, nullptr, COMPRESS_THRESHOLD, zstd_compression_level);
+	
+	zmq::message_t zmsg(output.second);
+	memcpy(zmsg.data(), output.first, output.second);
+	return zmsg;
+	
+}
+
+// accept compression buffer string, return zmq::message_t
+zmq::message_t ZstdCompress(ZSTD_CCtx* zstd_cctx, const char* msg, size_t msg_len, std::string& compress_buffer, size_t COMPRESS_THRESHOLD, int zstd_compression_level){
+	
+	std::pair<const char*, size_t> output = ZstdCompress(zstd_cctx, msg, msg_len, 0, 0, compress_buffer, COMPRESS_THRESHOLD, zstd_compression_level);
+	
+	zmq::message_t zmsg(output.second);
+	memcpy(zmsg.data(), output.first, output.second);
+	return zmsg;
+	
+}
+*/
+
+//////////////////////////////////////////////////
+
+bool ZstdDecompress(ZSTD_DCtx* zstd_dctx, const char* msg, size_t msg_len, std::string& decompress_buffer, size_t MAX_DECOMPRESSED_SIZE){
+	if(msg_len>sizeof(ZSTD_MAGIC_BYTES) && std::memcmp(msg,ZSTD_MAGIC_BYTES,sizeof(ZSTD_MAGIC_BYTES))==0){
+		size_t decompressed_bytes = ZSTD_getFrameContentSize(msg, msg_len);
+		if(decompressed_bytes==ZSTD_CONTENTSIZE_UNKNOWN || decompressed_bytes==ZSTD_CONTENTSIZE_ERROR){
+			// bad response
+			decompress_buffer = std::string{"Received corrupt zstd message "}+ZSTD_getErrorName(decompressed_bytes);
+			return false;
+		}
+		if(decompressed_bytes > MAX_DECOMPRESSED_SIZE){
+			decompress_buffer = "Compressed message with oversized payload: "+std::to_string(decompressed_bytes)+" bytes";
+			return false;
+		}
+		decompress_buffer.resize(decompressed_bytes);
+		decompressed_bytes = ZSTD_decompressDCtx(zstd_dctx,(void*)decompress_buffer.data(),decompressed_bytes, msg, msg_len);
+		if(ZSTD_isError(decompressed_bytes)){
+			decompress_buffer = std::string{"zstd error decompressing response: "}+ZSTD_getErrorName(decompressed_bytes);
+			return false;
+		}
+	} else {
+		// message not compressed
+		decompress_buffer.assign(msg, msg_len);
+	}
+	return true;
+}
+
+bool ZstdDecompress(ZSTD_DCtx* zstd_dctx, const std::string& msg, std::string& decompress_buffer, size_t MAX_DECOMPRESSED_SIZE){
+	return ZstdDecompress(zstd_dctx, msg.data(), msg.length(), decompress_buffer, MAX_DECOMPRESSED_SIZE);
+}
+
+}
diff --git a/src/ServiceDiscovery/zstd_helpers.h b/src/ServiceDiscovery/zstd_helpers.h
new file mode 100644
index 0000000..1128cfb
--- /dev/null
+++ b/src/ServiceDiscovery/zstd_helpers.h
@@ -0,0 +1,35 @@
+#ifndef ZSTD_HELPERS
+#define ZSTD_HELPERS
+
+#include "zmq.hpp"
+#include "zstd.h"
+#include <string>
+#include <utility>
+
+namespace ToolFramework {
+
+// we could avoid the need for all these splits if we supported c++17 std::string_view 🙃️
+
+// compression - implementation
+std::pair<const char*, size_t>  ZstdCompress(ZSTD_CCtx* zstd_cctx, const char* msg, size_t msg_len, char* compress_buffer, size_t MAX_COMPRESSED_SIZE, std::string* compress_buffer2, size_t COMPRESS_THRESHOLD, int zstd_compression_level); // don't compress anything less than 50B by default
+
+// compression wrapper - char array compression buffer
+std::pair<const char*, size_t>  ZstdCompress(ZSTD_CCtx* zstd_cctx, const char* msg, size_t msg_len, char* compress_buffer, size_t MAX_COMPRESSED_SIZE, size_t COMPRESS_THRESHOLD=50, int zstd_compression_level=1);
+
+// compression wrapper - string compression buffer
+std::pair<const char*, size_t>  ZstdCompress(ZSTD_CCtx* zstd_cctx, const char* msg, size_t msg_len, std::string& compress_buffer, size_t COMPRESS_THRESHOLD=50, int zstd_compression_level=1);
+
+/*
+zmq::message_t ZstdCompress(ZSTD_CCtx* zstd_cctx, const char* msg, size_t msg_len, char* compress_buffer, size_t MAX_COMPRESSED_SIZE, size_t COMPRESS_THRESHOLD, int zstd_compression_level);
+
+zmq::message_t ZstdCompress(ZSTD_CCtx* zstd_cctx, const char* msg, size_t msg_len, std::string& compress_buffer, size_t COMPRESS_THRESHOLD, int zstd_compression_level);
+*/
+
+// decompression
+bool ZstdDecompress(ZSTD_DCtx* zstd_dctx, const char* msg, size_t msg_len, std::string& decompress_buffer, size_t MAX_DECOMPRESSED_SIZE=104857600);  // don't decompress anything that will expand to > 100MB by default
+
+bool ZstdDecompress(ZSTD_DCtx* zstd_dctx, const std::string& msg, std::string& decompress_buffer, size_t MAX_DECOMPRESSED_SIZE=104857600);  // don't decompress anything that will expand to > 100MB by default
+
+}
+
+#endif