diff --git a/include/dfmodules/DataStore.hpp b/include/dfmodules/DataStore.hpp
index ebe6ee8a..8ed695e2 100644
--- a/include/dfmodules/DataStore.hpp
+++ b/include/dfmodules/DataStore.hpp
@@ -33,7 +33,7 @@
 #include <vector>
 
 #ifndef EXTERN_C_FUNC_DECLARE_START
-// NOLINTNEXTLINE(build/define_used)
+// NOLINTNEXTLINE
 #define EXTERN_C_FUNC_DECLARE_START                                                                                    \
   extern "C"                                                                                                           \
   {
@@ -42,7 +42,7 @@
  * @brief Declare the function that will be called by the plugin loader
  * @param klass Class to be defined as a DUNE IPM Receiver
  */
-// NOLINTNEXTLINE(build/define_used)
+// NOLINTNEXTLINE
 #define DEFINE_DUNE_DATA_STORE(klass)                                                                                  \
   EXTERN_C_FUNC_DECLARE_START                                                                                          \
   std::shared_ptr<dunedaq::dfmodules::DataStore> make(const std::string& name,                                         \
diff --git a/include/dfmodules/FileDataStoreImpl.hpp b/include/dfmodules/FileDataStoreImpl.hpp
index c4d45c62..f3d581f1 100644
--- a/include/dfmodules/FileDataStoreImpl.hpp
+++ b/include/dfmodules/FileDataStoreImpl.hpp
@@ -1,6 +1,10 @@
 /**
  * @file FileDataStoreImpl.hpp
  *
+ * This is part of the DUNE DAQ Application Framework, copyright 2020.
+ * Licensing/copyright details are in the COPYING file that you should have
+ * received with this code.
+ *
  * The base class for file-output-focused implementations of the
  * DataStore interface
  *
@@ -24,10 +28,6 @@
  * from appmodel::DataStoreConf as a superclass and adds parameters as
  * needed. See DataStoreConfTestDeriv in this package, and how it's
  * used by SummaryTextDataStore
- *
- * This is part of the DUNE DAQ Application Framework, copyright 2020.
- * Licensing/copyright details are in the COPYING file that you should have
- * received with this code.
  */
 
 #ifndef DFMODULES_INCLUDE_DFMODULES_FILEDATASTOREIMPL_HPP_
@@ -126,7 +126,7 @@ concept FileHandleConcept = requires(T file_handle,
   { const_file_handle.get_recorded_size() } -> std::convertible_to<size_t>;
   { const_file_handle.get_uncompressed_raw_data_size() } -> std::convertible_to<size_t>;
   { const_file_handle.get_total_file_size() } -> std::convertible_to<size_t>;
-};
+}; // NOLINT
 
 /**
  * @brief FileDataStoreImpl contains functionality you'd generally
diff --git a/plugins/DFOModule.cpp b/plugins/DFOModule.cpp
index 88b09ff1..c4159b83 100644
--- a/plugins/DFOModule.cpp
+++ b/plugins/DFOModule.cpp
@@ -144,7 +144,7 @@ DFOModule::do_start(const CommandData_t& payload)
     bool is_ready = m_busy_sender->is_ready_for_sending(std::chrono::milliseconds(100));
     TLOG_DEBUG(0) << "The sender for TriggerInhibit messages " << (is_ready ? "is" : "is not") << " ready.";
   }
-  for (auto trb_conn : m_trb_conn_ids) {
+  for (auto const& trb_conn : m_trb_conn_ids) {
     auto sender = iom->get_sender<dfmessages::TriggerDecision>(trb_conn);
     if (sender != nullptr) {
       bool is_ready = sender->is_ready_for_sending(std::chrono::milliseconds(100));
@@ -227,7 +227,7 @@ DFOModule::receive_trigger_decision(const dfmessages::TriggerDecision& decision)
   ++m_received_decisions;
   auto trigger_types = unpack_types(decision.trigger_type);
   for (const auto t : trigger_types) {
-    ++get_trigger_counter(t).received;
+    ++(get_trigger_counter(t).received);
   }
 
   std::chrono::steady_clock::time_point decision_assigned;
@@ -405,7 +405,7 @@ DFOModule::receive_trigger_complete_token(const dfmessages::TriggerDecisionToken
     auto dec_ptr = app_it->second->complete_assignment(token.trigger_number, m_metadata_function);
     auto trigger_types = unpack_types(dec_ptr->decision.trigger_type);
     for (const auto t : trigger_types)
-      ++get_trigger_counter(t).completed;
+      ++(get_trigger_counter(t).completed);
   } catch (AssignedTriggerDecisionNotFound const& err) {
     ers::error(err);
   }
@@ -473,7 +473,7 @@ DFOModule::notify_trigger_if_needed() const
   do {
     try {
       dfmessages::TriggerInhibit message{ busy, m_run_number };
-      m_busy_sender->send(std::move(message), m_queue_timeout);
+      m_busy_sender->send(std::move(message), m_queue_timeout); // NOLINT(performance-move-const-arg)
       wasSentSuccessfully = true;
       TLOG_DEBUG(TLVL_NOTIFY_TRIGGER) << get_name() << " Sent BUSY status " << busy << " to trigger in run "
                                       << m_run_number;
@@ -507,8 +507,9 @@ DFOModule::dispatch(const std::shared_ptr<AssignedTriggerDecision>& assignment)
       wasSentSuccessfully = true;
       ++m_sent_decisions;
       TLOG_DEBUG(TLVL_DISPATCH_TO_TRB) << get_name() << " Sent TriggerDecision for trigger_number "
-                                       << decision_copy.trigger_number << " to TRB at connection "
-                                       << assignment->connection_name << " for run number " << decision_copy.run_number;
+                                       << assignment->decision.trigger_number << " to TRB at connection "
+                                       << assignment->connection_name << " for run number "
+                                       << assignment->decision.run_number;
     } catch (const ers::Issue& excpt) {
       std::ostringstream oss_warn;
       oss_warn << "Send to connection \"" << assignment->connection_name << "\" failed";
diff --git a/plugins/DFOModule.hpp b/plugins/DFOModule.hpp
index 653e941b..1838ac5f 100644
--- a/plugins/DFOModule.hpp
+++ b/plugins/DFOModule.hpp
@@ -6,8 +6,8 @@
  * received with this code.
  */
 
-#ifndef DFMODULES_PLUGINS_DATAFLOWORCHESTRATOR_HPP_
-#define DFMODULES_PLUGINS_DATAFLOWORCHESTRATOR_HPP_
+#ifndef DFMODULES_PLUGINS_DFOMODULE_HPP_
+#define DFMODULES_PLUGINS_DFOMODULE_HPP_
 
 #include "dfmodules/TriggerRecordBuilderData.hpp"
 
@@ -28,6 +28,7 @@
 #include <map>
 #include <memory>
 #include <mutex>
+#include <set>
 #include <string>
 #include <utility>
 #include <vector>
@@ -48,8 +49,9 @@ ERS_DECLARE_ISSUE(dfmodules,
                   "DFOModule encountered run number mismatch: recvd (" << received_run_number << ") != " << run_number
                                                                        << " from " << src_app << " for trigger_number "
                                                                        << trig_num,
-                  ((uint32_t)received_run_number)((uint32_t)run_number)((std::string)src_app)(
-                    (uint32_t)trig_num)) // NOLINT(build/unsigned)
+                  ((uint32_t)received_run_number)             // NOLINT(build/unsigned)
+                  ((uint32_t)run_number)                      // NOLINT(build/unsigned)
+                  ((std::string)src_app)((uint32_t)trig_num)) // NOLINT(build/unsigned)
 ERS_DECLARE_ISSUE(dfmodules,
                   IncompleteTriggerDecision,
                   "TriggerDecision " << trigger_number << " didn't complete within timeout in run " << run_number,
@@ -140,8 +142,8 @@ class DFOModule : public dunedaq::appfwk::DAQModule
   // Struct for statistic
   struct TriggerData
   {
-    std::atomic<uint64_t> received{ 0 };
-    std::atomic<uint64_t> completed{ 0 };
+    std::atomic<uint64_t> received{ 0 };  // NOLINT(build/unsigned)
+    std::atomic<uint64_t> completed{ 0 }; // NOLINT(build/unsigned)
   };
   static std::set<trgdataformats::TriggerCandidateData::Type> unpack_types(
     decltype(dfmessages::TriggerDecision::trigger_type) t)
@@ -152,7 +154,7 @@ class DFOModule : public dunedaq::appfwk::DAQModule
     const std::bitset<64> bits(t);
     for (size_t i = 0; i < bits.size(); ++i) {
       if (bits[i])
-        results.insert((trgdataformats::TriggerCandidateData::Type)i);
+        results.insert(static_cast<trgdataformats::TriggerCandidateData::Type>(i));
     }
     return results;
   }
@@ -181,4 +183,4 @@ class DFOModule : public dunedaq::appfwk::DAQModule
 } // namespace dfmodules
 } // namespace dunedaq
 
-#endif // DFMODULES_PLUGINS_DATAFLOWORCHESTRATOR_HPP_
+#endif // DFMODULES_PLUGINS_DFOMODULE_HPP_
diff --git a/plugins/DataWriterModule.cpp b/plugins/DataWriterModule.cpp
index 09c6f3a1..03f8012a 100644
--- a/plugins/DataWriterModule.cpp
+++ b/plugins/DataWriterModule.cpp
@@ -44,8 +44,7 @@ enum
   TLVL_FRAGMENT_HEADER_DUMP = 17
 };
 
-namespace dunedaq {
-namespace dfmodules {
+namespace dunedaq::dfmodules {
 
 DataWriterModule::DataWriterModule(const std::string& name)
   : dunedaq::appfwk::DAQModule(name)
@@ -172,7 +171,7 @@ DataWriterModule::do_conf(const CommandData_t&)
   }
 
   // ensure that we have a valid dataWriter instance
-  if (m_data_writer.get() == nullptr) {
+  if (m_data_writer == nullptr) {
     throw InvalidDataWriterModule(ERS_HERE, get_name());
   }
 
@@ -188,14 +187,15 @@ DataWriterModule::do_start(const CommandData_t& payload)
   m_data_storage_is_enabled = (!start_params.disable_data_storage);
   m_run_number = start_params.run;
 
-  TLOG_DEBUG(TLVL_WORK_STEPS) << get_name() << ": Sending initial TriggerDecisionToken to DFO to announce my presence";
-  dfmessages::TriggerDecisionToken token;
-  token.run_number = 0;
-  token.trigger_number = 0;
-  token.decision_destination = m_trigger_decision_connection;
-
   int wasSentSuccessfully = 5;
   do {
+    TLOG_DEBUG(TLVL_WORK_STEPS) << get_name()
+                                << ": Sending initial TriggerDecisionToken to DFO to announce my presence";
+    dfmessages::TriggerDecisionToken token;
+    token.run_number = 0;
+    token.trigger_number = 0;
+    token.decision_destination = m_trigger_decision_connection;
+
     try {
       m_token_output->send(std::move(token), m_queue_timeout);
       wasSentSuccessfully = 0;
@@ -215,7 +215,7 @@ DataWriterModule::do_start(const CommandData_t& payload)
   if (m_data_storage_is_enabled) {
 
     // ensure that we have a valid dataWriter instance
-    if (m_data_writer.get() == nullptr) {
+    if (m_data_writer == nullptr) {
       // this check is done essentially to notify the user
       // in case the "start" has been called before the "conf"
       ers::fatal(InvalidDataWriterModule(ERS_HERE, get_name()));
@@ -377,16 +377,16 @@ DataWriterModule::receive_trigger_record(std::unique_ptr<daqdataformats::Trigger
     }
   }
   if (send_trigger_complete_message) {
-    TLOG_DEBUG(TLVL_WORK_STEPS) << get_name() << ": Pushing the TriggerDecisionToken for trigger number "
-                                << trigger_record_ptr->get_header_ref().get_trigger_number()
-                                << " onto the relevant output queue";
-    dfmessages::TriggerDecisionToken token;
-    token.run_number = m_run_number;
-    token.trigger_number = trigger_record_ptr->get_header_ref().get_trigger_number();
-    token.decision_destination = m_trigger_decision_connection;
-
     bool wasSentSuccessfully = false;
     do {
+      TLOG_DEBUG(TLVL_WORK_STEPS) << get_name() << ": Pushing the TriggerDecisionToken for trigger number "
+                                  << trigger_record_ptr->get_header_ref().get_trigger_number()
+                                  << " onto the relevant output queue";
+      dfmessages::TriggerDecisionToken token;
+      token.run_number = m_run_number;
+      token.trigger_number = trigger_record_ptr->get_header_ref().get_trigger_number();
+      token.decision_destination = m_trigger_decision_connection;
+
       try {
         m_token_output->send(std::move(token), m_queue_timeout);
         wasSentSuccessfully = true;
@@ -418,7 +418,6 @@ DataWriterModule::do_work(std::atomic<bool>& running_flag)
   }
 }
 
-} // namespace dfmodules
-} // namespace dunedaq
+} // namespace dunedaq::dfmodules
 
 DEFINE_DUNE_DAQ_MODULE(dunedaq::dfmodules::DataWriterModule)
diff --git a/plugins/DataWriterModule.hpp b/plugins/DataWriterModule.hpp
index 54127105..4d1d03aa 100644
--- a/plugins/DataWriterModule.hpp
+++ b/plugins/DataWriterModule.hpp
@@ -6,8 +6,8 @@
  * received with this code.
  */
 
-#ifndef DFMODULES_PLUGINS_DATAWRITER_HPP_
-#define DFMODULES_PLUGINS_DATAWRITER_HPP_
+#ifndef DFMODULES_PLUGINS_DATAWRITERMODULE_HPP_
+#define DFMODULES_PLUGINS_DATAWRITERMODULE_HPP_
 
 #include "dfmodules/DataStore.hpp"
 
@@ -104,7 +104,7 @@ class DataWriterModule : public dunedaq::appfwk::DAQModule
   inline double elapsed_seconds(std::chrono::steady_clock::time_point then,
                                 std::chrono::steady_clock::time_point now = std::chrono::steady_clock::now()) const
   {
-    return std::chrono::duration_cast<std::chrono::seconds>(now - then).count();
+    return std::chrono::duration_cast<std::chrono::duration<double, std::ratio<1>>>(now - then).count();
   }
 };
 } // namespace dfmodules
@@ -136,4 +136,4 @@ ERS_DECLARE_ISSUE_BASE(dfmodules,
 
 } // namespace dunedaq
 
-#endif // DFMODULES_PLUGINS_DATAWRITER_HPP_
+#endif // DFMODULES_PLUGINS_DATAWRITERMODULE_HPP_
diff --git a/plugins/FakeDataProdModule.cpp b/plugins/FakeDataProdModule.cpp
index ee65dee9..ee355453 100644
--- a/plugins/FakeDataProdModule.cpp
+++ b/plugins/FakeDataProdModule.cpp
@@ -37,8 +37,7 @@ enum
   TLVL_TIME_SYNCS = 12
 };
 
-namespace dunedaq {
-namespace dfmodules {
+namespace dunedaq::dfmodules {
 
 FakeDataProdModule::FakeDataProdModule(const std::string& name)
   : dunedaq::appfwk::DAQModule(name)
@@ -155,7 +154,7 @@ FakeDataProdModule::do_timesync(std::atomic<bool>& running_flag)
                                 << " run=" << timesyncmsg.run_number << " seqno=" << timesyncmsg.sequence_number
                                 << " source_id=" << timesyncmsg.source_id;
     try {
-      sender_ptr->send(std::move(timesyncmsg), std::chrono::milliseconds(500));
+      sender_ptr->send(std::move(timesyncmsg), std::chrono::milliseconds(500)); // NOLINT(performance-move-const-arg)
       ++sent_count;
     } catch (ers::Issue& excpt) {
       ers::warning(TimeSyncTransmissionFailed(ERS_HERE, get_name(), m_timesync_id, excpt));
@@ -215,7 +214,6 @@ FakeDataProdModule::process_data_request(dfmessages::DataRequest& data_request)
   TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << get_name() << ": finishing processing request " << data_request.request_number;
 }
 
-} // namespace dfmodules
-} // namespace dunedaq
+} // namespace dunedaq::dfmodules
 
 DEFINE_DUNE_DAQ_MODULE(dunedaq::dfmodules::FakeDataProdModule)
diff --git a/plugins/FakeDataProdModule.hpp b/plugins/FakeDataProdModule.hpp
index de9c12ad..e189c70b 100644
--- a/plugins/FakeDataProdModule.hpp
+++ b/plugins/FakeDataProdModule.hpp
@@ -6,8 +6,8 @@
  * received with this code.
  */
 
-#ifndef DFMODULES_PLUGINS_FAKEDATAPROD_HPP_
-#define DFMODULES_PLUGINS_FAKEDATAPROD_HPP_
+#ifndef DFMODULES_PLUGINS_FAKEDATAPRODMODULE_HPP_
+#define DFMODULES_PLUGINS_FAKEDATAPRODMODULE_HPP_
 
 #include "daqdataformats/Fragment.hpp"
 #include "dfmessages/DataRequest.hpp"
@@ -99,4 +99,4 @@ class FakeDataProdModule : public dunedaq::appfwk::DAQModule
 } // namespace dfmodules
 } // namespace dunedaq
 
-#endif // DFMODULES_PLUGINS_FAKEDATAPROD_HPP_
+#endif // DFMODULES_PLUGINS_FAKEDATAPRODMODULE_HPP_
diff --git a/plugins/FragmentAggregatorModule.cpp b/plugins/FragmentAggregatorModule.cpp
index 7329ef69..12fb9f81 100644
--- a/plugins/FragmentAggregatorModule.cpp
+++ b/plugins/FragmentAggregatorModule.cpp
@@ -21,10 +21,13 @@
 #include "iomanager/IOManager.hpp"
 
 #include <iostream>
+#include <limits>
+#include <memory>
 #include <string>
+#include <tuple>
+#include <utility>
 
-namespace dunedaq {
-namespace dfmodules {
+namespace dunedaq::dfmodules {
 
 FragmentAggregatorModule::FragmentAggregatorModule(const std::string& name)
   : DAQModule(name)
@@ -75,6 +78,7 @@ FragmentAggregatorModule::generate_opmon_data()
 {
   if (m_data_requests_processed > 0) {
     opmon::FragmentAggregatorTimeInfo dr_times;
+    // NOLINTNEXTLINE(build/unsigned)
     dr_times.set_min_us(m_data_requests_time_min_us.exchange(std::numeric_limits<uint64_t>::max()));
     dr_times.set_max_us(m_data_requests_time_max_us.exchange(0));
     dr_times.set_average_us(m_data_requests_time_average_us.exchange(0) / m_data_requests_processed);
@@ -83,6 +87,7 @@ FragmentAggregatorModule::generate_opmon_data()
 
   if (m_fragments_processed > 0) {
     opmon::FragmentAggregatorTimeInfo frag_times;
+    // NOLINTNEXTLINE(build/unsigned)
     frag_times.set_min_us(m_fragments_time_min_us.exchange(std::numeric_limits<uint64_t>::max()));
     frag_times.set_max_us(m_fragments_time_max_us.exchange(0));
     frag_times.set_average_us(m_fragments_time_average_us.exchange(0) / m_fragments_processed);
@@ -119,9 +124,11 @@ FragmentAggregatorModule::do_start(const CommandData_t& /* args */)
   m_fragments_incomplete.store(0);
   m_fragments_invalid.store(0);
   m_fragments_time_average_us.store(0);
+  // NOLINTNEXTLINE(build/unsigned)
   m_fragments_time_min_us.store(std::numeric_limits<uint64_t>::max());
   m_fragments_time_max_us.store(0);
   m_data_requests_time_average_us.store(0);
+  // NOLINTNEXTLINE(build/unsigned)
   m_data_requests_time_min_us.store(std::numeric_limits<uint64_t>::max());
   m_data_requests_time_max_us.store(0);
 
@@ -132,7 +139,7 @@ FragmentAggregatorModule::do_start(const CommandData_t& /* args */)
   // the first data-taking run in a DAQ session. Such delays can lead to undesirable
   // system behavior like trigger inhibits.
   auto iom = iomanager::IOManager::get();
-  for (auto trb_conn : m_trb_conn_ids) {
+  for (auto const& trb_conn : m_trb_conn_ids) {
     auto sender = iom->get_sender<std::unique_ptr<daqdataformats::Fragment>>(trb_conn);
     if (sender != nullptr) {
       bool is_ready = sender->is_ready_for_sending(std::chrono::milliseconds(100));
@@ -265,14 +272,13 @@ FragmentAggregatorModule::process_fragment(std::unique_ptr<daqdataformats::Fragm
   }
 }
 
-uint64_t
+uint64_t // NOLINT(build/unsigned)
 FragmentAggregatorModule::get_current_time_us()
 {
   return std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now().time_since_epoch())
     .count();
 }
 
-} // namespace dfmodules
-} // namespace dunedaq
+} // namespace dunedaq::dfmodules
 
 DEFINE_DUNE_DAQ_MODULE(dunedaq::dfmodules::FragmentAggregatorModule)
diff --git a/plugins/FragmentAggregatorModule.hpp b/plugins/FragmentAggregatorModule.hpp
index 68cd54a5..9d7668cb 100644
--- a/plugins/FragmentAggregatorModule.hpp
+++ b/plugins/FragmentAggregatorModule.hpp
@@ -7,8 +7,8 @@
  * received with this code.
  */
 
-#ifndef DFMODULES_PLUGINS_FRAGMENTAGGREGATOR_HPP_
-#define DFMODULES_PLUGINS_FRAGMENTAGGREGATOR_HPP_
+#ifndef DFMODULES_PLUGINS_FRAGMENTAGGREGATORMODULE_HPP_
+#define DFMODULES_PLUGINS_FRAGMENTAGGREGATORMODULE_HPP_
 
 #include "daqdataformats/Fragment.hpp"
 #include "daqdataformats/SourceID.hpp"
@@ -22,9 +22,11 @@
 
 #include <atomic>
 #include <map>
+#include <memory>
 #include <mutex>
 #include <string>
 #include <tuple>
+#include <vector>
 
 namespace dunedaq {
 /**
@@ -34,9 +36,9 @@ ERS_DECLARE_ISSUE(dfmodules,                  ///< Namespace
                   UnknownFragmentDestination, ///< Issue class name
                   "Could not find a valid destination for sending Fragment with trigger number: "
                     << trg_num << " sequence number: " << seq_num << " from DLH " << src, ///< Message
-                  ((uint64_t)trg_num)                                                     ///< Message parameters
-                  ((uint16_t)seq_num)                                                     ///< Message parameters
-                  ((daqdataformats::SourceID)src)                                         ///< Message parameters
+                  ((uint64_t)trg_num)             ///< Message parameters // NOLINT(build/unsigned)
+                  ((uint16_t)seq_num)             ///< Message parameters // NOLINT(build/unsigned)
+                  ((daqdataformats::SourceID)src) ///< Message parameters
 )
 
 ERS_DECLARE_ISSUE(dfmodules,         ///< Namespace
@@ -72,16 +74,16 @@ class FragmentAggregatorModule : public dunedaq::appfwk::DAQModule
   // Input and Output Connection names
   std::string m_data_req_input;
   std::string m_fragment_input;
-  std::map<int, std::string> m_producer_conn_ids;
+  std::map<uint32_t, std::string> m_producer_conn_ids; // NOLINT(build/unsigned)
   std::vector<std::string> m_trb_conn_ids;
 
   std::chrono::milliseconds m_fragment_send_timeout;
 
   // Opmon
-  uint64_t get_current_time_us();
-  uint64_t m_timestamp_before_dr;
-  uint64_t m_timestamp_before_frag;
-  using metric_counter_type = uint64_t;
+  uint64_t get_current_time_us();       // NOLINT(build/unsigned)
+  uint64_t m_timestamp_before_dr;       // NOLINT(build/unsigned)
+  uint64_t m_timestamp_before_frag;     // NOLINT(build/unsigned)
+  using metric_counter_type = uint64_t; // NOLINT(build/unsigned)
   std::atomic<metric_counter_type> m_data_requests_received{ 0 };
   std::atomic<metric_counter_type> m_data_requests_processed{ 0 };
   std::atomic<metric_counter_type> m_data_requests_failed{ 0 };
@@ -107,4 +109,4 @@ class FragmentAggregatorModule : public dunedaq::appfwk::DAQModule
 } // namespace dfmodules
 } // namespace dunedaq
 
-#endif // DFMODULES_PLUGINS_FRAGMENTAGGREGATOR_HPP_
+#endif // DFMODULES_PLUGINS_FRAGMENTAGGREGATORMODULE_HPP_
diff --git a/plugins/HDF5DataStore.hpp b/plugins/HDF5DataStore.hpp
index 85061d2e..55de73c3 100644
--- a/plugins/HDF5DataStore.hpp
+++ b/plugins/HDF5DataStore.hpp
@@ -42,7 +42,6 @@ HDF5DataStore::open_new_file(const std::string& unique_filename)
 
   auto& file_handle{ get_file_handle() };
   try {
-
     file_handle.reset(
       new hdf5libs::HDF5RawDataFile(unique_filename,
                                     get_run_number(),
diff --git a/plugins/TPStreamWriterModule.cpp b/plugins/TPStreamWriterModule.cpp
index 66006943..1f6ac4b1 100644
--- a/plugins/TPStreamWriterModule.cpp
+++ b/plugins/TPStreamWriterModule.cpp
@@ -23,6 +23,7 @@
 
 #include "boost/date_time/posix_time/posix_time.hpp"
 
+#include <algorithm>
 #include <chrono>
 #include <memory>
 #include <sstream>
@@ -36,8 +37,7 @@ enum
   TLVL_CONFIG = 7,
 };
 
-namespace dunedaq {
-namespace dfmodules {
+namespace dunedaq::dfmodules {
 
 TPStreamWriterModule::TPStreamWriterModule(const std::string& name)
   : dunedaq::appfwk::DAQModule(name)
@@ -96,7 +96,7 @@ TPStreamWriterModule::do_conf(const CommandData_t&)
   m_accumulation_inactivity_time_before_write = std::chrono::milliseconds(
     static_cast<int>(1000 * m_tp_writer_conf->get_tp_accumulation_inactivity_time_before_write_sec()));
   m_warn_user_when_tardy_tps_are_discarded = m_tp_writer_conf->get_warn_user_when_tardy_tps_are_discarded();
-  m_accumulation_interval_seconds = ((double)m_accumulation_interval_ticks) / 62500000.0;
+  m_accumulation_interval_seconds = static_cast<double>(m_accumulation_interval_ticks) / 62500000.0;
 
   // create the DataStore instance here
   try {
@@ -110,7 +110,7 @@ TPStreamWriterModule::do_conf(const CommandData_t&)
   }
 
   // ensure that we have a valid dataWriter instance
-  if (m_data_writer.get() == nullptr) {
+  if (m_data_writer == nullptr) {
     throw InvalidDataWriterModule(ERS_HERE, get_name());
   }
 
@@ -188,6 +188,7 @@ TPStreamWriterModule::do_work(std::atomic<bool>& running_flag)
   auto start_time = steady_clock::now();
   daqdataformats::timestamp_t first_timestamp = 0;
   daqdataformats::timestamp_t last_timestamp = 0;
+  daqdataformats::timestamp_t current_timestamp = 0;
 
   TPBundleHandler tp_bundle_handler(
     m_accumulation_interval_ticks, m_run_number, m_accumulation_inactivity_time_before_write);
@@ -219,6 +220,7 @@ TPStreamWriterModule::do_work(std::atomic<bool>& running_flag)
         continue;
       }
       ++m_tpsets_with_tps;
+      current_timestamp = tpset.start_time;
 
       size_t num_tps_in_tpset = tpset.objects.size();
       tp_bundle_handler.add_tpset(std::move(tpset));
@@ -311,22 +313,22 @@ TPStreamWriterModule::do_work(std::atomic<bool>& running_flag)
     }
 
     if (first_timestamp == 0) {
-      first_timestamp = tpset.start_time;
+      first_timestamp = current_timestamp;
     }
-    last_timestamp = tpset.start_time;
+    last_timestamp = current_timestamp;
   } // while(running)
 
   auto end_time = steady_clock::now();
   auto time_ms = duration_cast<milliseconds>(end_time - start_time).count();
-  float rate_hz = 1e3 * static_cast<float>(n_tpset_received) / time_ms;
-  float inferred_clock_frequency = 1e3 * (last_timestamp - first_timestamp) / time_ms;
+  auto rate_hz = 1e3 * n_tpset_received / static_cast<double>(time_ms);
+  auto inferred_clock_frequency =
+    1e3 * static_cast<double>(last_timestamp - first_timestamp) / static_cast<double>(time_ms);
 
   TLOG() << "Received " << n_tpset_received << " TPSets in " << time_ms << "ms. " << rate_hz
          << " TPSet/s. Inferred clock frequency " << inferred_clock_frequency << "Hz";
   TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << get_name() << ": Exiting do_work() method";
-} // NOLINT Function length
+} // NOLINT(readability/fn_size)
 
-} // namespace dfmodules
-} // namespace dunedaq
+} // namespace dunedaq::dfmodules
 
 DEFINE_DUNE_DAQ_MODULE(dunedaq::dfmodules::TPStreamWriterModule)
diff --git a/plugins/TPStreamWriterModule.hpp b/plugins/TPStreamWriterModule.hpp
index d1979578..4d07b910 100644
--- a/plugins/TPStreamWriterModule.hpp
+++ b/plugins/TPStreamWriterModule.hpp
@@ -8,8 +8,8 @@
  * received with this code.
  */
 
-#ifndef DFMODULES_PLUGINS_TPSTREAMWRITER_HPP_
-#define DFMODULES_PLUGINS_TPSTREAMWRITER_HPP_
+#ifndef DFMODULES_PLUGINS_TPSTREAMWRITERMODULE_HPP_
+#define DFMODULES_PLUGINS_TPSTREAMWRITERMODULE_HPP_
 
 #include "dfmodules/DataStore.hpp"
 
@@ -116,8 +116,8 @@ ERS_DECLARE_ISSUE_BASE(dfmodules,
                        "Tardy TPs from SourceIDs [" << sid_list << "] were discarded from TimeSlice number " << trnum
                                                     << " (~" << sec_too_late << " sec too late)",
                        ((std::string)name),
-                       ((std::string)sid_list)((size_t)trnum)((float)sec_too_late))
+                       ((std::string)sid_list)((size_t)trnum)((float)sec_too_late)) // NOLINT(readability/casting)
 
 } // namespace dunedaq
 
-#endif // DFMODULES_PLUGINS_TPSTREAMWRITER_HPP_
+#endif // DFMODULES_PLUGINS_TPSTREAMWRITERMODULE_HPP_
diff --git a/plugins/TRBModule.cpp b/plugins/TRBModule.cpp
index 379ebd30..9b8c7a7f 100644
--- a/plugins/TRBModule.cpp
+++ b/plugins/TRBModule.cpp
@@ -34,6 +34,7 @@
 #include <limits>
 #include <memory>
 #include <numeric>
+#include <set>
 #include <string>
 #include <thread>
 #include <utility>
@@ -52,8 +53,7 @@ enum
   TLVL_FRAGMENT_RECEIVE = 22
 };
 
-namespace dunedaq {
-namespace dfmodules {
+namespace dunedaq::dfmodules {
 
 using daqdataformats::TriggerRecordStatusBits;
 
@@ -307,6 +307,7 @@ TRBModule::flush_trigger_records()
   // create all possible trigger record
   std::vector<TriggerId> triggers;
   for (const auto& entry : m_trigger_records) {
+    // NOLINTNEXTLINE(performance-inefficient-vector-operation)
     triggers.push_back(entry.first);
   }
 
@@ -505,7 +506,7 @@ TRBModule::create_trigger_records_and_dispatch(const dfmessages::TriggerDecision
       end = component.window_end;
   }
 
-  daqdataformats::timestamp_diff_t tot_width = end - begin;
+  auto tot_width = static_cast<daqdataformats::timestamp_diff_t>(end - begin);
   daqdataformats::sequence_number_t max_sequence_number =
     (m_max_sequence_length > 0 && tot_width > 0) ? ((tot_width - 1) / m_max_sequence_length) : 0;
 
@@ -643,7 +644,8 @@ TRBModule::dispatch_data_requests(dfmessages::DataRequest dr, const daqdataforma
 
     // send data request into the corresponding connection
     try {
-      sender->send(std::move(dr), m_dreq_queue_timeout);
+      dfmessages::DataRequest dr_copy = dr;
+      sender->send(std::move(dr_copy), m_dreq_queue_timeout);
       wasSentSuccessfully = true;
       ++m_generated_data_requests;
     } catch (const ers::Issue& excpt) {
@@ -661,6 +663,7 @@ TRBModule::send_trigger_record(const TriggerId& id)
 {
 
   trigger_record_ptr_t temp_record(extract_trigger_record(id));
+  size_t record_size = temp_record->get_fragments_ref().size();
 
   // Send to monitoring, if needed
 
@@ -685,7 +688,7 @@ TRBModule::send_trigger_record(const TriggerId& id)
             // HACK to copy the trigger record so we can send it off to monitoring
             auto trigger_record_bytes =
               serialization::serialize(temp_record, serialization::SerializationType::kMsgPack);
-            trigger_record_ptr_t record_copy = serialization::deserialize<trigger_record_ptr_t>(trigger_record_bytes);
+            auto record_copy = serialization::deserialize<trigger_record_ptr_t>(trigger_record_bytes);
             iom->get_sender<trigger_record_ptr_t>(it->data_destination)
               ->send(std::move(record_copy), m_tr_queue_timeout);
             ++m_trmon_sent_counter;
@@ -717,7 +720,7 @@ TRBModule::send_trigger_record(const TriggerId& id)
 
   if (!wasSentSuccessfully) {
     ++m_abandoned_trigger_records;
-    m_lost_fragments += temp_record->get_fragments_ref().size();
+    m_lost_fragments += record_size;
     ers::error(dunedaq::dfmodules::AbandonedTriggerDecision(ERS_HERE, id));
   }
 
@@ -768,7 +771,6 @@ TRBModule::check_stale_requests()
   return book_updates;
 }
 
-} // namespace dfmodules
-} // namespace dunedaq
+} // namespace dunedaq::dfmodules
 
 DEFINE_DUNE_DAQ_MODULE(dunedaq::dfmodules::TRBModule)
diff --git a/plugins/TRBModule.hpp b/plugins/TRBModule.hpp
index abb532d8..9c5c3de0 100644
--- a/plugins/TRBModule.hpp
+++ b/plugins/TRBModule.hpp
@@ -6,8 +6,8 @@
  * received with this code.
  */
 
-#ifndef DFMODULES_PLUGINS_TRIGGERRECORDBUILDER_HPP_
-#define DFMODULES_PLUGINS_TRIGGERRECORDBUILDER_HPP_
+#ifndef DFMODULES_PLUGINS_TRBMODULE_HPP_
+#define DFMODULES_PLUGINS_TRBMODULE_HPP_
 
 #include "appmodel/ReadoutApplication.hpp"
 #include "appmodel/SmartDaqApplication.hpp"
@@ -92,7 +92,8 @@ struct TriggerId
 
   friend std::istream& operator>>(std::istream& in, TriggerId& id)
   {
-    char t1, t2;
+    char t1 = 0;
+    char t2 = 0;
     in >> id.trigger_number >> t1 >> id.sequence_number >> t2 >> id.run_number;
     return in;
   }
@@ -158,8 +159,10 @@ ERS_DECLARE_ISSUE(dfmodules,               ///< Namespace
                   "sending incomplete TriggerRecord downstream "
                     << optional_stop_time_phrase << " (trigger/run_number=" << id << ", " << num_frags_present << " of "
                     << num_components_requested << " fragments included)",
-                  ((std::string)optional_stop_time_phrase)((dfmodules::TriggerId)id)((int)num_frags_present)(
-                    (int)num_components_requested) ///< Message parameters
+                  ((std::string)optional_stop_time_phrase) ///< Message parameters // NOLINT
+                  ((dfmodules::TriggerId)id)               ///< Message parameters // NOLINT
+                  ((int)num_frags_present)                 ///< Message parameters // NOLINT
+                  ((uint64_t)num_components_requested)     ///< Message parameters // NOLINT
 )
 
 /**
@@ -276,6 +279,7 @@ class TRBModule : public dunedaq::appfwk::DAQModule
   std::list<dfmessages::TRMonRequest> m_mon_requests;
 
   // book related metrics
+  // NOLINTNEXTLINE(build/unsigned)
   using metric_counter_type = uint64_t; // decltype(triggerrecordbuilderinfo::Info::pending_trigger_decisions);
   mutable std::atomic<metric_counter_type> m_trigger_decisions_counter = { 0 }; // currently
   mutable std::atomic<metric_counter_type> m_fragment_counter = { 0 };          // currently
@@ -310,4 +314,4 @@ class TRBModule : public dunedaq::appfwk::DAQModule
 } // namespace dfmodules
 } // namespace dunedaq
 
-#endif // DFMODULES_PLUGINS_TRIGGERRECORDBUILDER_HPP_
+#endif // DFMODULES_PLUGINS_TRBMODULE_HPP_
diff --git a/plugins/TRMonRequestorModule.cpp b/plugins/TRMonRequestorModule.cpp
index 5f9217b9..89f67410 100755
--- a/plugins/TRMonRequestorModule.cpp
+++ b/plugins/TRMonRequestorModule.cpp
@@ -208,7 +208,7 @@ TRMonRequestorModule::send_trmon_request()
   }
 
   dfmessages::TRMonRequest req;
-  req.request_number = ++m_current_request_number;
+  req.request_number = ++m_current_request_number; // NOLINT(runtime/increment_decrement)
   req.trigger_type_mask = m_trigger_type_mask;
   req.run_number = *m_run_number;
   req.data_destination = m_reply_connection;
diff --git a/plugins/TRMonRequestorModule.hpp b/plugins/TRMonRequestorModule.hpp
index 46b06716..d432fd3b 100644
--- a/plugins/TRMonRequestorModule.hpp
+++ b/plugins/TRMonRequestorModule.hpp
@@ -87,6 +87,6 @@ class TRMonRequestorModule : public appfwk::DAQModule
   using metric_counter_t = std::remove_const<const_metric_counter_t>::type;
   std::atomic<metric_counter_t> m_trigger_records_requested{ 0 };
 };
-}
+} // namespace dunedaq::dfmodules
 
 #endif // DFMODULES_PLUGINS_TRMONREQUESTORMODULE_HPP_
diff --git a/schema/dfmodules/opmon/TPStreamWriter.proto b/schema/dfmodules/opmon/TPStreamWriter.proto
index 44ea2a45..4ce0b006 100644
--- a/schema/dfmodules/opmon/TPStreamWriter.proto
+++ b/schema/dfmodules/opmon/TPStreamWriter.proto
@@ -14,7 +14,7 @@ message TPStreamWriterInfo {
   uint64 total_tps_written = 17;  // count of TPs that have been written out in the current run
   uint64 total_tps_discarded = 18;// count of TPs that have been discarded in the current run
 
-uint64 tardy_timeslice_max_seconds = 21; //incremental max amount of time that a TimeSlice was tardy
+  double tardy_timeslice_max_seconds = 21; //incremental max amount of time that a TimeSlice was tardy
 
   uint64 timeslices_written = 31; // incremental count of TimeSlices that have been written out
   uint64 bytes_output = 32;       // incremental number of bytes that have been written out
diff --git a/src/TPBundleHandler.cpp b/src/TPBundleHandler.cpp
index ace111fa..338aae49 100644
--- a/src/TPBundleHandler.cpp
+++ b/src/TPBundleHandler.cpp
@@ -19,8 +19,7 @@
 #include <utility>
 #include <vector>
 
-namespace dunedaq {
-namespace dfmodules {
+namespace dunedaq::dfmodules {
 
 void
 TimeSliceAccumulator::add_tpset(trigger::TPSet&& tpset)
@@ -98,6 +97,7 @@ TimeSliceAccumulator::get_timeslice()
     frag->set_window_begin(m_begin_time);
     frag->set_window_end(m_end_time);
     frag->set_element_id(sourceid);
+    // NOLINTNEXTLINE(build/unsigned)
     frag->set_detector_id(static_cast<uint16_t>(detdataformats::DetID::Subdetector::kDAQ));
     frag->set_type(daqdataformats::FragmentType::kTriggerPrimitive);
 
@@ -140,7 +140,7 @@ TPBundleHandler::add_tpset(trigger::TPSet&& tpset)
     if (!m_one_or_more_time_slices_have_aged_out) {
       TLOG() << "Updating the slice numbers of existing accumulators by " << (1 - diff);
       for (auto& [local_tsidx, local_accum] : m_timeslice_accumulators) {
-        local_accum.update_slice_number(1 - diff);
+        local_accum.update_slice_number(static_cast<int>(1 - diff));
       }
       m_slice_index_offset -= (1 - diff);
     } else {
@@ -208,6 +208,7 @@ TPBundleHandler::get_all_remaining_timeslices()
   std::vector<std::unique_ptr<daqdataformats::TimeSlice>> list_of_timeslices;
 
   for (auto& [tsidx, accum] : m_timeslice_accumulators) {
+    // NOLINTNEXTLINE(performance-inefficient-vector-operation)
     list_of_timeslices.push_back(accum.get_timeslice());
   }
 
@@ -219,5 +220,4 @@ TPBundleHandler::get_all_remaining_timeslices()
   return list_of_timeslices;
 }
 
-} // namespace dfmodules
-} // namespace dunedaq
+} // namespace dunedaq::dfmodules
diff --git a/src/TriggerInhibitAgent.cpp b/src/TriggerInhibitAgent.cpp
index 18288fe0..57cde6b2 100644
--- a/src/TriggerInhibitAgent.cpp
+++ b/src/TriggerInhibitAgent.cpp
@@ -25,8 +25,7 @@ enum
   TLVL_WORK_STEPS = 10
 };
 
-namespace dunedaq {
-namespace dfmodules {
+namespace dunedaq::dfmodules {
 
 TriggerInhibitAgent::TriggerInhibitAgent(const std::string& parent_name,
                                          std::shared_ptr<trigdecreceiver_t> our_input,
@@ -139,7 +138,7 @@ TriggerInhibitAgent::do_work(std::atomic<bool>& running_flag)
         TLOG_DEBUG(TLVL_WORK_STEPS) << get_name() << ": Pushing a TriggerInhibit message with busy state set to "
                                     << inhibit_message.busy << " onto the output queue";
         try {
-          m_trigger_inhibit_sender->send(std::move(inhibit_message), m_queue_timeout);
+          m_trigger_inhibit_sender->send(std::move(inhibit_message), m_queue_timeout); // NOLINT
           ++sent_message_count;
 #if 0
           // temporary logging
@@ -174,5 +173,4 @@ TriggerInhibitAgent::do_work(std::atomic<bool>& running_flag)
   TLOG_DEBUG(TLVL_ENTER_EXIT_METHODS) << get_name() << ": Exiting do_work() method";
 }
 
-} // namespace dfmodules
-} // namespace dunedaq
+} // namespace dunedaq::dfmodules
diff --git a/src/TriggerRecordBuilderData.cpp b/src/TriggerRecordBuilderData.cpp
index bd13b9c0..74da6174 100644
--- a/src/TriggerRecordBuilderData.cpp
+++ b/src/TriggerRecordBuilderData.cpp
@@ -15,6 +15,7 @@
 #include "logging/Logging.hpp"
 
 #include <limits>
+#include <list>
 #include <memory>
 #include <string>
 #include <utility>
@@ -24,8 +25,7 @@
  */
 #define TRACE_NAME "TRBData" // NOLINT
 
-namespace dunedaq {
-namespace dfmodules {
+namespace dunedaq::dfmodules {
 
 TriggerRecordBuilderData::TriggerRecordBuilderData(std::string connection_name, size_t busy_threshold)
   : m_busy_threshold(busy_threshold)
@@ -194,12 +194,13 @@ TriggerRecordBuilderData::generate_opmon_data()
   auto completed_trigger_records = m_complete_counter.exchange(0);
   if (completed_trigger_records > 0) {
     m_last_average_time =
-      1e-6 * 0.5 * (m_min_complete_time.exchange(0) + m_max_complete_time.exchange(0)); // in seconds
+      1e-6 * 0.5 * static_cast<double>(m_min_complete_time.exchange(0) + m_max_complete_time.exchange(0)); // in seconds
   }
 
   if (m_last_average_time > 0.) {
     // prediction rate metrics
-    info.set_capacity_rate(0.5 * (m_busy_threshold.load() + m_free_threshold.load()) / m_last_average_time);
+    info.set_capacity_rate(0.5 * static_cast<double>(m_busy_threshold.load() + m_free_threshold.load()) /
+                           m_last_average_time);
   }
 
   publish(std::move(info));
@@ -222,5 +223,4 @@ TriggerRecordBuilderData::average_latency(std::chrono::steady_clock::time_point
   return sum / count;
 }
 
-} // namespace dfmodules
-} // namespace dunedaq
+} // namespace dunedaq::dfmodules
diff --git a/src/dfmodules/TriggerInhibitAgent.hpp b/src/dfmodules/TriggerInhibitAgent.hpp
index 4985e724..df96684c 100644
--- a/src/dfmodules/TriggerInhibitAgent.hpp
+++ b/src/dfmodules/TriggerInhibitAgent.hpp
@@ -27,8 +27,7 @@
 #include <string>
 #include <thread>
 
-namespace dunedaq {
-namespace dfmodules {
+namespace dunedaq::dfmodules {
 
 /**
  * @brief
@@ -82,7 +81,6 @@ class TriggerInhibitAgent : public utilities::NamedObject
   std::atomic<daqdataformats::trigger_number_t> m_trigger_number_at_start_of_processing_chain;
   std::atomic<daqdataformats::trigger_number_t> m_trigger_number_at_end_of_processing_chain;
 };
-} // namespace dfmodules
-} // namespace dunedaq
+} // namespace dunedaq::dfmodules
 
 #endif // DFMODULES_SRC_DFMODULES_TRIGGERINHIBITAGENT_HPP_
diff --git a/src/dfmodules/TriggerRecordBuilderData.hpp b/src/dfmodules/TriggerRecordBuilderData.hpp
index f8e64913..42ea4928 100644
--- a/src/dfmodules/TriggerRecordBuilderData.hpp
+++ b/src/dfmodules/TriggerRecordBuilderData.hpp
@@ -121,7 +121,7 @@ class TriggerRecordBuilderData : public opmonlib::MonitorableObject
   using metric_t = dunedaq::dfmodules::opmon::DFApplicationInfo;
   using const_time_counter_t = std::invoke_result<decltype(&metric_t::min_time_since_assignment), metric_t>::type;
   using time_counter_t = std::remove_const<const_time_counter_t>::type;
-  std::atomic<uint32_t> m_complete_counter{ 0 };
+  std::atomic<uint32_t> m_complete_counter{ 0 }; // NOLINT(build/unsigned)
   std::atomic<time_counter_t> m_min_complete_time{ std::numeric_limits<time_counter_t>::max() },
     m_max_complete_time{ 0 }; // in us
   double m_last_average_time{ 0. };
diff --git a/unittest/DFOModule_test.cxx b/unittest/DFOModule_test.cxx
index 690ca08a..f7b14d4f 100644
--- a/unittest/DFOModule_test.cxx
+++ b/unittest/DFOModule_test.cxx
@@ -24,6 +24,7 @@
 #include <map>
 #include <memory>
 #include <string>
+#include <utility>
 #include <vector>
 
 using namespace dunedaq::dfmodules;
diff --git a/unittest/HDF5Write_test.cxx b/unittest/HDF5Write_test.cxx
index a53207e7..af6f56a0 100644
--- a/unittest/HDF5Write_test.cxx
+++ b/unittest/HDF5Write_test.cxx
@@ -109,6 +109,7 @@ create_trigger_record(int trig_num, int fragment_size, int element_count)
     fh.sequence_number = 0;
     fh.fragment_type =
       static_cast<dunedaq::daqdataformats::fragment_type_t>(dunedaq::daqdataformats::FragmentType::kWIB);
+    // NOLINTNEXTLINE(build/unsigned)
     fh.detector_id = static_cast<uint16_t>(dunedaq::detdataformats::DetID::Subdetector::kHD_TPC);
     fh.element_id = dunedaq::daqdataformats::SourceID(stype_to_use, ele_num);
     std::unique_ptr<dunedaq::daqdataformats::Fragment> frag_ptr(
@@ -125,7 +126,7 @@ create_trigger_record(int trig_num, int fragment_size, int element_count)
 
 struct CfgFixture
 {
-  CfgFixture(std::string sessionName)
+  explicit CfgFixture(std::string sessionName)
   {
     TLOG_DEBUG(4) << "Creating CfgFixture";
     setenv("DUNEDAQ_SESSION", sessionName.c_str(), 1);
diff --git a/unittest/SummaryTextWrite_test.cxx b/unittest/SummaryTextWrite_test.cxx
index 39dc004b..c2ed7ae9 100644
--- a/unittest/SummaryTextWrite_test.cxx
+++ b/unittest/SummaryTextWrite_test.cxx
@@ -169,10 +169,11 @@ BOOST_AUTO_TEST_CASE(CheckDerivation)
   auto data_store_ptr = make_data_store(data_store_conf->get_type(), data_store_conf->UID(), cfg.cfgMgr, "dwm-01");
   BOOST_REQUIRE(data_store_ptr != nullptr);
 
-  const auto stub_data_store_ptr{ dynamic_cast<const dunedaq::dfmodules::SummaryTextDataStore*>(
-    data_store_ptr.get()) }; // NOLINT(runtime/rtti)
+  // NOLINTNEXTLINE(runtime/rtti)
+  const auto stub_data_store_ptr{ dynamic_cast<const dunedaq::dfmodules::SummaryTextDataStore*>(data_store_ptr.get()) };
   BOOST_REQUIRE(stub_data_store_ptr != nullptr);
 
+  // NOLINTNEXTLINE
   BOOST_REQUIRE_EQUAL(stub_data_store_ptr->get_derivval(), 773); // 773 should be the value in the config
 }
 
diff --git a/unittest/TriggerRecordBuilderData_test.cxx b/unittest/TriggerRecordBuilderData_test.cxx
index a42b6631..7c22a463 100644
--- a/unittest/TriggerRecordBuilderData_test.cxx
+++ b/unittest/TriggerRecordBuilderData_test.cxx
@@ -15,6 +15,7 @@
 #include "boost/test/unit_test.hpp"
 
 #include <chrono>
+#include <memory>
 #include <thread>
 #include <utility>