diff --git a/src/fne/network/TrafficNetwork.h b/src/fne/network/TrafficNetwork.h
index 48c73a99..77389f0d 100644
--- a/src/fne/network/TrafficNetwork.h
+++ b/src/fne/network/TrafficNetwork.h
@@ -87,16 +87,16 @@ namespace network
         STATE_NXDN = 3U,        //!< NXDN
     };
 
-    #define INFLUXDB_ERRSTR_DISABLED_SRC_RID "disabled source RID"
-    #define INFLUXDB_ERRSTR_DISABLED_DST_RID "disabled destination RID"
-    #define INFLUXDB_ERRSTR_INV_TALKGROUP "illegal/invalid talkgroup"
-    #define INFLUXDB_ERRSTR_DISABLED_TALKGROUP "disabled talkgroup"
-    #define INFLUXDB_ERRSTR_ENC_TALKGROUP_CLR "encrypted talkgroup with clear traffic"
-    #define INFLUXDB_ERRSTR_CLR_TALKGROUP_ENC "clear talkgroup with encrypted traffic"
-    #define INFLUXDB_ERRSTR_INV_SLOT "invalid slot for talkgroup"
-    #define INFLUXDB_ERRSTR_RID_NOT_PERMITTED "RID not permitted for talkgroup"
-    #define INFLUXDB_ERRSTR_ILLEGAL_RID_ACCESS "illegal/unknown RID attempted access"
-    #define INFLUXDB_ERRSTR_CALL_NOT_PERMITTED "call not permitted for talkgroup"
+    #define DB_ERRSTR_DISABLED_SRC_RID "disabled source RID"
+    #define DB_ERRSTR_DISABLED_DST_RID "disabled destination RID"
+    #define DB_ERRSTR_INV_TALKGROUP "illegal/invalid talkgroup"
+    #define DB_ERRSTR_DISABLED_TALKGROUP "disabled talkgroup"
+    #define DB_ERRSTR_ENC_TALKGROUP_CLR "encrypted talkgroup with clear traffic"
+    #define DB_ERRSTR_CLR_TALKGROUP_ENC "clear talkgroup with encrypted traffic"
+    #define DB_ERRSTR_INV_SLOT "invalid slot for talkgroup"
+    #define DB_ERRSTR_RID_NOT_PERMITTED "RID not permitted for talkgroup"
+    #define DB_ERRSTR_ILLEGAL_RID_ACCESS "illegal/unknown RID attempted access"
+    #define DB_ERRSTR_CALL_NOT_PERMITTED "call not permitted for talkgroup"
 
     const uint32_t MAX_HARD_CONN_CAP = 250U;
     const size_t PEER_STATE_LOCK_STRIPES = 256U;
diff --git a/src/fne/network/callhandler/TagAnalogData.cpp b/src/fne/network/callhandler/TagAnalogData.cpp
index 00b58bcc..f30e7559 100644
--- a/src/fne/network/callhandler/TagAnalogData.cpp
+++ b/src/fne/network/callhandler/TagAnalogData.cpp
@@ -724,10 +724,10 @@ bool TagAnalogData::validate(uint32_t peerId, data::NetData& data, uint32_t stre
     if (!rid.radioDefault()) {
         if (!rid.radioEnabled()) {
             // report error event to metrics
-            TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(INFLUXDB_ERRSTR_DISABLED_SRC_RID));
+            TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(DB_ERRSTR_DISABLED_SRC_RID));
 
             if (m_network->m_logDenials)
-                LogError(LOG_ANALOG, INFLUXDB_ERRSTR_DISABLED_SRC_RID ", peer = %u, srcId = %u, dstId = %u", peerId, data.getSrcId(), data.getDstId());
+                LogError(LOG_ANALOG, DB_ERRSTR_DISABLED_SRC_RID ", peer = %u, srcId = %u, dstId = %u", peerId, data.getSrcId(), data.getDstId());
 
             // report In-Call Control to the peer sending traffic
             m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_ANALOG, NET_ICC::REJECT_TRAFFIC, data.getDstId());
@@ -751,10 +751,10 @@ bool TagAnalogData::validate(uint32_t peerId, data::NetData& data, uint32_t stre
     std::vector<uint32_t> rejectedStreams = m_rejectedCallStreams[data.getDstId()];
     if (std::find(rejectedStreams.begin(), rejectedStreams.end(), streamId) != rejectedStreams.end()) {
         // report error event to metrics
-        TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(INFLUXDB_ERRSTR_CALL_NOT_PERMITTED));
+        TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(DB_ERRSTR_CALL_NOT_PERMITTED));
 
         if (m_network->m_logDenials)
-            LogError(LOG_ANALOG, INFLUXDB_ERRSTR_CALL_NOT_PERMITTED ", peer = %u, srcId = %u, dstId = %u", peerId, data.getSrcId(), data.getDstId());
+            LogError(LOG_ANALOG, DB_ERRSTR_CALL_NOT_PERMITTED ", peer = %u, srcId = %u, dstId = %u", peerId, data.getSrcId(), data.getDstId());
 
         m_rejectedCallStreams.unlock();
 
@@ -771,10 +771,10 @@ bool TagAnalogData::validate(uint32_t peerId, data::NetData& data, uint32_t stre
         if (!rid.radioDefault()) {
             if (!rid.radioEnabled()) {
                 // report error event to metrics
-                TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(INFLUXDB_ERRSTR_DISABLED_DST_RID));
+                TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(DB_ERRSTR_DISABLED_DST_RID));
 
                 if (m_network->m_logDenials)
-                    LogError(LOG_ANALOG, INFLUXDB_ERRSTR_DISABLED_DST_RID ", peer = %u, srcId = %u, dstId = %u", peerId, data.getSrcId(), data.getDstId());
+                    LogError(LOG_ANALOG, DB_ERRSTR_DISABLED_DST_RID ", peer = %u, srcId = %u, dstId = %u", peerId, data.getSrcId(), data.getDstId());
 
                 return false;
             }
@@ -784,10 +784,10 @@ bool TagAnalogData::validate(uint32_t peerId, data::NetData& data, uint32_t stre
             // report call error
             if (m_network->m_rejectUnknownRID) {
                 // report error event to metrics
-                TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(INFLUXDB_ERRSTR_ILLEGAL_RID_ACCESS));
+                TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(DB_ERRSTR_ILLEGAL_RID_ACCESS));
 
                 if (m_network->m_logDenials)
-                    LogWarning(LOG_ANALOG, INFLUXDB_ERRSTR_ILLEGAL_RID_ACCESS ", srcId = %u, dstId = %u", data.getSrcId(), data.getDstId());
+                    LogWarning(LOG_ANALOG, DB_ERRSTR_ILLEGAL_RID_ACCESS ", srcId = %u, dstId = %u", data.getSrcId(), data.getDstId());
 
                 // report In-Call Control to the peer sending traffic
                 m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_ANALOG, NET_ICC::REJECT_TRAFFIC, data.getDstId());
@@ -801,10 +801,10 @@ bool TagAnalogData::validate(uint32_t peerId, data::NetData& data, uint32_t stre
         lookups::TalkgroupRuleGroupVoice tg = m_network->m_tidLookup->find(data.getDstId());
         if (tg.isInvalid()) {
             // report error event to metrics
-            TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(INFLUXDB_ERRSTR_INV_TALKGROUP));
+            TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(DB_ERRSTR_INV_TALKGROUP));
 
             if (m_network->m_logDenials)
-                LogError(LOG_ANALOG, INFLUXDB_ERRSTR_INV_TALKGROUP ", peer = %u, srcId = %u, dstId = %u", peerId, data.getSrcId(), data.getDstId());
+                LogError(LOG_ANALOG, DB_ERRSTR_INV_TALKGROUP ", peer = %u, srcId = %u, dstId = %u", peerId, data.getSrcId(), data.getDstId());
 
             // report In-Call Control to the peer sending traffic
             m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_ANALOG, NET_ICC::REJECT_TRAFFIC, data.getDstId());
@@ -814,10 +814,10 @@ bool TagAnalogData::validate(uint32_t peerId, data::NetData& data, uint32_t stre
             // analog doesn't support strapping, so if the TG is strapped, reject the call
             if (tg.config().strapping() == lookups::TG_STRAPPING_STRAPPED) {
                 // report error event to metrics
-                TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(INFLUXDB_ERRSTR_CLR_TALKGROUP_ENC));
+                TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(DB_ERRSTR_CLR_TALKGROUP_ENC));
 
                 if (m_network->m_logDenials)
-                    LogError(LOG_ANALOG, INFLUXDB_ERRSTR_CLR_TALKGROUP_ENC ", peer = %u, srcId = %u, dstId = %u", peerId, data.getSrcId(), data.getDstId());
+                    LogError(LOG_ANALOG, DB_ERRSTR_CLR_TALKGROUP_ENC ", peer = %u, srcId = %u, dstId = %u", peerId, data.getSrcId(), data.getDstId());
 
                 // report In-Call Control to the peer sending traffic
                 m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_ANALOG, NET_ICC::REJECT_TRAFFIC, data.getDstId());
@@ -839,10 +839,10 @@ bool TagAnalogData::validate(uint32_t peerId, data::NetData& data, uint32_t stre
         // fail call if the reject flag is set
         if (rejectUnknownBadCall) {
             // report error event to metrics
-            TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(INFLUXDB_ERRSTR_ILLEGAL_RID_ACCESS));
+            TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(DB_ERRSTR_ILLEGAL_RID_ACCESS));
 
             if (m_network->m_logDenials)
-                LogWarning(LOG_ANALOG, INFLUXDB_ERRSTR_ILLEGAL_RID_ACCESS ", srcId = %u, dstId = %u", data.getSrcId(), data.getDstId());
+                LogWarning(LOG_ANALOG, DB_ERRSTR_ILLEGAL_RID_ACCESS ", srcId = %u, dstId = %u", data.getSrcId(), data.getDstId());
 
             // report In-Call Control to the peer sending traffic
             m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_ANALOG, NET_ICC::REJECT_TRAFFIC, data.getDstId());
@@ -852,10 +852,10 @@ bool TagAnalogData::validate(uint32_t peerId, data::NetData& data, uint32_t stre
         // is the TGID active?
         if (!tg.config().active()) {
             // report error event to metrics
-            TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(INFLUXDB_ERRSTR_DISABLED_TALKGROUP));
+            TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(DB_ERRSTR_DISABLED_TALKGROUP));
 
             if (m_network->m_logDenials)
-                LogError(LOG_ANALOG, INFLUXDB_ERRSTR_DISABLED_TALKGROUP ", peer = %u, srcId = %u, dstId = %u", peerId, data.getSrcId(), data.getDstId());
+                LogError(LOG_ANALOG, DB_ERRSTR_DISABLED_TALKGROUP ", peer = %u, srcId = %u, dstId = %u", peerId, data.getSrcId(), data.getDstId());
 
             // report In-Call Control to the peer sending traffic
             m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_ANALOG, NET_ICC::REJECT_TRAFFIC, data.getDstId());
@@ -870,10 +870,10 @@ bool TagAnalogData::validate(uint32_t peerId, data::NetData& data, uint32_t stre
                 std::vector<uint32_t> permittedRIDs = tg.config().permittedRIDs();
                 if (std::find(permittedRIDs.begin(), permittedRIDs.end(), data.getSrcId()) == permittedRIDs.end()) {
                     // report error event to metrics
-                    TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(INFLUXDB_ERRSTR_RID_NOT_PERMITTED));
+                    TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(DB_ERRSTR_RID_NOT_PERMITTED));
 
                     if (m_network->m_logDenials)
-                        LogError(LOG_ANALOG, INFLUXDB_ERRSTR_RID_NOT_PERMITTED ", peer = %u, srcId = %u, dstId = %u", peerId, data.getSrcId(), data.getDstId());
+                        LogError(LOG_ANALOG, DB_ERRSTR_RID_NOT_PERMITTED ", peer = %u, srcId = %u, dstId = %u", peerId, data.getSrcId(), data.getDstId());
 
                     // report In-Call Control to the peer sending traffic
                     m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_ANALOG, NET_ICC::REJECT_TRAFFIC, data.getDstId());
diff --git a/src/fne/network/callhandler/TagDMRData.cpp b/src/fne/network/callhandler/TagDMRData.cpp
index f55217a0..b515a5e8 100644
--- a/src/fne/network/callhandler/TagDMRData.cpp
+++ b/src/fne/network/callhandler/TagDMRData.cpp
@@ -1159,10 +1159,10 @@ bool TagDMRData::validate(uint32_t peerId, data::NetData& data, lc::CSBK* csbk,
     if (!rid.radioDefault()) {
         if (!rid.radioEnabled()) {
             // report error event to metrics
-            TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(INFLUXDB_ERRSTR_DISABLED_SRC_RID), data.getSlotNo());
+            TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(DB_ERRSTR_DISABLED_SRC_RID), data.getSlotNo());
 
             if (m_network->m_logDenials)
-                LogError(LOG_DMR, "DMR Slot %u, " INFLUXDB_ERRSTR_DISABLED_SRC_RID ", peer = %u, srcId = %u, dstId = %u", data.getSlotNo(), peerId, data.getSrcId(), data.getDstId());
+                LogError(LOG_DMR, "DMR Slot %u, " DB_ERRSTR_DISABLED_SRC_RID ", peer = %u, srcId = %u, dstId = %u", data.getSlotNo(), peerId, data.getSrcId(), data.getDstId());
 
             // report In-Call Control to the peer sending traffic
             m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_DMR, NET_ICC::REJECT_TRAFFIC, data.getDstId(), data.getSlotNo());
@@ -1247,10 +1247,10 @@ bool TagDMRData::validate(uint32_t peerId, data::NetData& data, lc::CSBK* csbk,
     std::vector<uint32_t> rejectedStreams = m_rejectedCallStreams[data.getDstId()];
     if (std::find(rejectedStreams.begin(), rejectedStreams.end(), streamId) != rejectedStreams.end()) {
         // report error event to metrics
-        TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(INFLUXDB_ERRSTR_CALL_NOT_PERMITTED), data.getSlotNo());
+        TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(DB_ERRSTR_CALL_NOT_PERMITTED), data.getSlotNo());
 
         if (m_network->m_logDenials)
-            LogError(LOG_DMR, "DMR Slot %u, " INFLUXDB_ERRSTR_CALL_NOT_PERMITTED ", peer = %u, srcId = %u, dstId = %u", data.getSlotNo(), peerId, data.getSrcId(), data.getDstId());
+            LogError(LOG_DMR, "DMR Slot %u, " DB_ERRSTR_CALL_NOT_PERMITTED ", peer = %u, srcId = %u, dstId = %u", data.getSlotNo(), peerId, data.getSrcId(), data.getDstId());
 
         m_rejectedCallStreams.unlock();
 
@@ -1267,10 +1267,10 @@ bool TagDMRData::validate(uint32_t peerId, data::NetData& data, lc::CSBK* csbk,
         if (!rid.radioDefault()) {
             if (!rid.radioEnabled()) {
                 // report error event to metrics
-                TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(INFLUXDB_ERRSTR_DISABLED_DST_RID), data.getSlotNo());
+                TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(DB_ERRSTR_DISABLED_DST_RID), data.getSlotNo());
 
                 if (m_network->m_logDenials)
-                    LogError(LOG_DMR, "DMR Slot %u, " INFLUXDB_ERRSTR_DISABLED_DST_RID ", peer = %u, srcId = %u, dstId = %u", data.getSlotNo(), peerId, data.getSrcId(), data.getDstId());
+                    LogError(LOG_DMR, "DMR Slot %u, " DB_ERRSTR_DISABLED_DST_RID ", peer = %u, srcId = %u, dstId = %u", data.getSlotNo(), peerId, data.getSrcId(), data.getDstId());
 
                 return false;
             }
@@ -1280,10 +1280,10 @@ bool TagDMRData::validate(uint32_t peerId, data::NetData& data, lc::CSBK* csbk,
             // report call error
             if (m_network->m_rejectUnknownRID) {
                 // report error event to metrics
-                TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(INFLUXDB_ERRSTR_ILLEGAL_RID_ACCESS), data.getSlotNo());
+                TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(DB_ERRSTR_ILLEGAL_RID_ACCESS), data.getSlotNo());
 
                 if (m_network->m_logDenials)
-                    LogWarning(LOG_DMR, "DMR slot %s, " INFLUXDB_ERRSTR_ILLEGAL_RID_ACCESS ", srcId = %u, dstId = %u", data.getSlotNo(), data.getSrcId(), data.getDstId());
+                    LogWarning(LOG_DMR, "DMR slot %s, " DB_ERRSTR_ILLEGAL_RID_ACCESS ", srcId = %u, dstId = %u", data.getSlotNo(), data.getSrcId(), data.getDstId());
 
                 // report In-Call Control to the peer sending traffic
                 m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_DMR, NET_ICC::REJECT_TRAFFIC, data.getDstId(), data.getSlotNo());
@@ -1297,10 +1297,10 @@ bool TagDMRData::validate(uint32_t peerId, data::NetData& data, lc::CSBK* csbk,
         lookups::TalkgroupRuleGroupVoice tg = m_network->m_tidLookup->find(data.getDstId());
         if (tg.isInvalid()) {
             // report error event to metrics
-            TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(INFLUXDB_ERRSTR_INV_TALKGROUP), data.getSlotNo());
+            TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(DB_ERRSTR_INV_TALKGROUP), data.getSlotNo());
 
             if (m_network->m_logDenials)
-                LogError(LOG_DMR, "DMR Slot %u, " INFLUXDB_ERRSTR_INV_TALKGROUP ", peer = %u, srcId = %u, dstId = %u", data.getSlotNo(), peerId, data.getSrcId(), data.getDstId());
+                LogError(LOG_DMR, "DMR Slot %u, " DB_ERRSTR_INV_TALKGROUP ", peer = %u, srcId = %u, dstId = %u", data.getSlotNo(), peerId, data.getSrcId(), data.getDstId());
 
             // report In-Call Control to the peer sending traffic
             m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_DMR, NET_ICC::REJECT_TRAFFIC, data.getDstId(),  data.getSlotNo());
@@ -1329,10 +1329,10 @@ bool TagDMRData::validate(uint32_t peerId, data::NetData& data, lc::CSBK* csbk,
         // fail call if the reject flag is set
         if (rejectUnknownBadCall) {
             // report error event to metrics
-            TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(INFLUXDB_ERRSTR_ILLEGAL_RID_ACCESS), data.getSlotNo());
+            TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(DB_ERRSTR_ILLEGAL_RID_ACCESS), data.getSlotNo());
 
             if (m_network->m_logDenials)
-                LogWarning(LOG_DMR, "DMR slot %s, " INFLUXDB_ERRSTR_ILLEGAL_RID_ACCESS ", srcId = %u, dstId = %u", data.getSlotNo(), data.getSrcId(), data.getDstId());
+                LogWarning(LOG_DMR, "DMR slot %s, " DB_ERRSTR_ILLEGAL_RID_ACCESS ", srcId = %u, dstId = %u", data.getSlotNo(), data.getSrcId(), data.getDstId());
 
             // report In-Call Control to the peer sending traffic
             m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_DMR, NET_ICC::REJECT_TRAFFIC, data.getDstId(), data.getSlotNo());
@@ -1342,10 +1342,10 @@ bool TagDMRData::validate(uint32_t peerId, data::NetData& data, lc::CSBK* csbk,
         // check the DMR slot number
         if (tg.source().tgSlot() != data.getSlotNo()) {
             // report error event to metrics
-            TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(INFLUXDB_ERRSTR_INV_SLOT), data.getSlotNo());
+            TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(DB_ERRSTR_INV_SLOT), data.getSlotNo());
 
             if (m_network->m_logDenials)
-                LogError(LOG_DMR, "DMR Slot %u, " INFLUXDB_ERRSTR_INV_SLOT ", peer = %u, srcId = %u, dstId = %u", data.getSlotNo(), peerId, data.getSrcId(), data.getDstId());
+                LogError(LOG_DMR, "DMR Slot %u, " DB_ERRSTR_INV_SLOT ", peer = %u, srcId = %u, dstId = %u", data.getSlotNo(), peerId, data.getSrcId(), data.getDstId());
 
             // report In-Call Control to the peer sending traffic
             m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_DMR, NET_ICC::REJECT_TRAFFIC, data.getDstId(), data.getSlotNo());
@@ -1355,10 +1355,10 @@ bool TagDMRData::validate(uint32_t peerId, data::NetData& data, lc::CSBK* csbk,
         // is the TGID active?
         if (!tg.config().active()) {
             // report error event to metrics
-            TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(INFLUXDB_ERRSTR_DISABLED_TALKGROUP), data.getSlotNo());
+            TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(DB_ERRSTR_DISABLED_TALKGROUP), data.getSlotNo());
 
             if (m_network->m_logDenials)
-                LogError(LOG_DMR, "DMR Slot %u, " INFLUXDB_ERRSTR_DISABLED_TALKGROUP ", peer = %u, srcId = %u, dstId = %u", data.getSlotNo(), peerId, data.getSrcId(), data.getDstId());
+                LogError(LOG_DMR, "DMR Slot %u, " DB_ERRSTR_DISABLED_TALKGROUP ", peer = %u, srcId = %u, dstId = %u", data.getSlotNo(), peerId, data.getSrcId(), data.getDstId());
 
             // report In-Call Control to the peer sending traffic
             m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_DMR, NET_ICC::REJECT_TRAFFIC, data.getDstId(), data.getSlotNo());
@@ -1373,10 +1373,10 @@ bool TagDMRData::validate(uint32_t peerId, data::NetData& data, lc::CSBK* csbk,
                 std::vector<uint32_t> permittedRIDs = tg.config().permittedRIDs();
                 if (std::find(permittedRIDs.begin(), permittedRIDs.end(), data.getSrcId()) == permittedRIDs.end()) {
                     // report error event to metrics
-                    TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(INFLUXDB_ERRSTR_RID_NOT_PERMITTED));
+                    TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, data.getSrcId(), data.getDstId(), std::string(DB_ERRSTR_RID_NOT_PERMITTED));
 
                     if (m_network->m_logDenials)
-                        LogError(LOG_DMR, "DMR Slot %u, " INFLUXDB_ERRSTR_RID_NOT_PERMITTED ", peer = %u, srcId = %u, dstId = %u", data.getSlotNo(), peerId, data.getSrcId(), data.getDstId());
+                        LogError(LOG_DMR, "DMR Slot %u, " DB_ERRSTR_RID_NOT_PERMITTED ", peer = %u, srcId = %u, dstId = %u", data.getSlotNo(), peerId, data.getSrcId(), data.getDstId());
 
                     // report In-Call Control to the peer sending traffic
                     m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_DMR, NET_ICC::REJECT_TRAFFIC, data.getDstId(), data.getSlotNo());
diff --git a/src/fne/network/callhandler/TagNXDNData.cpp b/src/fne/network/callhandler/TagNXDNData.cpp
index 47ada992..2b8382fa 100644
--- a/src/fne/network/callhandler/TagNXDNData.cpp
+++ b/src/fne/network/callhandler/TagNXDNData.cpp
@@ -1039,10 +1039,10 @@ bool TagNXDNData::validate(uint32_t peerId, lc::RTCH& lc, uint8_t messageType, u
     if (!rid.radioDefault()) {
         if (!rid.radioEnabled()) {
             // report error event to metrics
-            TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, lc.getSrcId(), lc.getDstId(), std::string(INFLUXDB_ERRSTR_DISABLED_SRC_RID));
+            TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, lc.getSrcId(), lc.getDstId(), std::string(DB_ERRSTR_DISABLED_SRC_RID));
 
             if (m_network->m_logDenials)
-                LogError(LOG_NXDN, INFLUXDB_ERRSTR_DISABLED_SRC_RID ", peer = %u, srcId = %u, dstId = %u", peerId, lc.getSrcId(), lc.getDstId());
+                LogError(LOG_NXDN, DB_ERRSTR_DISABLED_SRC_RID ", peer = %u, srcId = %u, dstId = %u", peerId, lc.getSrcId(), lc.getDstId());
 
             // report In-Call Control to the peer sending traffic
             m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_NXDN, NET_ICC::REJECT_TRAFFIC, lc.getDstId());
@@ -1066,10 +1066,10 @@ bool TagNXDNData::validate(uint32_t peerId, lc::RTCH& lc, uint8_t messageType, u
     std::vector<uint32_t> rejectedStreams = m_rejectedCallStreams[lc.getDstId()];
     if (std::find(rejectedStreams.begin(), rejectedStreams.end(), streamId) != rejectedStreams.end()) {
         // report error event to metrics
-        TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, lc.getSrcId(), lc.getDstId(), std::string(INFLUXDB_ERRSTR_CALL_NOT_PERMITTED));
+        TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, lc.getSrcId(), lc.getDstId(), std::string(DB_ERRSTR_CALL_NOT_PERMITTED));
 
         if (m_network->m_logDenials)
-            LogError(LOG_NXDN, INFLUXDB_ERRSTR_CALL_NOT_PERMITTED ", peer = %u, srcId = %u, dstId = %u", peerId, lc.getSrcId(), lc.getDstId());
+            LogError(LOG_NXDN, DB_ERRSTR_CALL_NOT_PERMITTED ", peer = %u, srcId = %u, dstId = %u", peerId, lc.getSrcId(), lc.getDstId());
 
         m_rejectedCallStreams.unlock();
 
@@ -1086,10 +1086,10 @@ bool TagNXDNData::validate(uint32_t peerId, lc::RTCH& lc, uint8_t messageType, u
         if (!rid.radioDefault()) {
             if (!rid.radioEnabled()) {
                 // report error event to metrics
-                TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, lc.getSrcId(), lc.getDstId(), std::string(INFLUXDB_ERRSTR_DISABLED_DST_RID));
+                TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, lc.getSrcId(), lc.getDstId(), std::string(DB_ERRSTR_DISABLED_DST_RID));
 
                 if (m_network->m_logDenials)
-                    LogError(LOG_NXDN, INFLUXDB_ERRSTR_DISABLED_DST_RID ", peer = %u, srcId = %u, dstId = %u", peerId, lc.getSrcId(), lc.getDstId());
+                    LogError(LOG_NXDN, DB_ERRSTR_DISABLED_DST_RID ", peer = %u, srcId = %u, dstId = %u", peerId, lc.getSrcId(), lc.getDstId());
 
                 // report In-Call Control to the peer sending traffic
                 m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_NXDN, NET_ICC::REJECT_TRAFFIC, lc.getDstId());
@@ -1101,10 +1101,10 @@ bool TagNXDNData::validate(uint32_t peerId, lc::RTCH& lc, uint8_t messageType, u
             // report call error
             if (m_network->m_rejectUnknownRID) {
                 // report error event to metrics
-                TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, lc.getSrcId(), lc.getDstId(), std::string(INFLUXDB_ERRSTR_ILLEGAL_RID_ACCESS));
+                TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, lc.getSrcId(), lc.getDstId(), std::string(DB_ERRSTR_ILLEGAL_RID_ACCESS));
 
                 if (m_network->m_logDenials)
-                    LogWarning(LOG_NXDN, INFLUXDB_ERRSTR_ILLEGAL_RID_ACCESS ", srcId = %u, dstId = %u", lc.getSrcId(), lc.getDstId());
+                    LogWarning(LOG_NXDN, DB_ERRSTR_ILLEGAL_RID_ACCESS ", srcId = %u, dstId = %u", lc.getSrcId(), lc.getDstId());
 
                 // report In-Call Control to the peer sending traffic
                 m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_NXDN, NET_ICC::REJECT_TRAFFIC, lc.getDstId());
@@ -1120,10 +1120,10 @@ bool TagNXDNData::validate(uint32_t peerId, lc::RTCH& lc, uint8_t messageType, u
     // check TGID validity
     if (tg.isInvalid()) {
         // report error event to metrics
-        TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, lc.getSrcId(), lc.getDstId(), std::string(INFLUXDB_ERRSTR_INV_TALKGROUP));
+        TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, lc.getSrcId(), lc.getDstId(), std::string(DB_ERRSTR_INV_TALKGROUP));
 
         if (m_network->m_logDenials)
-            LogError(LOG_NXDN, INFLUXDB_ERRSTR_INV_TALKGROUP ", peer = %u, srcId = %u, dstId = %u", peerId, lc.getSrcId(), lc.getDstId());
+            LogError(LOG_NXDN, DB_ERRSTR_INV_TALKGROUP ", peer = %u, srcId = %u, dstId = %u", peerId, lc.getSrcId(), lc.getDstId());
 
         // report In-Call Control to the peer sending traffic
         m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_NXDN, NET_ICC::REJECT_TRAFFIC, lc.getDstId());
@@ -1136,10 +1136,10 @@ bool TagNXDNData::validate(uint32_t peerId, lc::RTCH& lc, uint8_t messageType, u
             if (tg.config().strapping() == lookups::TG_STRAPPING_STRAPPED) {
                 if (lc.getAlgId() == NXDDEF::CIPHER_TYPE_NONE) {
                     // report error event to metrics
-                    TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, lc.getSrcId(), lc.getDstId(), std::string(INFLUXDB_ERRSTR_ENC_TALKGROUP_CLR));
+                    TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, lc.getSrcId(), lc.getDstId(), std::string(DB_ERRSTR_ENC_TALKGROUP_CLR));
 
                     if (m_network->m_logDenials)
-                        LogError(LOG_NXDN, INFLUXDB_ERRSTR_ENC_TALKGROUP_CLR ", peer = %u, srcId = %u, dstId = %u", peerId, lc.getSrcId(), lc.getDstId());
+                        LogError(LOG_NXDN, DB_ERRSTR_ENC_TALKGROUP_CLR ", peer = %u, srcId = %u, dstId = %u", peerId, lc.getSrcId(), lc.getDstId());
 
                     // report In-Call Control to the peer sending traffic
                     m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_NXDN, NET_ICC::REJECT_TRAFFIC, lc.getDstId(), 0U, true);
@@ -1151,10 +1151,10 @@ bool TagNXDNData::validate(uint32_t peerId, lc::RTCH& lc, uint8_t messageType, u
             if (tg.config().strapping() == lookups::TG_STRAPPING_CLEAR) {
                 if (lc.getAlgId() != NXDDEF::CIPHER_TYPE_NONE) {
                     // report error event to metrics
-                    TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, lc.getSrcId(), lc.getDstId(), std::string(INFLUXDB_ERRSTR_CLR_TALKGROUP_ENC));
+                    TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, lc.getSrcId(), lc.getDstId(), std::string(DB_ERRSTR_CLR_TALKGROUP_ENC));
 
                     if (m_network->m_logDenials)
-                        LogError(LOG_NXDN, INFLUXDB_ERRSTR_CLR_TALKGROUP_ENC ", peer = %u, srcId = %u, dstId = %u", peerId, lc.getSrcId(), lc.getDstId());
+                        LogError(LOG_NXDN, DB_ERRSTR_CLR_TALKGROUP_ENC ", peer = %u, srcId = %u, dstId = %u", peerId, lc.getSrcId(), lc.getDstId());
 
                     // report In-Call Control to the peer sending traffic
                     m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_NXDN, NET_ICC::REJECT_TRAFFIC, lc.getDstId(), 0U, true);
@@ -1178,10 +1178,10 @@ bool TagNXDNData::validate(uint32_t peerId, lc::RTCH& lc, uint8_t messageType, u
     // fail call if the reject flag is set
     if (rejectUnknownBadCall) {
         // report error event to metrics
-        TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, lc.getSrcId(), lc.getDstId(), std::string(INFLUXDB_ERRSTR_ILLEGAL_RID_ACCESS));
+        TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, lc.getSrcId(), lc.getDstId(), std::string(DB_ERRSTR_ILLEGAL_RID_ACCESS));
 
         if (m_network->m_logDenials)
-            LogWarning(LOG_NXDN, INFLUXDB_ERRSTR_ILLEGAL_RID_ACCESS ", srcId = %u, dstId = %u", lc.getSrcId(), lc.getDstId());
+            LogWarning(LOG_NXDN, DB_ERRSTR_ILLEGAL_RID_ACCESS ", srcId = %u, dstId = %u", lc.getSrcId(), lc.getDstId());
 
         // report In-Call Control to the peer sending traffic
         m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_NXDN, NET_ICC::REJECT_TRAFFIC, lc.getDstId());
@@ -1191,10 +1191,10 @@ bool TagNXDNData::validate(uint32_t peerId, lc::RTCH& lc, uint8_t messageType, u
     // is the TGID active?
     if (!tg.config().active()) {
         // report error event to metrics
-        TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, lc.getSrcId(), lc.getDstId(), std::string(INFLUXDB_ERRSTR_DISABLED_TALKGROUP));
+        TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, lc.getSrcId(), lc.getDstId(), std::string(DB_ERRSTR_DISABLED_TALKGROUP));
 
         if (m_network->m_logDenials)
-            LogError(LOG_NXDN, INFLUXDB_ERRSTR_DISABLED_TALKGROUP ", peer = %u, srcId = %u, dstId = %u", peerId, lc.getSrcId(), lc.getDstId());
+            LogError(LOG_NXDN, DB_ERRSTR_DISABLED_TALKGROUP ", peer = %u, srcId = %u, dstId = %u", peerId, lc.getSrcId(), lc.getDstId());
 
         // report In-Call Control to the peer sending traffic
         m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_NXDN, NET_ICC::REJECT_TRAFFIC, lc.getDstId());
@@ -1209,10 +1209,10 @@ bool TagNXDNData::validate(uint32_t peerId, lc::RTCH& lc, uint8_t messageType, u
             std::vector<uint32_t> permittedRIDs = tg.config().permittedRIDs();
             if (std::find(permittedRIDs.begin(), permittedRIDs.end(), lc.getSrcId()) == permittedRIDs.end()) {
                 // report error event to metrics
-                TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, lc.getSrcId(), lc.getDstId(), std::string(INFLUXDB_ERRSTR_RID_NOT_PERMITTED));
+                TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, lc.getSrcId(), lc.getDstId(), std::string(DB_ERRSTR_RID_NOT_PERMITTED));
 
                 if (m_network->m_logDenials)
-                    LogError(LOG_NXDN, INFLUXDB_ERRSTR_RID_NOT_PERMITTED ", peer = %u, srcId = %u, dstId = %u", peerId, lc.getSrcId(), lc.getDstId());
+                    LogError(LOG_NXDN, DB_ERRSTR_RID_NOT_PERMITTED ", peer = %u, srcId = %u, dstId = %u", peerId, lc.getSrcId(), lc.getDstId());
 
                 // report In-Call Control to the peer sending traffic
                 m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_NXDN, NET_ICC::REJECT_TRAFFIC, lc.getDstId());
diff --git a/src/fne/network/callhandler/TagP25Data.cpp b/src/fne/network/callhandler/TagP25Data.cpp
index 8e989783..949bce95 100644
--- a/src/fne/network/callhandler/TagP25Data.cpp
+++ b/src/fne/network/callhandler/TagP25Data.cpp
@@ -1636,10 +1636,10 @@ bool TagP25Data::validate(uint32_t peerId, lc::LC& control, DUID::E duid, const
         if (!rid.radioDefault()) {
             if (!rid.radioEnabled()) {
                 // report error event to metrics
-                TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, control.getSrcId(), control.getDstId(), std::string(INFLUXDB_ERRSTR_DISABLED_SRC_RID));
+                TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, control.getSrcId(), control.getDstId(), std::string(DB_ERRSTR_DISABLED_SRC_RID));
 
                 if (m_network->m_logDenials)
-                    LogError(LOG_P25, INFLUXDB_ERRSTR_DISABLED_SRC_RID ", peer = %u, srcId = %u, dstId = %u", peerId, control.getSrcId(), control.getDstId());
+                    LogError(LOG_P25, DB_ERRSTR_DISABLED_SRC_RID ", peer = %u, srcId = %u, dstId = %u", peerId, control.getSrcId(), control.getDstId());
 
                 // report In-Call Control to the peer sending traffic
                 m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_P25, NET_ICC::REJECT_TRAFFIC, control.getDstId());
@@ -1701,10 +1701,10 @@ bool TagP25Data::validate(uint32_t peerId, lc::LC& control, DUID::E duid, const
     std::vector<uint32_t> rejectedStreams = m_rejectedCallStreams[control.getDstId()];
     if (std::find(rejectedStreams.begin(), rejectedStreams.end(), streamId) != rejectedStreams.end()) {
         // report error event to metrics
-        TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, control.getSrcId(), control.getDstId(), std::string(INFLUXDB_ERRSTR_CALL_NOT_PERMITTED));
+        TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, control.getSrcId(), control.getDstId(), std::string(DB_ERRSTR_CALL_NOT_PERMITTED));
 
         if (m_network->m_logDenials)
-            LogError(LOG_P25, INFLUXDB_ERRSTR_CALL_NOT_PERMITTED ", peer = %u, srcId = %u, dstId = %u", peerId, control.getSrcId(), control.getDstId());
+            LogError(LOG_P25, DB_ERRSTR_CALL_NOT_PERMITTED ", peer = %u, srcId = %u, dstId = %u", peerId, control.getSrcId(), control.getDstId());
 
         m_rejectedCallStreams.unlock();
 
@@ -1737,10 +1737,10 @@ bool TagP25Data::validate(uint32_t peerId, lc::LC& control, DUID::E duid, const
         if (!rid.radioDefault()) {
             if (!rid.radioEnabled()) {
                 // report error event to metrics
-                TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, control.getSrcId(), control.getDstId(), std::string(INFLUXDB_ERRSTR_DISABLED_DST_RID));
+                TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, control.getSrcId(), control.getDstId(), std::string(DB_ERRSTR_DISABLED_DST_RID));
 
                 if (m_network->m_logDenials)
-                    LogError(LOG_P25, INFLUXDB_ERRSTR_DISABLED_DST_RID ", peer = %u, srcId = %u, dstId = %u", peerId, control.getSrcId(), control.getDstId());
+                    LogError(LOG_P25, DB_ERRSTR_DISABLED_DST_RID ", peer = %u, srcId = %u, dstId = %u", peerId, control.getSrcId(), control.getDstId());
 
                 // report In-Call Control to the peer sending traffic
                 m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_P25, NET_ICC::REJECT_TRAFFIC, control.getDstId());
@@ -1752,10 +1752,10 @@ bool TagP25Data::validate(uint32_t peerId, lc::LC& control, DUID::E duid, const
             // report call error
             if (m_network->m_rejectUnknownRID) {
                 // report error event to metrics
-                TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, control.getSrcId(), control.getDstId(), std::string(INFLUXDB_ERRSTR_ILLEGAL_RID_ACCESS));
+                TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, control.getSrcId(), control.getDstId(), std::string(DB_ERRSTR_ILLEGAL_RID_ACCESS));
 
                 if (m_network->m_logDenials)
-                    LogWarning(LOG_P25, INFLUXDB_ERRSTR_ILLEGAL_RID_ACCESS ", srcId = %u, dstId = %u", control.getSrcId(), control.getDstId());
+                    LogWarning(LOG_P25, DB_ERRSTR_ILLEGAL_RID_ACCESS ", srcId = %u, dstId = %u", control.getSrcId(), control.getDstId());
 
                 // report In-Call Control to the peer sending traffic
                 m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_P25, NET_ICC::REJECT_TRAFFIC, control.getDstId());
@@ -1839,10 +1839,10 @@ bool TagP25Data::validate(uint32_t peerId, lc::LC& control, DUID::E duid, const
     if (tg.isInvalid()) {
         //LogDebugEx(LOG_NET, "TagP25Data::validate()", "dstId = %u, invalid dropped", control.getDstId());
         // report error event to metrics
-        TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, control.getSrcId(), control.getDstId(), std::string(INFLUXDB_ERRSTR_INV_TALKGROUP));
+        TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, control.getSrcId(), control.getDstId(), std::string(DB_ERRSTR_INV_TALKGROUP));
 
         if (m_network->m_logDenials)
-            LogError(LOG_P25, INFLUXDB_ERRSTR_INV_TALKGROUP ", peer = %u, srcId = %u, dstId = %u", peerId, control.getSrcId(), control.getDstId());
+            LogError(LOG_P25, DB_ERRSTR_INV_TALKGROUP ", peer = %u, srcId = %u, dstId = %u", peerId, control.getSrcId(), control.getDstId());
 
         // report In-Call Control to the peer sending traffic
         m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_P25, NET_ICC::REJECT_TRAFFIC, control.getDstId());
@@ -1856,10 +1856,10 @@ bool TagP25Data::validate(uint32_t peerId, lc::LC& control, DUID::E duid, const
                 //LogDebugEx(LOG_P25, "TagP25Data::validate()", "tgId = %u, duid = $%02X, strapping = %u, algId = $%02X", control.getDstId(), (uint8_t)duid, tg.config().strapping(), control.getAlgId());
                 if (control.getAlgId() == P25DEF::ALGO_UNENCRYPT) {
                     // report error event to metrics
-                    TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, control.getSrcId(), control.getDstId(), std::string(INFLUXDB_ERRSTR_ENC_TALKGROUP_CLR));
+                    TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, control.getSrcId(), control.getDstId(), std::string(DB_ERRSTR_ENC_TALKGROUP_CLR));
 
                     if (m_network->m_logDenials)
-                        LogError(LOG_P25, INFLUXDB_ERRSTR_ENC_TALKGROUP_CLR ", peer = %u, srcId = %u, dstId = %u", peerId, control.getSrcId(), control.getDstId());
+                        LogError(LOG_P25, DB_ERRSTR_ENC_TALKGROUP_CLR ", peer = %u, srcId = %u, dstId = %u", peerId, control.getSrcId(), control.getDstId());
 
                     // report In-Call Control to the peer sending traffic
                     m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_P25, NET_ICC::REJECT_TRAFFIC, control.getDstId(), 0U, true);
@@ -1871,10 +1871,10 @@ bool TagP25Data::validate(uint32_t peerId, lc::LC& control, DUID::E duid, const
             if (tg.config().strapping() == lookups::TG_STRAPPING_CLEAR) {
                 if (control.getAlgId() != P25DEF::ALGO_UNENCRYPT) {
                     // report error event to metrics
-                    TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, control.getSrcId(), control.getDstId(), std::string(INFLUXDB_ERRSTR_CLR_TALKGROUP_ENC));
+                    TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, control.getSrcId(), control.getDstId(), std::string(DB_ERRSTR_CLR_TALKGROUP_ENC));
 
                     if (m_network->m_logDenials)
-                        LogError(LOG_P25, INFLUXDB_ERRSTR_CLR_TALKGROUP_ENC ", peer = %u, srcId = %u, dstId = %u", peerId, control.getSrcId(), control.getDstId());
+                        LogError(LOG_P25, DB_ERRSTR_CLR_TALKGROUP_ENC ", peer = %u, srcId = %u, dstId = %u", peerId, control.getSrcId(), control.getDstId());
 
                     // report In-Call Control to the peer sending traffic
                     m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_P25, NET_ICC::REJECT_TRAFFIC, control.getDstId(), 0U, true);
@@ -1898,10 +1898,10 @@ bool TagP25Data::validate(uint32_t peerId, lc::LC& control, DUID::E duid, const
     // fail call if the reject flag is set
     if (rejectUnknownBadCall) {
         // report error event to metrics
-        TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, control.getSrcId(), control.getDstId(), std::string(INFLUXDB_ERRSTR_ILLEGAL_RID_ACCESS));
+        TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, control.getSrcId(), control.getDstId(), std::string(DB_ERRSTR_ILLEGAL_RID_ACCESS));
 
         if (m_network->m_logDenials)
-            LogWarning(LOG_P25, INFLUXDB_ERRSTR_ILLEGAL_RID_ACCESS ", srcId = %u, dstId = %u", control.getSrcId(), control.getDstId());
+            LogWarning(LOG_P25, DB_ERRSTR_ILLEGAL_RID_ACCESS ", srcId = %u, dstId = %u", control.getSrcId(), control.getDstId());
 
         // report In-Call Control to the peer sending traffic
         m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_P25, NET_ICC::REJECT_TRAFFIC, control.getDstId());
@@ -1911,10 +1911,10 @@ bool TagP25Data::validate(uint32_t peerId, lc::LC& control, DUID::E duid, const
     // is the TGID active?
     if (!tg.config().active()) {
         // report error event to metrics
-        TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, control.getSrcId(), control.getDstId(), std::string(INFLUXDB_ERRSTR_DISABLED_TALKGROUP));
+        TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, control.getSrcId(), control.getDstId(), std::string(DB_ERRSTR_DISABLED_TALKGROUP));
 
         if (m_network->m_logDenials)
-            LogError(LOG_P25, INFLUXDB_ERRSTR_DISABLED_TALKGROUP ", peer = %u, srcId = %u, dstId = %u", peerId, control.getSrcId(), control.getDstId());
+            LogError(LOG_P25, DB_ERRSTR_DISABLED_TALKGROUP ", peer = %u, srcId = %u, dstId = %u", peerId, control.getSrcId(), control.getDstId());
 
         // report In-Call Control to the peer sending traffic
         m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_P25, NET_ICC::REJECT_TRAFFIC, control.getDstId());
@@ -1929,10 +1929,10 @@ bool TagP25Data::validate(uint32_t peerId, lc::LC& control, DUID::E duid, const
             std::vector<uint32_t> permittedRIDs = tg.config().permittedRIDs();
             if (std::find(permittedRIDs.begin(), permittedRIDs.end(), control.getSrcId()) == permittedRIDs.end()) {
                 // report error event to metrics
-                TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, control.getSrcId(), control.getDstId(), std::string(INFLUXDB_ERRSTR_RID_NOT_PERMITTED));
+                TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, control.getSrcId(), control.getDstId(), std::string(DB_ERRSTR_RID_NOT_PERMITTED));
 
                 if (m_network->m_logDenials)
-                    LogError(LOG_P25, INFLUXDB_ERRSTR_RID_NOT_PERMITTED ", peer = %u, srcId = %u, dstId = %u", peerId, control.getSrcId(), control.getDstId());
+                    LogError(LOG_P25, DB_ERRSTR_RID_NOT_PERMITTED ", peer = %u, srcId = %u, dstId = %u", peerId, control.getSrcId(), control.getDstId());
 
                 // report In-Call Control to the peer sending traffic
                 m_network->writePeerICC(peerId, streamId, NET_SUBFUNC::PROTOCOL_SUBFUNC_P25, NET_ICC::REJECT_TRAFFIC, control.getDstId());
diff --git a/src/fne/network/callhandler/packetdata/DMRPacketData.cpp b/src/fne/network/callhandler/packetdata/DMRPacketData.cpp
index 7b810332..a6ffaf2c 100644
--- a/src/fne/network/callhandler/packetdata/DMRPacketData.cpp
+++ b/src/fne/network/callhandler/packetdata/DMRPacketData.cpp
@@ -239,7 +239,7 @@ bool DMRPacketData::processFrame(const uint8_t* data, uint32_t len, uint32_t pee
             if (!rid.radioDefault()) {
                 if (!rid.radioEnabled()) {
                     // report error event to metrics
-                    TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, status->header.getSrcId(), status->header.getDstId(), std::string(INFLUXDB_ERRSTR_DISABLED_SRC_RID));
+                    TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, status->header.getSrcId(), status->header.getDstId(), std::string(DB_ERRSTR_DISABLED_SRC_RID));
 
                     m_status.erase(peerId);
                     delete status;
diff --git a/src/fne/network/callhandler/packetdata/P25PacketData.cpp b/src/fne/network/callhandler/packetdata/P25PacketData.cpp
index cd557d73..5f29ad20 100644
--- a/src/fne/network/callhandler/packetdata/P25PacketData.cpp
+++ b/src/fne/network/callhandler/packetdata/P25PacketData.cpp
@@ -247,7 +247,7 @@ bool P25PacketData::processFrame(const uint8_t* data, uint32_t len, uint32_t pee
                         if (!rid.radioDefault()) {
                             if (!rid.radioEnabled()) {
                                 // report error event to metrics
-                                TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, status->assembler.dataHeader.getLLId(), status->assembler.dataHeader.getLLId(), std::string(INFLUXDB_ERRSTR_DISABLED_SRC_RID));
+                                TrafficNetwork::MetricsLogging::logCallErrorEvent(m_network, peerId, streamId, status->assembler.dataHeader.getLLId(), status->assembler.dataHeader.getLLId(), std::string(DB_ERRSTR_DISABLED_SRC_RID));
 
                                 m_status.erase(peerId);
                                 delete status;