diff --git a/core/include/minifi-cpp/core/ProcessSession.h b/core/include/minifi-cpp/core/ProcessSession.h
index cbc74f7323..6bd971813f 100644
--- a/core/include/minifi-cpp/core/ProcessSession.h
+++ b/core/include/minifi-cpp/core/ProcessSession.h
@@ -32,7 +32,6 @@
 
 #include "ProcessContext.h"
 #include "core/logging/LoggerFactory.h"
-#include "core/Deprecated.h"
 #include "FlowFile.h"
 #include "WeakReference.h"
 #include "minifi-cpp/provenance/Provenance.h"
diff --git a/extension-utils/include/core/Deprecated.h b/extension-utils/include/core/Deprecated.h
deleted file mode 100644
index 4dd7e54a25..0000000000
--- a/extension-utils/include/core/Deprecated.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/**
-
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#ifndef LIBMINIFI_INCLUDE_CORE_DEPRECATED_H_
-#define LIBMINIFI_INCLUDE_CORE_DEPRECATED_H_
-
-#ifdef _MSC_VER
-#define DEPRECATED(v, ev) __declspec(deprecated)
-#elif defined(__GNUC__) | defined(__clang__)
-#define DEPRECATED(v, ev) __attribute__((__deprecated__))
-#else
-#define DEPRECATED(v, ev)
-#endif
-
-#endif /* LIBMINIFI_INCLUDE_CORE_DEPRECATED_H_ */
diff --git a/extension-utils/include/utils/OpenTelemetryLogDataModelUtils.h b/extension-utils/include/utils/OpenTelemetryLogDataModelUtils.h
index c9c639116b..d46d5598a5 100644
--- a/extension-utils/include/utils/OpenTelemetryLogDataModelUtils.h
+++ b/extension-utils/include/utils/OpenTelemetryLogDataModelUtils.h
@@ -20,7 +20,7 @@
 #include <string>
 
 #include "rapidjson/document.h"
-#include "NetworkInterfaceInfo.h"
+#include "utils/net/NetworkInterfaceInfo.h"
 #include "utils/net/DNS.h"
 
 namespace org::apache::nifi::minifi::utils {
diff --git a/extension-utils/include/utils/StagingQueue.h b/extension-utils/include/utils/StagingQueue.h
deleted file mode 100644
index 6751c53010..0000000000
--- a/extension-utils/include/utils/StagingQueue.h
+++ /dev/null
@@ -1,190 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <mutex>
-#include <atomic>
-#include <utility>
-#include "MinifiConcurrentQueue.h"
-
-namespace org {
-namespace apache {
-namespace nifi {
-namespace minifi {
-namespace utils {
-
-namespace internal {
-template<typename T>
-struct default_allocator {
-  T operator()(size_t max_size) const {
-    return T::allocate(max_size);
-  }
-};
-}  // namespace internal
-
-/**
- * Purpose: A FIFO container that allows chunked processing while trying to enforce
- * soft limits like max chunk size and max total size. The "head" chunk might be
- * modified in a thread-safe manner (usually appending to it) before committing it
- * thus making it available for dequeuing.
- */
-template<typename ActiveItem, typename Allocator = internal::default_allocator<ActiveItem>>
-class StagingQueue {
-  using Item = typename std::decay<decltype(std::declval<ActiveItem&>().commit())>::type;
-
-  static_assert(std::is_same<decltype(std::declval<const Allocator&>()(std::declval<size_t>())), ActiveItem>::value,
-      "Allocator::operator(size_t) must return an ActiveItem");
-  static_assert(std::is_same<decltype(std::declval<const Item&>().size()), size_t>::value,
-      "Item::size must return size_t");
-  static_assert(std::is_same<decltype(std::declval<const ActiveItem&>().size()), size_t>::value,
-      "ActiveItem::size must return size_t");
-
-  template<typename Functor, typename Arg, typename = void>
-  struct FunctorCallHelper;
-
-  template<typename Functor, typename Arg>
-  struct FunctorCallHelper<Functor, Arg, typename std::enable_if<std::is_same<decltype(std::declval<Functor>()(std::declval<Arg>())), bool>::value>::type> {
-    static bool call(Functor&& fn, Arg&& arg) {
-      return std::forward<Functor>(fn)(std::forward<Arg>(arg));
-    }
-  };
-
-  template<typename Functor, typename Arg>
-  struct FunctorCallHelper<Functor, Arg, typename std::enable_if<std::is_same<decltype(std::declval<Functor>()(std::declval<Arg>())), void>::value>::type> {
-    static bool call(Functor&& fn, Arg&& arg) {
-      std::forward<Functor>(fn)(std::forward<Arg>(arg));
-      return false;
-    }
-  };
-
-  static ActiveItem allocateActiveItem(const Allocator& allocator, size_t max_item_size) {
-    // max_size is a soft limit, i.e. reaching max_size is an indicator
-    // that that item should be committed, we cannot guarantee that only
-    // max_size content is in the item, since max_size is the "trigger limit",
-    // presumable each item would contain (at the trigger point) a little
-    // more than max_size content, that is the reasoning behind "* 3 / 2"
-    return allocator(max_item_size * 3 / 2);
-  }
-
- public:
-  StagingQueue(size_t max_size, size_t max_item_size, Allocator allocator = {})
-    : max_size_(max_size),
-      max_item_size_(max_item_size),
-      active_item_(allocateActiveItem(allocator, max_item_size)),
-      allocator_(allocator) {}
-
-  void commit() {
-    std::unique_lock<std::mutex> lock{active_item_mutex_};
-    if (active_item_.size() == 0) {
-      // nothing to commit
-      return;
-    }
-    commit(lock);
-  }
-
-  /**
-   * Allows thread-safe modification of the "live" instance.
-   * @tparam Functor
-   * @param fn callable which can modify the instance, should return true
-   * if it would like to force a commit
-   */
-  template<typename Functor>
-  void modify(Functor&& fn) {
-    std::unique_lock<std::mutex> lock{active_item_mutex_};
-    size_t original_size = active_item_.size();
-    bool should_commit = FunctorCallHelper<Functor, ActiveItem&>::call(std::forward<Functor>(fn), active_item_);
-    size_t new_size = active_item_.size();
-    if (new_size >= original_size) {
-      total_size_ += new_size - original_size;
-    } else {
-      total_size_ -= original_size - new_size;
-    }
-    if (should_commit || new_size > max_item_size_) {
-      commit(lock);
-    }
-  }
-
-  template<class Rep, class Period>
-  bool tryDequeue(Item& out, const std::chrono::duration<Rep, Period>& time) {
-    if (time == std::chrono::duration<Rep, Period>{0}) {
-      return tryDequeue(out);
-    }
-    if (queue_.dequeueWaitFor(out, time)) {
-      total_size_ -= out.size();
-      return true;
-    }
-    return false;
-  }
-
-  bool tryDequeue(Item& out) {
-    if (queue_.tryDequeue(out)) {
-      total_size_ -= out.size();
-      return true;
-    }
-    return false;
-  }
-
-  size_t getMaxSize() const {
-    return max_size_;
-  }
-
-  size_t getMaxItemSize() const {
-    return max_item_size_;
-  }
-
-  void discardOverflow() {
-    while (total_size_ > max_size_) {
-      Item item;
-      if (!queue_.tryDequeue(item)) {
-        break;
-      }
-      total_size_ -= item.size();
-    }
-  }
-
-  size_t size() const {
-    return total_size_;
-  }
-
-  size_t itemCount() const {
-    return queue_.size();
-  }
-
- private:
-  void commit(std::unique_lock<std::mutex>& /*lock*/) {
-    queue_.enqueue(active_item_.commit());
-    active_item_ = allocateActiveItem(allocator_, max_item_size_);
-  }
-
-  const size_t max_size_;
-  const size_t max_item_size_;
-  std::atomic<size_t> total_size_{0};
-
-  std::mutex active_item_mutex_;
-  ActiveItem active_item_;
-
-  const Allocator allocator_;
-
-  ConditionConcurrentQueue<Item> queue_;
-};
-
-}  // namespace utils
-}  // namespace minifi
-}  // namespace nifi
-}  // namespace apache
-}  // namespace org
diff --git a/extension-utils/src/Exception.cpp b/extension-utils/src/Exception.cpp
deleted file mode 100644
index c9e622077c..0000000000
--- a/extension-utils/src/Exception.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "Exception.h"
-
-#ifndef WIN32
-#include <cxxabi.h>
-#endif  // !WIN32
-
-#include <typeinfo>
-
-namespace org::apache::nifi::minifi {
-std::string getCurrentExceptionTypeName() {
-#ifndef WIN32
-  const std::type_info* exception_type = abi::__cxa_current_exception_type();
-  if (exception_type) {
-    return exception_type->name();
-  }
-#endif  // !WIN32
-  try {
-    std::rethrow_exception(std::current_exception());
-  } catch (const std::exception& ex) {
-    return typeid(ex).name();
-  } catch (...) { }
-
-  return {};
-}
-}  // namespace org::apache::nifi::minifi
diff --git a/extension-utils/src/utils/NetworkInterfaceInfo.cpp b/extension-utils/src/utils/NetworkInterfaceInfo.cpp
deleted file mode 100644
index f61b9ba821..0000000000
--- a/extension-utils/src/utils/NetworkInterfaceInfo.cpp
+++ /dev/null
@@ -1,146 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "utils/NetworkInterfaceInfo.h"
-#include "utils/net/Socket.h"
-#include "core/logging/LoggerFactory.h"
-#ifdef WIN32
-#include <iphlpapi.h>
-#pragma comment(lib, "IPHLPAPI.lib")
-#include "utils/OsUtils.h"
-#include "utils/UnicodeConversion.h"
-#else
-#include <unistd.h>
-#include <netinet/in.h>
-#include <sys/socket.h>
-#include <net/if.h>
-#include <arpa/inet.h>
-#include <ifaddrs.h>
-#endif
-
-namespace org::apache::nifi::minifi::utils {
-
-std::shared_ptr<core::logging::Logger> NetworkInterfaceInfo::logger_ = core::logging::LoggerFactory<NetworkInterfaceInfo>::getLogger();
-
-#ifdef WIN32
-
-NetworkInterfaceInfo::NetworkInterfaceInfo(const IP_ADAPTER_ADDRESSES* adapter)
-    : name_(to_string(adapter->FriendlyName)),
-      running_(adapter->OperStatus == IfOperStatusUp),
-      loopback_(adapter->IfType == IF_TYPE_SOFTWARE_LOOPBACK) {
-  for (auto unicast_address = adapter->FirstUnicastAddress; unicast_address != nullptr; unicast_address = unicast_address->Next) {
-    if (unicast_address->Address.lpSockaddr->sa_family == AF_INET) {
-      ip_v4_addresses_.push_back(net::sockaddr_ntop(unicast_address->Address.lpSockaddr));
-    } else if (unicast_address->Address.lpSockaddr->sa_family == AF_INET6) {
-      ip_v6_addresses_.push_back(net::sockaddr_ntop(unicast_address->Address.lpSockaddr));
-    }
-  }
-}
-#else
-NetworkInterfaceInfo::NetworkInterfaceInfo(const struct ifaddrs* ifa)
-    : name_(ifa->ifa_name),
-      running_(ifa->ifa_flags & IFF_RUNNING),
-      loopback_(ifa->ifa_flags & IFF_LOOPBACK) {
-  if (ifa->ifa_addr->sa_family == AF_INET) {
-    ip_v4_addresses_.push_back(net::sockaddr_ntop(ifa->ifa_addr));
-  } else if (ifa->ifa_addr->sa_family == AF_INET6) {
-    ip_v6_addresses_.push_back(net::sockaddr_ntop(ifa->ifa_addr));
-  }
-}
-#endif
-
-namespace {
-struct HasName {
-  explicit HasName(const std::string& name) : name_(name) {}
-  bool operator()(const NetworkInterfaceInfo& network_interface_info) {
-    return network_interface_info.getName() == name_;
-  }
-  const std::string& name_;
-};
-}
-
-std::vector<NetworkInterfaceInfo> NetworkInterfaceInfo::getNetworkInterfaceInfos(const std::function<bool(const NetworkInterfaceInfo&)>& filter,
-    const std::optional<uint32_t> max_interfaces) {
-  std::vector<NetworkInterfaceInfo> network_adapters;
-#ifdef WIN32
-  ULONG buffer_length = sizeof(IP_ADAPTER_ADDRESSES);
-  auto get_adapters_err = GetAdaptersAddresses(0, 0, nullptr, nullptr, &buffer_length);
-  if (ERROR_BUFFER_OVERFLOW != get_adapters_err) {
-    logger_->log_error("GetAdaptersAddresses failed: {}", get_adapters_err);
-    return network_adapters;
-  }
-  std::vector<char> bytes(buffer_length, 0);
-  auto* adapter = reinterpret_cast<IP_ADAPTER_ADDRESSES*>(bytes.data());
-  get_adapters_err = GetAdaptersAddresses(0, 0, nullptr, adapter, &buffer_length);
-  if (NO_ERROR != get_adapters_err) {
-    logger_->log_error("GetAdaptersAddresses failed: {}", get_adapters_err);
-    return network_adapters;
-  }
-  while (adapter != nullptr) {
-    NetworkInterfaceInfo interface_info(adapter);
-    if (filter(interface_info)) {
-      auto it = std::find_if(network_adapters.begin(), network_adapters.end(), HasName(interface_info.getName()));
-      if (it == network_adapters.end()) {
-        network_adapters.emplace_back(std::move(interface_info));
-      } else {
-        interface_info.moveAddressesInto(*it);
-      }
-    }
-    if (max_interfaces.has_value() && network_adapters.size() >= max_interfaces.value())
-      return network_adapters;
-    adapter = adapter->Next;
-  }
-#else
-  struct ifaddrs* interface_addresses = nullptr;
-  auto cleanup = gsl::finally([&interface_addresses] { freeifaddrs(interface_addresses); });
-  if (getifaddrs(&interface_addresses) == -1) {
-    logger_->log_error("getifaddrs failed: {}", std::strerror(errno));
-    return network_adapters;
-  }
-
-  for (struct ifaddrs* ifa = interface_addresses; ifa != nullptr; ifa = ifa->ifa_next) {
-    if (!ifa->ifa_addr)
-      continue;
-    NetworkInterfaceInfo interface_info(ifa);
-    if (filter(interface_info)) {
-      auto it = std::find_if(network_adapters.begin(), network_adapters.end(), HasName(interface_info.getName()));
-      if (it == network_adapters.end()) {
-        network_adapters.emplace_back(std::move(interface_info));
-      } else {
-        interface_info.moveAddressesInto(*it);
-      }
-    }
-    if (max_interfaces.has_value() && network_adapters.size() >= max_interfaces.value())
-      return network_adapters;
-  }
-#endif
-  return network_adapters;
-}
-
-namespace {
-void move_append(std::vector<std::string> &&source, std::vector<std::string> &destination) {
-  destination.reserve(destination.size() + source.size());
-  std::move(std::begin(source), std::end(source), std::back_inserter(destination));
-  source.clear();
-}
-}  // namespace
-
-void NetworkInterfaceInfo::moveAddressesInto(NetworkInterfaceInfo& destination) {
-  move_append(std::move(ip_v4_addresses_), destination.ip_v4_addresses_);
-  move_append(std::move(ip_v6_addresses_), destination.ip_v6_addresses_);
-}
-
-}  // namespace org::apache::nifi::minifi::utils
diff --git a/extensions/rocksdb-repos/controllers/RocksDbStateStorage.h b/extensions/rocksdb-repos/controllers/RocksDbStateStorage.h
index 0805a93af3..6c9f8a85ac 100644
--- a/extensions/rocksdb-repos/controllers/RocksDbStateStorage.h
+++ b/extensions/rocksdb-repos/controllers/RocksDbStateStorage.h
@@ -20,7 +20,7 @@
 #include <string>
 #include <memory>
 
-#include "controllers/keyvalue/AutoPersistor.h"
+#include "utils/AutoPersistor.h"
 #include "controllers/keyvalue/KeyValueStateStorage.h"
 #include "core/Core.h"
 #include "core/logging/Logger.h"
diff --git a/extensions/standard-processors/controllers/PersistentMapStateStorage.h b/extensions/standard-processors/controllers/PersistentMapStateStorage.h
index 689d336c0e..86096a07b5 100644
--- a/extensions/standard-processors/controllers/PersistentMapStateStorage.h
+++ b/extensions/standard-processors/controllers/PersistentMapStateStorage.h
@@ -22,7 +22,7 @@
 #include <memory>
 #include <utility>
 
-#include "controllers/keyvalue/AutoPersistor.h"
+#include "utils/AutoPersistor.h"
 #include "core/Core.h"
 #include "properties/Configure.h"
 #include "InMemoryKeyValueStorage.h"
diff --git a/extensions/standard-processors/processors/AppendHostInfo.cpp b/extensions/standard-processors/processors/AppendHostInfo.cpp
index b2d0b3f291..33d9196865 100644
--- a/extensions/standard-processors/processors/AppendHostInfo.cpp
+++ b/extensions/standard-processors/processors/AppendHostInfo.cpp
@@ -31,7 +31,7 @@
 #include "core/ProcessSession.h"
 #include "core/FlowFile.h"
 #include "core/Resource.h"
-#include "utils/NetworkInterfaceInfo.h"
+#include "utils/net/NetworkInterfaceInfo.h"
 #include "utils/net/DNS.h"
 
 namespace org::apache::nifi::minifi::processors {
diff --git a/libminifi/include/controllers/keyvalue/AutoPersistor.h b/libminifi/include/controllers/keyvalue/AutoPersistor.h
deleted file mode 100644
index 3cefe8c514..0000000000
--- a/libminifi/include/controllers/keyvalue/AutoPersistor.h
+++ /dev/null
@@ -1,61 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <condition_variable>
-#include <memory>
-#include <mutex>
-#include <string>
-#include <thread>
-#include <utility>
-
-#include "core/ConfigurableComponent.h"
-#include "core/Core.h"
-#include "core/logging/LoggerFactory.h"
-#include "utils/Export.h"
-
-namespace org::apache::nifi::minifi::controllers {
-
-/**
- *  Persists in given intervals.
- *  Has an own thread, so stop() must be called before destruction of data used by persist_.
- */
-class AutoPersistor {
- public:
-  ~AutoPersistor();
-
-  void start(bool always_persist, std::chrono::milliseconds auto_persistence_interval, std::function<bool()> persist);
-  void stop();
-
-  [[nodiscard]] bool isAlwaysPersisting() const {
-    return always_persist_;
-  }
-
- private:
-  void persistingThreadFunc();
-
-  bool always_persist_ = false;
-  std::chrono::milliseconds auto_persistence_interval_{0};
-  std::thread persisting_thread_;
-  bool running_ = false;
-  std::mutex persisting_mutex_;
-  std::condition_variable persisting_cv_;
-  std::function<bool()> persist_;
-  std::shared_ptr<core::logging::Logger> logger_ = core::logging::LoggerFactory<AutoPersistor>::getLogger();
-};
-
-}  // namespace org::apache::nifi::minifi::controllers
diff --git a/libminifi/include/core/ProcessSession.h b/libminifi/include/core/ProcessSession.h
index 745ee97dfa..14adb56751 100644
--- a/libminifi/include/core/ProcessSession.h
+++ b/libminifi/include/core/ProcessSession.h
@@ -34,7 +34,6 @@
 #include "FlowFileRecord.h"
 #include "Exception.h"
 #include "core/logging/LoggerFactory.h"
-#include "core/Deprecated.h"
 #include "FlowFile.h"
 #include "WeakReference.h"
 #include "provenance/Provenance.h"
diff --git a/libminifi/include/core/state/nodes/DeviceInformation.h b/libminifi/include/core/state/nodes/DeviceInformation.h
index 88480c7b7d..d7ebf47c82 100644
--- a/libminifi/include/core/state/nodes/DeviceInformation.h
+++ b/libminifi/include/core/state/nodes/DeviceInformation.h
@@ -48,8 +48,6 @@
 
 #include "core/state/nodes/MetricsBase.h"
 #include "Connection.h"
-#include "utils/OsUtils.h"
-#include "utils/NetworkInterfaceInfo.h"
 #include "utils/SystemCpuUsageTracker.h"
 #include "utils/Export.h"
 
diff --git a/libminifi/include/utils/CallBackTimer.h b/libminifi/include/utils/CallBackTimer.h
deleted file mode 100644
index c5fe96b2c6..0000000000
--- a/libminifi/include/utils/CallBackTimer.h
+++ /dev/null
@@ -1,62 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef LIBMINIFI_INCLUDE_UTILS_CALLBACKTIMER_H_
-#define LIBMINIFI_INCLUDE_UTILS_CALLBACKTIMER_H_
-
-#include <mutex>
-#include <condition_variable>
-#include <thread>
-#include <chrono>
-#include <functional>
-
-namespace org {
-namespace apache {
-namespace nifi {
-namespace minifi {
-namespace utils {
-
-class CallBackTimer {
- public:
-  CallBackTimer(std::chrono::milliseconds interval, const std::function<void(void)>& func);
-  ~CallBackTimer();
-
-  void stop();
-
-  void start();
-
-  bool is_running() const;
-
- private:
-  bool execute_;
-  std::function<void(void)> func_;
-  std::thread thd_;
-  mutable std::mutex mtx_;
-  mutable std::mutex cv_mtx_;
-  std::condition_variable cv_;
-
-  const std::chrono::milliseconds interval_;
-};
-
-}  // namespace utils
-}  // namespace minifi
-}  // namespace nifi
-}  // namespace apache
-}  // namespace org
-
-#endif  // LIBMINIFI_INCLUDE_UTILS_CALLBACKTIMER_H_
-
diff --git a/libminifi/include/utils/ClassUtils.h b/libminifi/include/utils/ClassUtils.h
deleted file mode 100644
index 3726651669..0000000000
--- a/libminifi/include/utils/ClassUtils.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <string>
-#include <string_view>
-
-namespace org::apache::nifi::minifi::utils::ClassUtils {
-
-/**
- * Shortens class names via the canonical representation ( package with name )
- * @param class_name input class name
- * @param out output class name that is shortened.
- * @return true if out has been updated, false otherwise
- */
-bool shortenClassName(std::string_view class_name, std::string &out);
-
-}  // namespace org::apache::nifi::minifi::utils::ClassUtils
diff --git a/libminifi/include/utils/CollectionUtils.h b/libminifi/include/utils/CollectionUtils.h
deleted file mode 100644
index 46b3f4f832..0000000000
--- a/libminifi/include/utils/CollectionUtils.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <algorithm>
-#include <utility>
-
-namespace org {
-namespace apache {
-namespace nifi {
-namespace minifi {
-namespace utils {
-
-namespace internal {
-
-template<typename T, typename Arg, typename = void>
-struct find_in_range {
-  static auto call(const T& range, const Arg& arg) -> decltype(std::find(range.begin(), range.end(), arg)) {
-    return std::find(range.begin(), range.end(), arg);
-  }
-};
-
-template<typename T, typename Arg>
-struct find_in_range<T, Arg, decltype(std::declval<const T&>().find(std::declval<const Arg&>()), void())> {
-  static auto call(const T& range, const Arg& arg) -> decltype(range.find(arg)) {
-    return range.find(arg);
-  }
-};
-
-}  // namespace internal
-
-template<typename T, typename U>
-bool haveCommonItem(const T& a, const U& b) {
-  using Item = typename T::value_type;
-  return std::any_of(a.begin(), a.end(), [&] (const Item& item) {
-    return internal::find_in_range<U, Item>::call(b, item) != b.end();
-  });
-}
-
-}  // namespace utils
-}  // namespace minifi
-}  // namespace nifi
-}  // namespace apache
-}  // namespace org
diff --git a/libminifi/include/utils/Cron.h b/libminifi/include/utils/Cron.h
deleted file mode 100644
index 97b78e3d99..0000000000
--- a/libminifi/include/utils/Cron.h
+++ /dev/null
@@ -1,57 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <exception>
-#include <string>
-#include <chrono>
-#include <optional>
-#include <memory>
-#include <utility>
-#include "date/tz.h"
-#include "Exception.h"
-
-namespace org::apache::nifi::minifi::utils {
-class BadCronExpression : public minifi::Exception {
- public:
-  explicit BadCronExpression(const std::string& errmsg) : minifi::Exception(errmsg) {}
-};
-
-class CronField {
- public:
-  virtual ~CronField() = default;
-
-  [[nodiscard]] virtual bool matches(date::local_seconds time_point) const = 0;
-  virtual bool operator==(const CronField&) const { throw std::runtime_error("not implemented"); }
-};
-
-class Cron {
- public:
-  explicit Cron(const std::string& expression);
-
-  [[nodiscard]] std::optional<date::local_seconds> calculateNextTrigger(date::local_seconds start) const;
-
-  std::unique_ptr<CronField> second_;
-  std::unique_ptr<CronField> minute_;
-  std::unique_ptr<CronField> hour_;
-  std::unique_ptr<CronField> day_;
-  std::unique_ptr<CronField> month_;
-  std::unique_ptr<CronField> day_of_week_;
-  std::unique_ptr<CronField> year_;
-};
-
-}  // namespace org::apache::nifi::minifi::utils
diff --git a/libminifi/include/utils/Error.h b/libminifi/include/utils/Error.h
deleted file mode 100644
index 77ef4a6aca..0000000000
--- a/libminifi/include/utils/Error.h
+++ /dev/null
@@ -1,26 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <system_error>
-
-namespace org::apache::nifi::minifi::utils {
-
-std::error_code getLastError();
-
-}  // namespace org::apache::nifi::minifi::utils
diff --git a/libminifi/include/utils/Export.h b/libminifi/include/utils/Export.h
deleted file mode 100644
index 175821d93c..0000000000
--- a/libminifi/include/utils/Export.h
+++ /dev/null
@@ -1,35 +0,0 @@
-/**
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#ifdef WIN32
-  #ifdef LIBMINIFI
-    #define MINIFIAPI __declspec(dllexport)
-  #else
-    #define MINIFIAPI __declspec(dllimport)
-  #endif
-  #ifdef MODULE_NAME
-    #define EXTENSIONAPI __declspec(dllexport)
-  #else
-    #define EXTENSIONAPI __declspec(dllimport)
-  #endif
-#else
-  #define MINIFIAPI
-  #define EXTENSIONAPI
-#endif
diff --git a/libminifi/include/utils/FifoExecutor.h b/libminifi/include/utils/FifoExecutor.h
deleted file mode 100644
index 1aca59d560..0000000000
--- a/libminifi/include/utils/FifoExecutor.h
+++ /dev/null
@@ -1,67 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <future>
-#include <thread>
-#include <utility>
-
-#include "utils/MinifiConcurrentQueue.h"
-
-namespace org::apache::nifi::minifi::utils {
-
-namespace detail {
-class WorkerThread final {
- public:
-  WorkerThread();
-
-  WorkerThread(const WorkerThread&) = delete;
-  WorkerThread(WorkerThread&&) = delete;
-  WorkerThread& operator=(WorkerThread) = delete;
-
-  ~WorkerThread();
-
-  template<typename... Args>
-  void enqueue(Args&&... args) { task_queue_.enqueue(std::forward<Args>(args)...); }
-
- private:
-  void run() noexcept;
-
-  utils::ConditionConcurrentQueue<std::packaged_task<void()>> task_queue_;
-  std::thread thread_;
-};
-}  // namespace detail
-
-/**
- * Executes arbitrary functions with no parameters asynchronously on an internal thread, returning a future to the result.
- */
-class FifoExecutor final {
- public:
-  template<typename Func>
-  auto enqueue(Func func) -> std::future<decltype(func())> {
-    using result_type = decltype(func());
-    std::packaged_task<result_type()> task{std::move(func)};
-    auto future = task.get_future();
-    worker_thread_.enqueue(std::move(task));
-    return future;
-  }
- private:
-  detail::WorkerThread worker_thread_;
-};
-
-}  // namespace org::apache::nifi::minifi::utils
diff --git a/libminifi/include/utils/FileMutex.h b/libminifi/include/utils/FileMutex.h
deleted file mode 100644
index 54596ead2e..0000000000
--- a/libminifi/include/utils/FileMutex.h
+++ /dev/null
@@ -1,59 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <filesystem>
-#include <array>
-#include <mutex>
-#include <optional>
-#include "utils/gsl.h"
-
-#ifdef WIN32
-#include <windows.h>
-#endif
-
-namespace org::apache::nifi::minifi::utils {
-
-// Warning: this will write the pid of the current process into the file
-class FileMutex {
- public:
-  explicit FileMutex(std::filesystem::path path);
-  ~FileMutex() {
-    gsl_Expects(!file_handle_.has_value());
-  }
-
-  FileMutex(const FileMutex&) = delete;
-  FileMutex(FileMutex&&) = delete;
-  FileMutex& operator=(const FileMutex&) = delete;
-  FileMutex& operator=(FileMutex&&) = delete;
-
-  void lock();
-  void unlock();
-
- private:
-  std::filesystem::path path_;
-
-  std::mutex mtx_;
-#ifdef WIN32
-  std::optional<HANDLE> file_handle_;
-#else
-  std::optional<int> file_handle_;
-#endif
-};
-
-}  // namespace org::apache::nifi::minifi::utils
diff --git a/libminifi/include/utils/IntervalSwitch.h b/libminifi/include/utils/IntervalSwitch.h
deleted file mode 100644
index 0052b4e006..0000000000
--- a/libminifi/include/utils/IntervalSwitch.h
+++ /dev/null
@@ -1,74 +0,0 @@
-/**
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <functional>
-#include <utility>
-
-#include "utils/gsl.h"
-
-namespace org {
-namespace apache {
-namespace nifi {
-namespace minifi {
-namespace utils {
-
-enum class IntervalSwitchState {
-  LOWER,
-  UPPER,
-};
-
-namespace detail {
-struct SwitchReturn {
-  IntervalSwitchState state;
-  bool switched;
-};
-}  // namespace detail
-
-template<typename T, typename Comp = std::less<T>>
-class IntervalSwitch {
- public:
-  IntervalSwitch(T lower_threshold, T upper_threshold, const IntervalSwitchState initial_state = IntervalSwitchState::UPPER)
-      :lower_threshold_{std::move(lower_threshold)}, upper_threshold_{std::move(upper_threshold)}, state_{initial_state} {
-    gsl_Expects(!less_(upper_threshold_, lower_threshold_));
-  }
-
-  detail::SwitchReturn operator()(const T& value) {
-    const auto old_state = state_;
-    if (less_(value, lower_threshold_)) {
-      state_ = IntervalSwitchState::LOWER;
-    } else if (!less_(value, upper_threshold_)) {
-      state_ = IntervalSwitchState::UPPER;
-    }
-    return {state_, state_ != old_state};
-  }
-
- private:
-  T lower_threshold_;
-  T upper_threshold_;
-  Comp less_;
-
-  IntervalSwitchState state_;
-};
-
-}  // namespace utils
-}  // namespace minifi
-}  // namespace nifi
-}  // namespace apache
-}  // namespace org
diff --git a/libminifi/include/utils/JsonCallback.h b/libminifi/include/utils/JsonCallback.h
deleted file mode 100644
index c455e6c348..0000000000
--- a/libminifi/include/utils/JsonCallback.h
+++ /dev/null
@@ -1,100 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <memory>
-#include <optional>
-#include <string>
-#include <utility>
-
-#include "rapidjson/stream.h"
-#include "rapidjson/writer.h"
-#include "rapidjson/prettywriter.h"
-
-#include "io/StreamPipe.h"
-
-namespace org {
-namespace apache {
-namespace nifi {
-namespace minifi {
-namespace utils {
-
-class JsonInputCallback {
- public:
-  explicit JsonInputCallback(rapidjson::Document& document) : document_(document) {}
-  int64_t operator()(const std::shared_ptr<io::InputStream>& stream) {
-    std::string content;
-    content.resize(stream->size());
-    const auto read_ret = stream->read(as_writable_bytes(std::span(content)));
-    if (io::isError(read_ret)) {
-      return -1;
-    }
-    rapidjson::ParseResult parse_result = document_.Parse<rapidjson::kParseStopWhenDoneFlag>(content.data());
-    if (parse_result.IsError())
-      return -1;
-
-    return read_ret;
-  }
- private:
-  rapidjson::Document& document_;
-};
-
-class JsonOutputCallback {
- public:
-  explicit JsonOutputCallback(rapidjson::Document&& root, std::optional<uint8_t> decimal_places)
-      : root_(std::move(root)), decimal_places_(decimal_places) {}
-
-  int64_t operator()(const std::shared_ptr<io::OutputStream>& stream) const {
-    rapidjson::StringBuffer buffer;
-    rapidjson::Writer<rapidjson::StringBuffer> writer(buffer);
-    if (decimal_places_.has_value())
-      writer.SetMaxDecimalPlaces(decimal_places_.value());
-    root_.Accept(writer);
-    const auto write_return = stream->write(reinterpret_cast<const uint8_t*>(buffer.GetString()), buffer.GetSize());
-    return !io::isError(write_return) ? gsl::narrow<int64_t>(write_return) : -1;
-  }
-
- protected:
-  rapidjson::Document root_;
-  std::optional<uint8_t> decimal_places_;
-};
-
-class PrettyJsonOutputCallback {
- public:
-  explicit PrettyJsonOutputCallback(rapidjson::Document&& root, std::optional<uint8_t> decimal_places)
-      : root_(std::move(root)), decimal_places_(decimal_places) {}
-
-  int64_t operator()(const std::shared_ptr<io::OutputStream>& stream) const {
-    rapidjson::StringBuffer buffer;
-    rapidjson::PrettyWriter<rapidjson::StringBuffer> writer(buffer);
-    if (decimal_places_.has_value())
-      writer.SetMaxDecimalPlaces(decimal_places_.value());
-    root_.Accept(writer);
-    const auto write_return = stream->write(reinterpret_cast<const uint8_t*>(buffer.GetString()), buffer.GetSize());
-    return !io::isError(write_return) ? gsl::narrow<int64_t>(write_return) : -1;
-  }
-
- protected:
-  rapidjson::Document root_;
-  std::optional<uint8_t> decimal_places_;
-};
-
-}  // namespace utils
-}  // namespace minifi
-}  // namespace nifi
-}  // namespace apache
-}  // namespace org
diff --git a/libminifi/include/utils/LineByLineInputOutputStreamCallback.h b/libminifi/include/utils/LineByLineInputOutputStreamCallback.h
deleted file mode 100644
index 0d68fe5680..0000000000
--- a/libminifi/include/utils/LineByLineInputOutputStreamCallback.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <functional>
-#include <memory>
-#include <optional>
-#include <string>
-#include <vector>
-
-#include "core/logging/Logger.h"
-#include "io/InputStream.h"
-#include "io/OutputStream.h"
-#include "io/StreamPipe.h"
-
-namespace org::apache::nifi::minifi::utils {
-
-class LineByLineInputOutputStreamCallback {
- public:
-  using CallbackType = std::function<std::string(const std::string& input_line, bool is_first_line, bool is_last_line)>;
-  explicit LineByLineInputOutputStreamCallback(CallbackType callback);
-  int64_t operator()(const std::shared_ptr<io::InputStream>& input, const std::shared_ptr<io::OutputStream>& output);
-
- private:
-  int64_t readInput(io::InputStream& stream);
-  void readLine();
-  [[nodiscard]] bool isLastLine() const { return !next_line_.has_value(); }
-
-  CallbackType callback_;
-  std::vector<std::byte> input_;
-  std::vector<std::byte>::iterator current_pos_{};
-  std::optional<std::string> current_line_;
-  std::optional<std::string> next_line_;
-};
-
-}  // namespace org::apache::nifi::minifi::utils
diff --git a/libminifi/include/utils/LogUtils.h b/libminifi/include/utils/LogUtils.h
deleted file mode 100644
index c8d852c9b7..0000000000
--- a/libminifi/include/utils/LogUtils.h
+++ /dev/null
@@ -1,87 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <memory>
-#include <utility>
-
-#include "utils/Enum.h"
-
-namespace org::apache::nifi::minifi::utils::LogUtils {
-
-enum class LogLevelOption {
-  LOGGING_TRACE,
-  LOGGING_DEBUG,
-  LOGGING_INFO,
-  LOGGING_WARN,
-  LOGGING_ERROR,
-  LOGGING_CRITICAL,
-  LOGGING_OFF
-};
-
-inline LogLevelOption mapToLogLevelOption(core::logging::LOG_LEVEL level) {
-  switch (level) {
-    case core::logging::trace: return LogLevelOption::LOGGING_TRACE;
-    case core::logging::debug: return LogLevelOption::LOGGING_DEBUG;
-    case core::logging::info: return LogLevelOption::LOGGING_INFO;
-    case core::logging::warn: return LogLevelOption::LOGGING_WARN;
-    case core::logging::err: return LogLevelOption::LOGGING_ERROR;
-    case core::logging::critical: return LogLevelOption::LOGGING_CRITICAL;
-    case core::logging::off: return LogLevelOption::LOGGING_OFF;
-  }
-  throw std::invalid_argument(fmt::format("Invalid LOG_LEVEL {}", magic_enum::enum_underlying(level)));
-}
-
-inline core::logging::LOG_LEVEL mapToLogLevel(LogLevelOption option) {
-  switch (option) {
-    case LogLevelOption::LOGGING_TRACE: return core::logging::trace;
-    case LogLevelOption::LOGGING_DEBUG: return core::logging::debug;
-    case LogLevelOption::LOGGING_INFO: return core::logging::info;
-    case LogLevelOption::LOGGING_WARN: return core::logging::warn;
-    case LogLevelOption::LOGGING_ERROR: return core::logging::err;
-    case LogLevelOption::LOGGING_CRITICAL: return core::logging::critical;
-    case LogLevelOption::LOGGING_OFF: return core::logging::off;
-  }
-  throw std::invalid_argument(fmt::format("Invalid LogLevelOption {}", magic_enum::enum_underlying(option)));
-}
-
-}  // namespace org::apache::nifi::minifi::utils::LogUtils
-
-namespace magic_enum::customize {
-using LogLevelOption = org::apache::nifi::minifi::utils::LogUtils::LogLevelOption;
-
-template <>
-constexpr customize_t enum_name<LogLevelOption>(LogLevelOption value) noexcept {
-  switch (value) {
-    case LogLevelOption::LOGGING_TRACE:
-      return "TRACE";
-    case LogLevelOption::LOGGING_DEBUG:
-      return "DEBUG";
-    case LogLevelOption::LOGGING_INFO:
-      return "INFO";
-    case LogLevelOption::LOGGING_WARN:
-      return "WARN";
-    case LogLevelOption::LOGGING_ERROR:
-      return "ERROR";
-    case LogLevelOption::LOGGING_CRITICAL:
-      return "CRITICAL";
-    case LogLevelOption::LOGGING_OFF:
-      return "OFF";
-  }
-  return invalid_tag;
-}
-}  // namespace magic_enum::customize
diff --git a/libminifi/include/utils/MapUtils.h b/libminifi/include/utils/MapUtils.h
deleted file mode 100644
index 55011d78df..0000000000
--- a/libminifi/include/utils/MapUtils.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <set>
-
-namespace org {
-namespace apache {
-namespace nifi {
-namespace minifi {
-namespace utils {
-namespace MapUtils {
-
-/**
- * Return a set of keys from a map
- */
-template<template <typename...> class Map, typename T, typename U>
-std::set<T> getKeys(const Map<T, U>& m) {
-  std::set<T> keys;
-  for (const auto& pair : m) {
-    keys.insert(pair.first);
-  }
-  return keys;
-}
-
-} /* namespace MapUtils */
-} /* namespace utils */
-} /* namespace minifi */
-} /* namespace nifi */
-} /* namespace apache */
-} /* namespace org */
diff --git a/libminifi/include/utils/NetworkInterfaceInfo.h b/libminifi/include/utils/NetworkInterfaceInfo.h
deleted file mode 100644
index 5d8f7953ea..0000000000
--- a/libminifi/include/utils/NetworkInterfaceInfo.h
+++ /dev/null
@@ -1,70 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <string>
-#include <vector>
-#include <memory>
-#include <unordered_map>
-#include <optional>
-#include "core/logging/Logger.h"
-
-#ifdef WIN32
-struct _IP_ADAPTER_ADDRESSES_LH;
-typedef _IP_ADAPTER_ADDRESSES_LH IP_ADAPTER_ADDRESSES_LH;
-typedef IP_ADAPTER_ADDRESSES_LH IP_ADAPTER_ADDRESSES;
-#else
-struct ifaddrs;
-#endif
-
-namespace org::apache::nifi::minifi::utils {
-class NetworkInterfaceInfo {
- public:
-  NetworkInterfaceInfo(NetworkInterfaceInfo&& src) noexcept = default;
-#ifdef WIN32
-  // Creates NetworkInterfaceInfo from IP_ADAPTER_ADDRESSES struct (it should contain all ip addresses from an adapter)
-  explicit NetworkInterfaceInfo(const IP_ADAPTER_ADDRESSES* adapter);
-#else
-  // Creates NetworkInterfaceInfo from ifaddrs struct (it will only contain a single ip address from an adapter, it should be merged together based on name_)
-  explicit NetworkInterfaceInfo(const struct ifaddrs* ifa);
-#endif
-  NetworkInterfaceInfo& operator=(NetworkInterfaceInfo&& other) noexcept = default;
-  [[nodiscard]] const std::string& getName() const noexcept { return name_; }
-  [[nodiscard]] bool hasIpV4Address() const noexcept { return !ip_v4_addresses_.empty(); }
-  [[nodiscard]] bool hasIpV6Address() const noexcept { return !ip_v6_addresses_.empty(); }
-  [[nodiscard]] bool isRunning() const noexcept { return running_; }
-  [[nodiscard]] bool isLoopback() const noexcept { return loopback_; }
-  [[nodiscard]] const std::vector<std::string>& getIpV4Addresses() const noexcept { return ip_v4_addresses_; }
-  [[nodiscard]] const std::vector<std::string>& getIpV6Addresses() const noexcept { return ip_v6_addresses_; }
-
-  // Traverses the ip addresses and merges them together based on the interface name
-  static std::vector<NetworkInterfaceInfo> getNetworkInterfaceInfos(
-      const std::function<bool(const NetworkInterfaceInfo&)>& filter = { [](const NetworkInterfaceInfo&) { return true; } },
-      std::optional<uint32_t> max_interfaces = std::nullopt);
-
- private:
-  void moveAddressesInto(NetworkInterfaceInfo& destination);
-
-  std::string name_;
-  std::vector<std::string> ip_v4_addresses_;
-  std::vector<std::string> ip_v6_addresses_;
-  bool running_;
-  bool loopback_;
-  static std::shared_ptr<core::logging::Logger> logger_;
-};
-}  // namespace org::apache::nifi::minifi::utils
diff --git a/libminifi/include/utils/OpenTelemetryLogDataModelUtils.h b/libminifi/include/utils/OpenTelemetryLogDataModelUtils.h
deleted file mode 100644
index c9c639116b..0000000000
--- a/libminifi/include/utils/OpenTelemetryLogDataModelUtils.h
+++ /dev/null
@@ -1,75 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <string>
-
-#include "rapidjson/document.h"
-#include "NetworkInterfaceInfo.h"
-#include "utils/net/DNS.h"
-
-namespace org::apache::nifi::minifi::utils {
-
-class OpenTelemetryLogDataModel {
- public:
-  static void appendEventInformation(rapidjson::Document& root, const std::string& event_identifier) {
-    rapidjson::Value name;
-    name.SetString(event_identifier.c_str(), gsl::narrow<rapidjson::SizeType>(event_identifier.length()), root.GetAllocator());
-    root.AddMember("Name", name, root.GetAllocator());
-    root.AddMember("Timestamp", rapidjson::Value().SetInt64(std::time(0)), root.GetAllocator());
-  }
-
-  static void appendHostInformation(rapidjson::Document& root) {
-    root.AddMember("Resource", rapidjson::Value{ rapidjson::kObjectType }, root.GetAllocator());
-    appendHostName(root["Resource"], root.GetAllocator());
-    appendIPAddresses(root["Resource"], root.GetAllocator());
-  }
-
-  static void appendBody(rapidjson::Document& root) {
-    root.AddMember("Body", rapidjson::Value{ rapidjson::kObjectType }, root.GetAllocator());
-  }
-
- private:
-  static void appendHostName(rapidjson::Value& resource, rapidjson::Document::AllocatorType& allocator) {
-    std::string hostname = utils::net::getMyHostName();
-    rapidjson::Value hostname_value;
-    hostname_value.SetString(hostname.c_str(), gsl::narrow<rapidjson::SizeType>(hostname.length()), allocator);
-    resource.AddMember("host.hostname", hostname_value, allocator);
-  }
-
-  static void appendIPAddresses(rapidjson::Value& resource, rapidjson::Document::AllocatorType& alloc) {
-    resource.AddMember("host.ip", rapidjson::Value{ rapidjson::kObjectType }, alloc);
-    rapidjson::Value& ip = resource["host.ip"];
-    auto network_interface_infos = utils::NetworkInterfaceInfo::getNetworkInterfaceInfos();
-    for (const auto& network_interface_info : network_interface_infos) {
-      rapidjson::Value interface_name(network_interface_info.getName().c_str(), gsl::narrow<rapidjson::SizeType>(network_interface_info.getName().length()), alloc);
-      rapidjson::Value interface_address_array(rapidjson::kArrayType);
-      for (auto& ip_v4_address : network_interface_info.getIpV4Addresses()) {
-        rapidjson::Value address_value(ip_v4_address.c_str(), gsl::narrow<rapidjson::SizeType>(ip_v4_address.length()), alloc);
-        interface_address_array.PushBack(address_value.Move(), alloc);
-      }
-      for (auto& ip_v6_address : network_interface_info.getIpV6Addresses()) {
-        rapidjson::Value address_value(ip_v6_address.c_str(), gsl::narrow<rapidjson::SizeType>(ip_v6_address.length()), alloc);
-        interface_address_array.PushBack(address_value.Move(), alloc);
-      }
-      ip.AddMember(interface_name, interface_address_array, alloc);
-    }
-  }
-};
-
-}  // namespace org::apache::nifi::minifi::utils
diff --git a/libminifi/include/utils/ProcessCpuUsageTracker.h b/libminifi/include/utils/ProcessCpuUsageTracker.h
deleted file mode 100644
index c360359ff8..0000000000
--- a/libminifi/include/utils/ProcessCpuUsageTracker.h
+++ /dev/null
@@ -1,84 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#ifdef WIN32
-#include <cstdint>
-#include "windows.h"
-#else
-#include <time.h>
-#endif
-
-namespace org::apache::nifi::minifi::utils {
-
-class ProcessCpuUsageTrackerBase {
- public:
-  ProcessCpuUsageTrackerBase() = default;
-  virtual ~ProcessCpuUsageTrackerBase() = default;
-  virtual double getCpuUsageAndRestartCollection() = 0;
-};
-
-#ifndef WIN32
-class ProcessCpuUsageTracker : ProcessCpuUsageTrackerBase {
- public:
-  ProcessCpuUsageTracker();
-  ~ProcessCpuUsageTracker() = default;
-  double getCpuUsageAndRestartCollection() override;
-
- protected:
-  void queryCpuTimes();
-  bool isCurrentQueryOlderThanPrevious() const;
-  bool isCurrentQuerySameAsPrevious() const;
-  double getProcessCpuUsageBetweenLastTwoQueries() const;
-
- private:
-  clock_t cpu_times_;
-  clock_t sys_cpu_times_;
-  clock_t user_cpu_times_;
-
-  clock_t previous_cpu_times_;
-  clock_t previous_sys_cpu_times_;
-  clock_t previous_user_cpu_times_;
-};
-
-#else
-
-class ProcessCpuUsageTracker : ProcessCpuUsageTrackerBase {
- public:
-  ProcessCpuUsageTracker();
-  ~ProcessCpuUsageTracker() = default;
-  double getCpuUsageAndRestartCollection() override;
-
- protected:
-  void queryCpuTimes();
-  bool isCurrentQuerySameAsPrevious() const;
-  bool isCurrentQueryOlderThanPrevious() const;
-  double getProcessCpuUsageBetweenLastTwoQueries() const;
-
- private:
-  HANDLE self_;
-  uint64_t cpu_times_;
-  uint64_t sys_cpu_times_;
-  uint64_t user_cpu_times_;
-
-  uint64_t previous_cpu_times_;
-  uint64_t previous_sys_cpu_times_;
-  uint64_t previous_user_cpu_times_;
-};
-#endif
-
-}  // namespace org::apache::nifi::minifi::utils
diff --git a/libminifi/include/utils/StoppableThread.h b/libminifi/include/utils/StoppableThread.h
deleted file mode 100644
index c21ca26333..0000000000
--- a/libminifi/include/utils/StoppableThread.h
+++ /dev/null
@@ -1,60 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <mutex>
-#include <thread>
-#include <condition_variable>
-#include <atomic>
-#include <functional>
-
-namespace org::apache::nifi::minifi::utils {
-
-// mimics some aspects of std::jthread
-// unfortunately clang's jthread support is lacking
-// TODO(adebreceni): replace this with std::jthread
-class StoppableThread {
- public:
-  explicit StoppableThread(std::function<void()> fn);
-
-  void stopAndJoin() {
-    running_ = false;
-    {
-      std::unique_lock lock(mtx_);
-      cv_.notify_all();
-    }
-    if (thread_.joinable()) {
-      thread_.join();
-    }
-  }
-
-  ~StoppableThread() {
-    stopAndJoin();
-  }
-
-  // return true if stop was requested
-  static bool waitForStopRequest(std::chrono::milliseconds time);
-
- private:
-  std::atomic_bool running_{true};
-  std::mutex mtx_;
-  std::condition_variable cv_;
-  std::thread thread_;
-};
-
-}  // namespace org::apache::nifi::minifi::utils
diff --git a/libminifi/include/utils/SystemCpuUsageTracker.h b/libminifi/include/utils/SystemCpuUsageTracker.h
deleted file mode 100644
index 95e21d9869..0000000000
--- a/libminifi/include/utils/SystemCpuUsageTracker.h
+++ /dev/null
@@ -1,123 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#pragma once
-
-#include <cstdint>
-
-#ifdef __linux__
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <string>
-#endif
-
-#ifdef WIN32
-#include "TCHAR.h"
-#include "windows.h"
-#endif
-
-#ifdef __APPLE__
-#include <mach/mach_init.h>
-#include <mach/mach_error.h>
-#include <mach/mach_host.h>
-#include <mach/vm_map.h>
-#endif
-
-namespace org::apache::nifi::minifi::utils {
-
-class SystemCpuUsageTrackerBase {
- public:
-  SystemCpuUsageTrackerBase() = default;
-  virtual ~SystemCpuUsageTrackerBase() = default;
-  virtual double getCpuUsageAndRestartCollection() = 0;
-};
-
-#ifdef __linux__
-class SystemCpuUsageTracker : public SystemCpuUsageTrackerBase {
- public:
-  SystemCpuUsageTracker();
-  ~SystemCpuUsageTracker() = default;
-  double getCpuUsageAndRestartCollection() override;
-
- protected:
-  void queryCpuTimes();
-  bool isCurrentQuerySameAsPrevious() const;
-  bool isCurrentQueryOlderThanPrevious() const;
-  double getCpuUsageBetweenLastTwoQueries() const;
-
- private:
-  uint64_t total_user_;
-  uint64_t previous_total_user_;
-
-  uint64_t total_user_low_;
-  uint64_t previous_total_user_low_;
-
-  uint64_t total_sys_;
-  uint64_t previous_total_sys_;
-
-  uint64_t total_idle_;
-  uint64_t previous_total_idle_;
-};
-#endif  // linux
-
-#ifdef WIN32
-class SystemCpuUsageTracker : public SystemCpuUsageTrackerBase {
- public:
-  SystemCpuUsageTracker();
-  ~SystemCpuUsageTracker() = default;
-  double getCpuUsageAndRestartCollection() override;
-
- protected:
-  void queryCpuTimes();
-  bool isCurrentQuerySameAsPrevious() const;
-  bool isCurrentQueryOlderThanPrevious() const;
-  double getCpuUsageBetweenLastTwoQueries() const;
-
- private:
-  uint64_t total_idle_;
-  uint64_t total_sys_;
-  uint64_t total_user_;
-
-  uint64_t previous_total_idle_;
-  uint64_t previous_total_sys_;
-  uint64_t previous_total_user_;
-};
-#endif  // windows
-
-#ifdef __APPLE__
-class SystemCpuUsageTracker : public SystemCpuUsageTrackerBase {
- public:
-  SystemCpuUsageTracker();
-  ~SystemCpuUsageTracker() = default;
-  double getCpuUsageAndRestartCollection() override;
-
- protected:
-  void queryCpuTicks();
-  bool isCurrentQueryOlderThanPrevious() const;
-  bool isCurrentQuerySameAsPrevious() const;
-  double getCpuUsageBetweenLastTwoQueries() const;
-
- private:
-  uint64_t total_ticks_;
-  uint64_t previous_total_ticks_;
-
-  uint64_t idle_ticks_;
-  uint64_t previous_idle_ticks_;
-};
-#endif  // macOS
-
-}  // namespace org::apache::nifi::minifi::utils
diff --git a/libminifi/include/utils/UnicodeConversion.h b/libminifi/include/utils/UnicodeConversion.h
deleted file mode 100644
index dfd0e26ef1..0000000000
--- a/libminifi/include/utils/UnicodeConversion.h
+++ /dev/null
@@ -1,39 +0,0 @@
-/**
- * @file UnicodeConversion.h
- * Unicode conversion functions
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <atlbase.h>
-#include <atlconv.h>
-#include <string>
-
-namespace org::apache::nifi::minifi::utils {
-
-inline std::string to_string(const std::wstring& utf16_string) {
-  ATL::CW2A utf8_string(utf16_string.c_str(), CP_UTF8);
-  return {LPSTR{utf8_string}};
-}
-
-inline std::wstring to_wstring(const std::string& utf8_string) {
-  ATL::CA2W utf16_string(utf8_string.c_str(), CP_UTF8);
-  return {LPWSTR{utf16_string}};
-}
-
-}  // namespace org::apache::nifi::minifi::utils
diff --git a/libminifi/include/utils/net/ConnectionHandler.h b/libminifi/include/utils/net/ConnectionHandler.h
deleted file mode 100644
index b3d5075ec2..0000000000
--- a/libminifi/include/utils/net/ConnectionHandler.h
+++ /dev/null
@@ -1,173 +0,0 @@
-/**
-* Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <asio/read.hpp>
-
-#include "utils/net/AsioCoro.h"
-#include "utils/net/AsioSocketUtils.h"
-#include "ConnectionHandlerBase.h"
-
-namespace org::apache::nifi::minifi::utils::net {
-
-template<class SocketType>
-class ConnectionHandler final : public ConnectionHandlerBase {
- public:
-  ConnectionHandler(ConnectionId connection_id,
-                    const std::chrono::milliseconds timeout,
-                    std::shared_ptr<core::logging::Logger> logger,
-                    const std::optional<size_t> max_size_of_socket_send_buffer,
-                    asio::ssl::context* ssl_context)
-      : connection_id_(std::move(connection_id)),
-        timeout_duration_(timeout),
-        logger_(std::move(logger)),
-        max_size_of_socket_send_buffer_(max_size_of_socket_send_buffer),
-        ssl_context_(ssl_context) {
-  }
-
-  ConnectionHandler(ConnectionHandler&&) = delete;
-  ConnectionHandler(const ConnectionHandler&) = delete;
-  ConnectionHandler& operator=(ConnectionHandler&&) = delete;
-  ConnectionHandler& operator=(const ConnectionHandler&) = delete;
-
-  ~ConnectionHandler() override {
-    shutdownSocket();
-  }
-
-
- private:
-  [[nodiscard]] bool hasBeenUsedIn(std::chrono::milliseconds dur) const override {
-    return last_used_ && *last_used_ >= (std::chrono::steady_clock::now() - dur);
-  }
-
-  void reset() override {
-    last_used_.reset();
-    socket_.reset();
-  }
-
-  [[nodiscard]] bool hasBeenUsed() const override { return last_used_.has_value(); }
-  [[nodiscard]] asio::awaitable<std::error_code> setupUsableSocket(asio::io_context& io_context) override;
-  [[nodiscard]] bool hasUsableSocket() const { return socket_ && socket_->lowest_layer().is_open(); }
-
-  asio::awaitable<std::error_code> establishNewConnection(const asio::ip::tcp::resolver::results_type& endpoints, asio::io_context& io_context_);
-  [[nodiscard]] asio::awaitable<std::tuple<std::error_code, size_t>> write(const asio::const_buffer& buffer) override;
-  [[nodiscard]] asio::awaitable<std::tuple<std::error_code, size_t>> read(asio::mutable_buffer& buffer) override;
-
-  SocketType createNewSocket(asio::io_context& io_context_);
-  void shutdownSocket();
-
-  ConnectionId connection_id_;
-  std::optional<SocketType> socket_{};
-
-  std::optional<std::chrono::steady_clock::time_point> last_used_{};
-  asio::steady_timer::duration timeout_duration_{};
-
-  std::shared_ptr<core::logging::Logger> logger_{};
-  std::optional<size_t> max_size_of_socket_send_buffer_{};
-
-  asio::ssl::context* ssl_context_{};
-};
-
-template<>
-inline TcpSocket ConnectionHandler<TcpSocket>::createNewSocket(asio::io_context& io_context_) {
-  gsl_Expects(!ssl_context_);
-  return TcpSocket{io_context_};
-}
-
-template<>
-inline SslSocket ConnectionHandler<SslSocket>::createNewSocket(asio::io_context& io_context_) {
-  gsl_Expects(ssl_context_);
-  return {io_context_, *ssl_context_};
-}
-
-template<>
-inline void ConnectionHandler<TcpSocket>::shutdownSocket() {
-}
-
-template<>
-inline void ConnectionHandler<SslSocket>::shutdownSocket() {
-  gsl_Expects(ssl_context_);
-  if (socket_) {
-    asio::error_code ec;
-    socket_->lowest_layer().cancel(ec);
-    if (ec) {
-      logger_->log_error("Cancelling asynchronous operations of SSL socket failed with: {}", ec.message());
-    }
-    socket_->shutdown(ec);
-    if (ec) {
-      logger_->log_error("Shutdown of SSL socket failed with: {}", ec.message());
-    }
-  }
-}
-
-template<class SocketType>
-asio::awaitable<std::error_code> ConnectionHandler<SocketType>::establishNewConnection(const asio::ip::tcp::resolver::results_type& endpoints, asio::io_context& io_context) {
-  auto socket = createNewSocket(io_context);
-  std::error_code last_error;
-  for (const auto& endpoint : endpoints) {
-    auto [connection_error] = co_await asyncOperationWithTimeout(socket.lowest_layer().async_connect(endpoint, use_nothrow_awaitable), timeout_duration_);
-    if (connection_error) {
-      logger_->log_debug("Connecting to {} failed due to {}", endpoint.endpoint(), connection_error.message());
-      last_error = connection_error;
-      continue;
-    }
-    auto [handshake_error] = co_await handshake(socket, timeout_duration_);
-    if (handshake_error) {
-      logger_->log_debug("Handshake with {} failed due to {}", endpoint.endpoint(), handshake_error.message());
-      last_error = handshake_error;
-      continue;
-    }
-    if (max_size_of_socket_send_buffer_)
-      socket.lowest_layer().set_option(TcpSocket::send_buffer_size(gsl::narrow<int>(*max_size_of_socket_send_buffer_)));
-    socket_.emplace(std::move(socket));
-    co_return std::error_code();
-  }
-  co_return last_error;
-}
-
-template<class SocketType>
-[[nodiscard]] asio::awaitable<std::error_code> ConnectionHandler<SocketType>::setupUsableSocket(asio::io_context& io_context) {
-  if (hasUsableSocket())
-    co_return std::error_code();
-  asio::ip::tcp::resolver resolver(io_context);
-  auto [resolve_error, resolve_result] = co_await asyncOperationWithTimeout(
-      resolver.async_resolve(connection_id_.getHostname(), connection_id_.getService(), use_nothrow_awaitable), timeout_duration_);
-  if (resolve_error)
-    co_return resolve_error;
-  co_return co_await establishNewConnection(resolve_result, io_context);
-}
-
-template<class SocketType>
-asio::awaitable<std::tuple<std::error_code, size_t>> ConnectionHandler<SocketType>::write(const asio::const_buffer& buffer) {
-  auto result = co_await asyncOperationWithTimeout(asio::async_write(*socket_, buffer, use_nothrow_awaitable), timeout_duration_);
-  if (!std::get<std::error_code>(result)) {
-    last_used_ = std::chrono::steady_clock::now();
-  }
-  co_return result;
-}
-
-template<class SocketType>
-asio::awaitable<std::tuple<std::error_code, size_t>> ConnectionHandler<SocketType>::read(asio::mutable_buffer& buffer) {
-  auto result = co_await asyncOperationWithTimeout(asio::async_read(*socket_, buffer, use_nothrow_awaitable), timeout_duration_);
-  if (!std::get<std::error_code>(result)) {
-    last_used_ = std::chrono::steady_clock::now();
-  }
-  co_return result;
-}
-
-}  // namespace org::apache::nifi::minifi::utils::net
diff --git a/libminifi/include/utils/net/ConnectionHandlerBase.h b/libminifi/include/utils/net/ConnectionHandlerBase.h
deleted file mode 100644
index 847880bb89..0000000000
--- a/libminifi/include/utils/net/ConnectionHandlerBase.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/**
-* Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-namespace org::apache::nifi::minifi::utils::net {
-
-class ConnectionHandlerBase {
- public:
-  ConnectionHandlerBase() = default;
-  ConnectionHandlerBase(const ConnectionHandlerBase& connection_id) = delete;
-  ConnectionHandlerBase(ConnectionHandlerBase&& connection_id) = delete;
-  ConnectionHandlerBase& operator=(ConnectionHandlerBase&&) = delete;
-  ConnectionHandlerBase& operator=(const ConnectionHandlerBase&) = delete;
-
-  virtual ~ConnectionHandlerBase() = default;
-
-  virtual void reset() = 0;
-
-  [[nodiscard]] virtual asio::awaitable<std::error_code> setupUsableSocket(asio::io_context& io_context) = 0;
-  [[nodiscard]] virtual bool hasBeenUsed() const = 0;
-  [[nodiscard]] virtual bool hasBeenUsedIn(std::chrono::milliseconds dur) const = 0;
-  [[nodiscard]] virtual asio::awaitable<std::tuple<std::error_code, size_t>> write(const asio::const_buffer& buffer) = 0;
-  [[nodiscard]] virtual asio::awaitable<std::tuple<std::error_code, size_t>> read(asio::mutable_buffer& buffer) = 0;
-};
-
-}  // namespace org::apache::nifi::minifi::utils::net
diff --git a/libminifi/include/utils/requirements/Container.h b/libminifi/include/utils/requirements/Container.h
deleted file mode 100644
index 62b7aeba51..0000000000
--- a/libminifi/include/utils/requirements/Container.h
+++ /dev/null
@@ -1,77 +0,0 @@
-/**
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <iterator>
-#include <utility>
-#include <type_traits>
-#include "LegacyForwardIterator.h"
-#include "EqualityComparable.h"
-
-namespace org {
-namespace apache {
-namespace nifi {
-namespace minifi {
-namespace utils {
-
-template<typename T>
-struct assert_container :
-    assert_legacy_forward_iterator<typename T::iterator>,
-    assert_legacy_forward_iterator<typename T::const_iterator> {
-  static_assert(std::is_same<typename T::reference, typename T::value_type&>::value, "");
-  static_assert(std::is_same<typename T::const_reference, const typename T::value_type&>::value, "");
-  static_assert(std::is_same<typename std::iterator_traits<typename T::iterator>::value_type, typename T::value_type>::value, "");
-  static_assert(std::is_convertible<typename T::iterator, typename T::const_iterator>::value, "");
-  static_assert(std::is_same<typename std::iterator_traits<typename T::const_iterator>::value_type, const typename T::value_type>::value, "");
-  static_assert(std::is_signed<typename T::difference_type>::value && std::is_integral<typename T::difference_type>::value, "");
-  static_assert(std::is_same<typename T::difference_type, typename std::iterator_traits<typename T::iterator>::difference_type>::value, "");
-  static_assert(std::is_same<typename T::difference_type, typename std::iterator_traits<typename T::const_iterator>::difference_type>::value, "");
-  static_assert(std::is_unsigned<typename T::size_type>::value && !std::is_same<typename T::size_type, bool>::value, "");
-
-  static_assert(std::is_default_constructible<T>::value, "");
-  static_assert(std::is_copy_constructible<T>::value, "");
-  static_assert(std::is_move_constructible<T>::value, "");
-  static_assert(std::is_copy_assignable<T>::value, "");
-  static_assert(std::is_move_assignable<T>::value, "");
-  static_assert(std::is_destructible<T>::value, "");
-
-  static_assert(std::is_same<decltype(std::declval<T&>().begin()), typename T::iterator>::value, "");
-  static_assert(std::is_same<decltype(std::declval<const T&>().begin()), typename T::const_iterator>::value, "");
-  static_assert(std::is_same<decltype(std::declval<T&>().end()), typename T::iterator>::value, "");
-  static_assert(std::is_same<decltype(std::declval<const T&>().end()), typename T::const_iterator>::value, "");
-  static_assert(std::is_same<decltype(std::declval<T&>().cbegin()), typename T::const_iterator>::value, "");
-  static_assert(std::is_same<decltype(std::declval<T&>().cend()), typename T::const_iterator>::value, "");
-
-  static_assert(is_equality_comparable<typename T::value_type>::value, "");
-  static_assert(std::is_convertible<decltype(std::declval<T&>() == std::declval<T&>()), bool>::value, "");
-  static_assert(std::is_convertible<decltype(std::declval<T&>() != std::declval<T&>()), bool>::value, "");
-
-  static_assert(std::is_same<decltype(std::declval<T&>().swap(std::declval<T&>())), void>::value, "Member swap");
-  static_assert(std::is_same<decltype(swap(std::declval<T&>(), std::declval<T&>())), void>::value, "ADL swap");
-  static_assert(std::is_same<decltype(std::declval<T&>().size()), typename T::size_type>::value, "");
-  static_assert(std::is_same<decltype(std::declval<T&>().max_size()), typename T::size_type>::value, "");
-
-  static_assert(std::is_convertible<decltype(std::declval<T&>().empty()), bool>::value, "");
-};
-
-}  // namespace utils
-}  // namespace minifi
-}  // namespace nifi
-}  // namespace apache
-}  // namespace org
diff --git a/libminifi/include/utils/requirements/EqualityComparable.h b/libminifi/include/utils/requirements/EqualityComparable.h
deleted file mode 100644
index 8c41800d15..0000000000
--- a/libminifi/include/utils/requirements/EqualityComparable.h
+++ /dev/null
@@ -1,42 +0,0 @@
-/**
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <type_traits>
-
-namespace org {
-namespace apache {
-namespace nifi {
-namespace minifi {
-namespace utils {
-
-template<typename T, typename = void>
-struct is_equality_comparable : std::false_type {};
-
-template<typename T>
-struct is_equality_comparable<T,
-    typename std::enable_if<
-      std::is_convertible<decltype(std::declval<const T>() == std::declval<const T>()), bool>::value
-    >::type> : std::true_type {};
-
-}  // namespace utils
-}  // namespace minifi
-}  // namespace nifi
-}  // namespace apache
-}  // namespace org
diff --git a/libminifi/include/utils/requirements/LegacyForwardIterator.h b/libminifi/include/utils/requirements/LegacyForwardIterator.h
deleted file mode 100644
index 389ce33c93..0000000000
--- a/libminifi/include/utils/requirements/LegacyForwardIterator.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/**
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <iterator>
-#include "LegacyInputIterator.h"
-
-namespace org {
-namespace apache {
-namespace nifi {
-namespace minifi {
-namespace utils {
-
-template<typename T>
-struct assert_legacy_forward_iterator : assert_legacy_input_iterator<T> {
-  static_assert(std::is_default_constructible<T>::value, "T is not default constructible");
-  static_assert(
-      std::is_same<typename std::iterator_traits<T>::reference, typename std::iterator_traits<T>::value_type&>::value
-      || std::is_same<typename std::iterator_traits<T>::reference, const typename std::iterator_traits<T>::value_type&>::value
-      , "reference should be either value_type& or const value_type& depending on if we want a mutable iterator");
-
-  static_assert(std::is_same<decltype(std::declval<T>()++), T>::value, "Expected an iterator");
-  static_assert(std::is_same<decltype(*std::declval<T>()++), typename std::iterator_traits<T>::reference>::value, "Expected a reference");
-};
-
-}  // namespace utils
-}  // namespace minifi
-}  // namespace nifi
-}  // namespace apache
-}  // namespace org
diff --git a/libminifi/include/utils/requirements/LegacyInputIterator.h b/libminifi/include/utils/requirements/LegacyInputIterator.h
deleted file mode 100644
index d5a067574c..0000000000
--- a/libminifi/include/utils/requirements/LegacyInputIterator.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/**
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <utility>
-#include <iterator>
-#include "LegacyIterator.h"
-#include "EqualityComparable.h"
-
-namespace org {
-namespace apache {
-namespace nifi {
-namespace minifi {
-namespace utils {
-
-template<typename T>
-struct assert_legacy_input_iterator : assert_legacy_iterator<T> {
-  static_assert(is_equality_comparable<T>::value, "");
-  static_assert(std::is_same<decltype(*std::declval<const T>()), typename std::iterator_traits<T>::reference>::value, "");
-  static_assert(std::is_same<decltype(*std::declval<const T>().T::operator->()), typename std::iterator_traits<T>::reference>::value, "");
-  static_assert(std::is_convertible<decltype(*std::declval<T>()++), typename std::iterator_traits<T>::value_type>::value, "");
-
- private:
-  // checking for contextual convertibility
-  using _ = decltype(true || (std::declval<const T>() != std::declval<const T>()));
-};
-
-}  // namespace utils
-}  // namespace minifi
-}  // namespace nifi
-}  // namespace apache
-}  // namespace org
diff --git a/libminifi/include/utils/requirements/LegacyIterator.h b/libminifi/include/utils/requirements/LegacyIterator.h
deleted file mode 100644
index fea38bb3b8..0000000000
--- a/libminifi/include/utils/requirements/LegacyIterator.h
+++ /dev/null
@@ -1,73 +0,0 @@
-/**
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <type_traits>
-#include <iterator>
-#include <utility>
-#include "utils/GeneralUtils.h"
-#include "Swappable.h"
-
-namespace org {
-namespace apache {
-namespace nifi {
-namespace minifi {
-namespace utils {
-
-namespace detail {
-
-template<typename T, typename = void>
-struct is_dereferenceable : std::false_type {};
-
-template<typename T>
-struct is_dereferenceable<T, std::void_t<decltype(*std::declval<T&>())>> : std::true_type {};
-
-template<typename T, typename = void>
-struct is_incrementable : std::false_type {};
-
-template<typename T>
-struct is_incrementable<T,
-    typename std::enable_if<
-        std::is_same<decltype(++std::declval<T&>()), T&>::value
-    >::type> : std::true_type {};
-
-}  // namespace detail
-
-template<typename T>
-struct assert_legacy_iterator {
-  static_assert(std::is_copy_constructible<T>::value, "");
-  static_assert(std::is_copy_assignable<T>::value, "");
-  static_assert(std::is_destructible<T>::value, "");
-  static_assert(is_swappable<T>::value, "");
-  static_assert(detail::is_dereferenceable<T>::value, "");
-  static_assert(detail::is_incrementable<T>::value, "");
-
- private:
-  using value_type = typename std::iterator_traits<T>::value_type;
-  using difference_type = typename std::iterator_traits<T>::difference_type;
-  using reference = typename std::iterator_traits<T>::reference;
-  using pointer = typename std::iterator_traits<T>::pointer;
-  using iterator_category = typename std::iterator_traits<T>::iterator_category;
-};
-
-}  // namespace utils
-}  // namespace minifi
-}  // namespace nifi
-}  // namespace apache
-}  // namespace org
diff --git a/libminifi/include/utils/requirements/Swappable.h b/libminifi/include/utils/requirements/Swappable.h
deleted file mode 100644
index 9369004eb3..0000000000
--- a/libminifi/include/utils/requirements/Swappable.h
+++ /dev/null
@@ -1,80 +0,0 @@
-/**
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <utility>
-#include "utils/GeneralUtils.h"
-
-namespace org {
-namespace apache {
-namespace nifi {
-namespace minifi {
-namespace utils {
-
-namespace detail {
-
-using std::swap;
-
-template<typename T, typename U, typename = void>
-struct is_swappable_with_impl: std::false_type {};
-
-
-template<typename T, typename U>
-struct is_swappable_with_impl<T, U,
-    std::void_t<decltype(
-      swap(std::declval<T>(), std::declval<U>()),
-      swap(std::declval<U>(), std::declval<T>()))
-    >> : std::true_type {};
-
-// non-cv-qualified non-ref-qualified functions
-template<typename T>
-struct is_simple_function : std::false_type {};
-
-// functions with fixed number of arguments
-template<typename R, typename ...Args>
-struct is_simple_function<R(Args...)> : std::true_type {};
-
-// variadic functions
-template<typename R, typename ...Args>
-struct is_simple_function<R(Args..., ...)> : std::true_type {};
-
-template<typename T>
-struct is_referenceable {
-  static constexpr bool value = is_simple_function<T>::value || std::is_object<T>::value;
-};
-
-}  // namespace detail
-
-template<typename T, typename U>
-using is_swappable_with = detail::is_swappable_with_impl<T, U>;
-
-template<typename T, typename = void>
-struct is_swappable : std::false_type{};
-
-template<typename T>
-struct is_swappable<T,
-    typename std::enable_if<
-      detail::is_referenceable<T>::value
-    >::type> : is_swappable_with<T&, T&> {};
-
-}  // namespace utils
-}  // namespace minifi
-}  // namespace nifi
-}  // namespace apache
-}  // namespace org
diff --git a/libminifi/src/core/state/nodes/DeviceInformation.cpp b/libminifi/src/core/state/nodes/DeviceInformation.cpp
index fb81e7634c..92b8465939 100644
--- a/libminifi/src/core/state/nodes/DeviceInformation.cpp
+++ b/libminifi/src/core/state/nodes/DeviceInformation.cpp
@@ -21,6 +21,8 @@
 #include <array>
 
 #include "core/Resource.h"
+#include "utils/net/NetworkInterfaceInfo.h"
+#include "utils/OsUtils.h"
 
 namespace org::apache::nifi::minifi::state::response {
 
diff --git a/libminifi/src/utils/ClassUtils.cpp b/libminifi/src/utils/ClassUtils.cpp
deleted file mode 100644
index e471ae0916..0000000000
--- a/libminifi/src/utils/ClassUtils.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-/**
- *
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "utils/ClassUtils.h"
-
-#include <iostream>
-#include <string>
-
-#include "utils/StringUtils.h"
-
-namespace org::apache::nifi::minifi::utils {
-
-bool ClassUtils::shortenClassName(std::string_view class_name, std::string &out) {
-  std::string class_delim = "::";
-  auto class_split = utils::string::split(class_name, class_delim);
-  // support . and ::
-  if (class_split.size() <= 1) {
-    if (class_name.find('.') != std::string::npos) {
-      class_delim = ".";
-      class_split = utils::string::split(class_name, class_delim);
-    } else {
-      // if no update can be performed, return false to let the developer know
-      // this. Out will have no updates
-      return false;
-    }
-  }
-  for (auto &elem : class_split) {
-    if (&elem != &class_split.back() && elem.size() > 1) {
-      elem = elem.substr(0, 1);
-    }
-  }
-
-  out = utils::string::join(class_delim, class_split);
-  return true;
-}
-
-}  // namespace org::apache::nifi::minifi::utils
diff --git a/libminifi/src/utils/Cron.cpp b/libminifi/src/utils/Cron.cpp
deleted file mode 100644
index 93dc84b66d..0000000000
--- a/libminifi/src/utils/Cron.cpp
+++ /dev/null
@@ -1,513 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "utils/Cron.h"
-#include <charconv>
-#include "utils/TimeUtil.h"
-#include "utils/StringUtils.h"
-#include "date/date.h"
-
-using namespace std::literals::chrono_literals;
-
-using std::chrono::seconds;
-using std::chrono::minutes;
-using std::chrono::hours;
-using std::chrono::days;
-
-using date::local_seconds;
-using date::day;
-using date::weekday;
-using date::month;
-using date::year;
-using date::year_month_day;
-using date::last;
-using date::local_days;
-using date::from_stream;
-using date::make_time;
-using date::Friday;
-using date::Saturday;
-using date::Sunday;
-
-namespace org::apache::nifi::minifi::utils {
-namespace {
-
-// https://github.com/HowardHinnant/date/issues/550
-// Due to https://gcc.gnu.org/bugzilla/show_bug.cgi?id=78714
-// the month parsing with '%b' and the weekday parsing with '%a' is case-sensitive in gcc11
-// This has been fixed in gcc13
-std::stringstream getCaseInsensitiveCStream(const std::string& str) {
-#if defined(__GNUC__) && (__GNUC__ < 13)
-  auto patched_str = string::toLower(str);
-  if (!patched_str.empty())
-    patched_str[0] = static_cast<char>(std::toupper(static_cast<unsigned char>(patched_str[0])));
-  auto stream = std::stringstream{patched_str};
-#else
-  auto stream = std::stringstream{str};
-#endif
-  stream.imbue(std::locale::classic());
-  return stream;
-}
-
-
-template<class T>
-std::optional<T> fromChars(const std::string& input) {
-  T t{};
-  const auto result = std::from_chars(input.data(), input.data() + input.size(), t);
-  if (result.ptr != input.data() + input.size())
-    return std::nullopt;
-  return t;
-}
-
-bool operator<=(const weekday& lhs, const weekday& rhs) {
-  return lhs.c_encoding() <= rhs.c_encoding();
-}
-
-template <typename FieldType>
-FieldType parse(const std::string&);
-
-template <>
-seconds parse<seconds>(const std::string& second_str) {
-  if (auto sec_int = fromChars<uint64_t>(second_str); sec_int && *sec_int <= 59)
-    return seconds(*sec_int);
-  throw BadCronExpression("Invalid second " + second_str);
-}
-
-template <>
-minutes parse<minutes>(const std::string& minute_str) {
-  if (auto min_int = fromChars<uint64_t>(minute_str); min_int && *min_int <= 59)
-    return minutes(*min_int);
-  throw BadCronExpression("Invalid minute " + minute_str);
-}
-
-template <>
-hours parse<hours>(const std::string& hour_str) {
-  if (auto hour_int = fromChars<uint64_t>(hour_str); hour_int && *hour_int <= 23)
-    return hours(*hour_int);
-  throw BadCronExpression("Invalid hour " + hour_str);
-}
-
-template <>
-days parse<days>(const std::string& days_str) {
-  if (auto days_int = fromChars<uint64_t>(days_str))
-    return days(*days_int);
-  throw BadCronExpression("Invalid days " + days_str);
-}
-
-template <>
-day parse<day>(const std::string& day_str) {
-  if (auto day_int = fromChars<unsigned int>(day_str); day_int && day_int.value() >= 1 && day_int.value() <= 31)
-    return day(*day_int);
-  throw BadCronExpression("Invalid day " + day_str);
-}
-
-template <>
-month parse<month>(const std::string& month_str) {
-  std::stringstream stream = getCaseInsensitiveCStream(month_str);
-
-  month parsed_month{};
-  if (month_str.size() > 2) {
-    from_stream(stream, "%b", parsed_month);
-    if (!stream.fail() && parsed_month.ok() && stream.peek() == EOF)
-      return parsed_month;
-  } else {
-    from_stream(stream, "%m", parsed_month);
-    if (!stream.fail() && parsed_month.ok() && stream.peek() == EOF)
-      return parsed_month;
-  }
-
-  throw BadCronExpression("Invalid month " + month_str);
-}
-
-template <>
-weekday parse<weekday>(const std::string& weekday_str) {
-  std::stringstream stream = getCaseInsensitiveCStream(weekday_str);
-
-  if (weekday_str.size() > 2) {
-    weekday parsed_weekday{};
-    from_stream(stream, "%a", parsed_weekday);
-    if (!stream.fail() && parsed_weekday.ok() && stream.peek() == EOF)
-      return parsed_weekday;
-  } else {
-    unsigned weekday_num = 0;
-    stream >> weekday_num;
-    if (!stream.fail() && weekday_num < 8 && stream.peek() == EOF)
-      return weekday(weekday_num);
-  }
-  throw BadCronExpression("Invalid weekday: " + weekday_str);
-}
-
-template <>
-year parse<year>(const std::string& year_str) {
-  if (auto year_int = fromChars<int>(year_str); year_int && *year_int >= 1970 && *year_int <= 2999)
-    return year(*year_int);
-  throw BadCronExpression("Invalid year: " + year_str);
-}
-
-template <typename FieldType>
-FieldType getFieldType(local_seconds time_point);
-
-template <>
-year getFieldType(local_seconds time_point) {
-  year_month_day year_month_day(floor<days>(time_point));
-  return year_month_day.year();
-}
-
-template <>
-month getFieldType(local_seconds time_point) {
-  year_month_day year_month_day(floor<days>(time_point));
-  return year_month_day.month();
-}
-
-template <>
-day getFieldType(local_seconds time_point) {
-  year_month_day year_month_day(floor<days>(time_point));
-  return year_month_day.day();
-}
-
-template <>
-hours getFieldType(local_seconds time_point) {
-  auto dp = floor<days>(time_point);
-  auto time = make_time(time_point-dp);
-  return time.hours();
-}
-
-template <>
-minutes getFieldType(local_seconds time_point) {
-  auto dp = floor<days>(time_point);
-  auto time = make_time(time_point-dp);
-  return time.minutes();
-}
-
-template <>
-seconds getFieldType(local_seconds time_point) {
-  auto dp = floor<days>(time_point);
-  auto time = make_time(time_point-dp);
-  return time.seconds();
-}
-
-template <>
-weekday getFieldType(local_seconds time_point) {
-  auto dp = floor<days>(time_point);
-  return weekday(dp);
-}
-
-bool isWeekday(year_month_day date) {
-  weekday date_weekday = weekday(local_days(date));
-  return date_weekday != Saturday && date_weekday != Sunday;
-}
-
-template <typename FieldType>
-class SingleValueField : public CronField {
- public:
-  explicit SingleValueField(FieldType value) : value_(value) {}
-
-  [[nodiscard]] bool matches(local_seconds time_point) const override {
-    return value_ == getFieldType<FieldType>(time_point);
-  }
-
-  bool operator==(const CronField& rhs) const override {
-    if (auto rhs_single_value = dynamic_cast<const SingleValueField*>(&rhs)) {
-      return value_ == rhs_single_value->value_;
-    }
-    return false;
-  }
-
-
- private:
-  FieldType value_;
-};
-
-class NotCheckedField : public CronField {
- public:
-  NotCheckedField() = default;
-
-  [[nodiscard]] bool matches(local_seconds) const override { return true; }
-};
-
-class AllValuesField : public CronField {
- public:
-  AllValuesField() = default;
-
-  [[nodiscard]] bool matches(local_seconds) const override { return true; }
-};
-
-template <typename FieldType>
-class RangeField : public CronField {
- public:
-  explicit RangeField(FieldType lower_bound, FieldType upper_bound)
-      : lower_bound_(std::move(lower_bound)),
-        upper_bound_(std::move(upper_bound)) {
-    if (!(lower_bound_ <= upper_bound_))
-      throw std::out_of_range("lower bound must be smaller or equal to upper bound");
-  }
-
-  [[nodiscard]] bool matches(local_seconds value) const override {
-    return lower_bound_ <= getFieldType<FieldType>(value) && getFieldType<FieldType>(value) <= upper_bound_;
-  }
-
- private:
-  FieldType lower_bound_;
-  FieldType upper_bound_;
-};
-
-template <typename FieldType>
-class ListField : public CronField {
- public:
-  explicit ListField(std::vector<FieldType> valid_values) : valid_values_(std::move(valid_values)) {}
-
-  [[nodiscard]] bool matches(local_seconds value) const override {
-    return std::find(valid_values_.begin(), valid_values_.end(), getFieldType<FieldType>(value)) != valid_values_.end();
-  }
-
- private:
-  std::vector<FieldType> valid_values_;
-};
-
-template <typename FieldType>
-class IncrementField : public CronField {
- public:
-  IncrementField(FieldType start, int increment) : start_(start), increment_(increment) {}
-
-  [[nodiscard]] bool matches(local_seconds value) const override {
-    return (getFieldType<FieldType>(value) - start_).count() % increment_ == 0;
-  }
-
- private:
-  FieldType start_;
-  int increment_;
-};
-
-class LastNthDayInMonthField : public CronField {
- public:
-  explicit LastNthDayInMonthField(days offset) : offset_(offset) {
-    if (!(offset_ <= std::chrono::days(30)))
-      throw BadCronExpression("Offset from last day must be <= 30");
-  }
-
-  [[nodiscard]] bool matches(local_seconds tp) const override {
-    year_month_day date(floor<days>(tp));
-    auto last_day = date.year() / date.month() / last;
-    auto target_date = local_days(last_day) - offset_;
-    return local_days(date) == target_date;
-  }
-
- private:
-  days offset_;
-};
-
-class NthWeekdayField : public CronField {
- public:
-  NthWeekdayField(weekday wday, uint8_t n) : weekday_(wday), n_(n) {}
-
-  [[nodiscard]] bool matches(local_seconds tp) const override {
-    year_month_day date(floor<days>(tp));
-    auto target_date = date.year() / date.month() / (weekday_[n_]);
-    return local_days(date) == local_days(target_date);
-  }
-
- private:
-  weekday weekday_;
-  uint8_t n_;
-};
-
-class LastWeekDayField : public CronField {
- public:
-  LastWeekDayField() = default;
-
-  [[nodiscard]] bool matches(local_seconds value) const override {
-    year_month_day date(floor<days>(value));
-    year_month_day last_day_of_the_month_date = year_month_day(local_days(date.year()/date.month()/last));
-    if (isWeekday(last_day_of_the_month_date))
-      return date == last_day_of_the_month_date;
-    year_month_day last_friday_of_the_month_date = year_month_day(local_days(date.year()/date.month()/Friday[last]));
-    return date == last_friday_of_the_month_date;
-  }
-};
-
-class LastSpecificDayOfTheWeekOfTheMonth : public CronField {
- public:
-  explicit LastSpecificDayOfTheWeekOfTheMonth(weekday wday) : weekday_(wday) {}
-
-  [[nodiscard]] bool matches(local_seconds value) const override {
-    year_month_day date(floor<days>(value));
-    year_month_day last_weekday_of_month_date = year_month_day(local_days(date.year()/date.month()/weekday_[last]));
-    return date == last_weekday_of_month_date;
-  }
- private:
-  weekday weekday_;
-};
-
-class ClosestWeekdayToTheNthDayOfTheMonth : public CronField {
- public:
-  explicit ClosestWeekdayToTheNthDayOfTheMonth(day day_number) : day_number_(day_number) {}
-
-  [[nodiscard]] bool matches(local_seconds value) const override {
-    year_month_day date(floor<days>(value));
-    for (auto diff : {0, -1, 1, -2, 2}) {
-      auto target_date = date.year() / date.month() / (day_number_ + days(diff));
-      if (target_date.ok() && isWeekday(target_date))
-        return target_date == date;
-    }
-
-    return false;
-  }
-
- private:
-  day day_number_;
-};
-
-template <typename FieldType>
-std::unique_ptr<CronField> parseCronField(const std::string& field_str) {
-  try {
-    if (field_str == "*") {
-      return std::make_unique<AllValuesField>();
-    }
-
-    if (field_str == "?") {
-      return std::make_unique<NotCheckedField>();
-    }
-
-    if (field_str == "L") {
-      if constexpr (std::is_same<day, FieldType>())
-        return std::make_unique<LastNthDayInMonthField>(days(0));
-      if constexpr (std::is_same<weekday, FieldType>())
-        return std::make_unique<SingleValueField<weekday>>(Saturday);
-      throw BadCronExpression("L can only be used in the Day of month/Day of week fields");
-    }
-
-    if (field_str == "LW") {
-      if constexpr (!std::is_same<day, FieldType>())
-        throw BadCronExpression("LW can only be used in the Day of month field");
-      return std::make_unique<LastWeekDayField>();
-    }
-
-    if (field_str.find('#') != std::string::npos) {
-      if constexpr (!std::is_same<weekday, FieldType>())
-        throw BadCronExpression("# can only be used in the Day of week field");
-      auto operands = string::split(field_str, "#");
-      if (operands.size() != 2)
-        throw BadCronExpression("Invalid field " + field_str);
-
-      if (auto second_operand = fromChars<uint8_t>(operands[1]))
-        return std::make_unique<NthWeekdayField>(parse<weekday>(operands[0]), *second_operand);
-    }
-
-    if (field_str.find('-') != std::string::npos) {
-      auto operands = string::split(field_str, "-");
-      if (operands.size() != 2)
-        throw BadCronExpression("Invalid field " + field_str);
-      if (operands[0] == "L") {
-        if constexpr (std::is_same<day, FieldType>())
-          return std::make_unique<LastNthDayInMonthField>(parse<days>(operands[1]));
-      }
-      return std::make_unique<RangeField<FieldType>>(parse<FieldType>(operands[0]), parse<FieldType>(operands[1]));
-    }
-
-    if (field_str.ends_with('L')) {
-      if constexpr (!std::is_same<weekday, FieldType>())
-        throw BadCronExpression("<X>L can only be used in the Day of week field");
-      auto prefix = field_str.substr(0, field_str.size()-1);
-      return std::make_unique<LastSpecificDayOfTheWeekOfTheMonth>(parse<weekday>(prefix));
-    }
-
-    if (field_str.find('/') != std::string::npos) {
-      auto operands = string::split(field_str, "/");
-      if (operands.size() != 2)
-        throw BadCronExpression("Invalid field " + field_str);
-      if (operands[0] == "*")
-        operands[0] = "0";
-      if (auto second_operand = fromChars<int>(operands[1]))
-        return std::make_unique<IncrementField<FieldType>>(parse<FieldType>(operands[0]), *second_operand);
-    }
-
-    if (field_str.find(',') != std::string::npos) {
-      auto operands_str = string::split(field_str, ",");
-      std::vector<FieldType> operands;
-      std::transform(operands_str.begin(), operands_str.end(), std::back_inserter(operands), parse<FieldType>);
-      return std::make_unique<ListField<FieldType>>(std::move(operands));
-    }
-
-    if (field_str.ends_with('W')) {
-      if constexpr (!std::is_same<day, FieldType>())
-        throw BadCronExpression("W can only be used in the Day of month field");
-      auto operands_str = string::split(field_str, "W");
-      if (operands_str.size() != 2)
-        throw BadCronExpression("Invalid field " + field_str);
-      return std::make_unique<ClosestWeekdayToTheNthDayOfTheMonth>(parse<day>(operands_str[0]));
-    }
-
-    return std::make_unique<SingleValueField<FieldType>>(parse<FieldType>(field_str));
-  } catch (const std::exception& e) {
-    throw BadCronExpression("Couldn't parse cron field: " + field_str + " " + e.what());
-  }
-}
-}  // namespace
-
-Cron::Cron(const std::string& expression) {
-  auto tokens = string::split(expression, " ");
-
-  if (tokens.size() != 6 && tokens.size() != 7)
-    throw BadCronExpression("malformed cron string (must be 6 or 7 fields): " + expression);
-
-  second_ = parseCronField<seconds>(tokens[0]);
-  minute_ = parseCronField<minutes>(tokens[1]);
-  hour_ = parseCronField<hours>(tokens[2]);
-  day_ = parseCronField<day>(tokens[3]);
-  month_ = parseCronField<month>(tokens[4]);
-  day_of_week_ = parseCronField<weekday>(tokens[5]);
-  if (tokens.size() == 7)
-    year_ = parseCronField<year>(tokens[6]);
-}
-
-std::optional<local_seconds> Cron::calculateNextTrigger(const local_seconds start) const {
-  gsl_Expects(second_ && minute_ && hour_ && day_ && month_ && day_of_week_);
-  auto next = timeutils::roundToNextSecond(start);
-  while (next < local_days((year(2999)/1/1))) {
-    if (year_ && !year_->matches(next)) {
-      next = timeutils::roundToNextYear(next);
-      continue;
-    }
-    if (!month_->matches(next)) {
-      next = timeutils::roundToNextMonth(next);
-      continue;
-    }
-    if (!day_->matches(next)) {
-      next = timeutils::roundToNextDay(next);
-      continue;
-    }
-    if (!day_of_week_->matches(next)) {
-      next = timeutils::roundToNextDay(next);
-      continue;
-    }
-    if (!hour_->matches(next)) {
-      next = timeutils::roundToNextHour(next);
-      continue;
-    }
-    if (!minute_->matches(next)) {
-      next = timeutils::roundToNextMinute(next);
-      continue;
-    }
-    if (!second_->matches(next)) {
-      next = timeutils::roundToNextSecond(next);
-      continue;
-    }
-    return next;
-  }
-  return std::nullopt;
-}
-
-}  // namespace org::apache::nifi::minifi::utils
diff --git a/libminifi/src/utils/Error.cpp b/libminifi/src/utils/Error.cpp
deleted file mode 100644
index ba6f15e9a2..0000000000
--- a/libminifi/src/utils/Error.cpp
+++ /dev/null
@@ -1,37 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "utils/Error.h"
-
-#include <cerrno>
-#include "utils/gsl.h"
-
-#ifdef WIN32
-#include <windows.h>
-#endif
-
-namespace org::apache::nifi::minifi::utils {
-
-std::error_code getLastError() {
-#ifdef WIN32
-  return {gsl::narrow<int>(GetLastError()), std::system_category()};
-#else
-  return {gsl::narrow<int>(errno), std::generic_category()};
-#endif
-}
-
-}  // namespace org::apache::nifi::minifi::utils
diff --git a/libminifi/src/utils/FifoExecutor.cpp b/libminifi/src/utils/FifoExecutor.cpp
deleted file mode 100644
index f7bf0a8070..0000000000
--- a/libminifi/src/utils/FifoExecutor.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "utils/FifoExecutor.h"
-
-namespace org::apache::nifi::minifi::utils::detail {
-WorkerThread::WorkerThread()
-    : thread_{&WorkerThread::run, this} {}
-
-WorkerThread::~WorkerThread() {
-  task_queue_.stop();
-  thread_.join();
-}
-
-void WorkerThread::run() noexcept {
-  while (task_queue_.isRunning()) {
-    task_queue_.consumeWait([](std::packaged_task<void()>&& f) { f(); });
-  }
-}
-}  // namespace org::apache::nifi::minifi::utils::detail
diff --git a/libminifi/src/utils/FileMutex.cpp b/libminifi/src/utils/FileMutex.cpp
deleted file mode 100644
index 758f1d248f..0000000000
--- a/libminifi/src/utils/FileMutex.cpp
+++ /dev/null
@@ -1,171 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "utils/FileMutex.h"
-
-#include <span>
-#include <iostream>
-#include "utils/gsl.h"
-#include "utils/OsUtils.h"
-#include "utils/Error.h"
-
-#ifdef WIN32
-
-namespace org::apache::nifi::minifi::utils {
-
-FileMutex::FileMutex(std::filesystem::path path): path_(std::move(path)) {}
-
-// we cannot assume the logging system to be initialized
-
-void FileMutex::lock() {
-  std::lock_guard guard(mtx_);
-  gsl_Expects(!file_handle_.has_value());
-  HANDLE handle = CreateFileA(path_.string().c_str(), GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
-
-  if (handle == INVALID_HANDLE_VALUE) {
-    const auto err = utils::getLastError();
-    std::string pid_str = "unknown";
-    handle = CreateFileA(path_.string().c_str(), GENERIC_READ, FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
-    if (handle == INVALID_HANDLE_VALUE) {
-      std::cerr << "Failed to open file to read pid: " << utils::getLastError().message() << std::endl;
-    } else {
-      std::array<char, 16> buffer = {};
-      size_t pid_str_size = 0;
-      DWORD read_size;
-      while (ReadFile(handle, buffer.data() + pid_str_size, gsl::narrow<DWORD>(buffer.size() - pid_str_size), &read_size, NULL) && read_size != 0) {
-        pid_str_size += read_size;
-      }
-      pid_str = "'" + std::string(buffer.data(), pid_str_size) + "'";
-      if (!CloseHandle(handle)) {
-        std::cerr << "Failed to close file after unsuccessful locking attempt: " << utils::getLastError().message() << std::endl;
-      }
-    }
-
-    throw std::system_error{err, "Failed to open file '" + path_.string() + "' to be locked, previous pid: " + pid_str};
-  }
-
-  const std::string pidstr = std::to_string(utils::OsUtils::getCurrentProcessId());
-  std::span<const char> buffer = pidstr;
-  while (!buffer.empty()) {
-    DWORD written;
-    if (!WriteFile(handle, buffer.data(), gsl::narrow<DWORD>(buffer.size()), &written, NULL)) {
-      const auto err = utils::getLastError();
-      if (!CloseHandle(file_handle_.value())) {
-        std::cerr << "Failed to close file: " << utils::getLastError().message() << std::endl;
-      }
-      throw std::system_error(err, "Failed to write pid to lock file '" + path_.string() + "'");
-    }
-    buffer = buffer.subspan(written);
-  }
-
-  file_handle_ = handle;
-}
-
-void FileMutex::unlock() {
-  std::lock_guard guard(mtx_);
-  gsl_Expects(file_handle_.has_value());
-  if (!CloseHandle(file_handle_.value())) {
-    std::cerr << "Failed to close file: " << utils::getLastError().message() << std::endl;
-  }
-  file_handle_.reset();
-}
-
-}  // namespace org::apache::nifi::minifi::utils
-
-#else
-
-#include <fcntl.h>
-#include <unistd.h>
-#include <cstring>
-
-namespace org::apache::nifi::minifi::utils {
-
-FileMutex::FileMutex(std::filesystem::path path): path_(std::move(path)) {}
-
-void FileMutex::lock() {
-  std::lock_guard guard(mtx_);
-  gsl_Expects(!file_handle_.has_value());
-  int flags = O_RDWR | O_CREAT;
-#ifdef O_CLOEXEC
-  flags |= O_CLOEXEC;
-#endif
-  int fd = open(path_.string().c_str(), flags, 0644);
-  if (fd < 0) {
-    throw std::system_error{utils::getLastError(), "Failed to open file '" + path_.string() + "' to be locked"};
-  }
-
-  struct flock file_lock_info{};
-  file_lock_info.l_type = F_WRLCK;
-  int value = fcntl(fd, F_SETLK, &file_lock_info);
-  if (value == -1) {
-    const auto err = utils::getLastError();
-    std::string pid_str = "unknown";
-    std::array<char, 16> buffer{};
-    size_t pid_str_size = 0;
-    ssize_t ret = 0;
-    while ((ret = read(fd, buffer.data() + pid_str_size, buffer.size() - pid_str_size)) > 0) {
-      pid_str_size += ret;
-    }
-    if (ret < 0) {
-      std::cerr << "Failed to read file content: " << utils::getLastError().message() << std::endl;
-    } else {
-      pid_str = "'" + std::string(buffer.data(), pid_str_size) + "'";
-    }
-
-    if (close(fd) == -1) {
-      std::cerr << "Failed to close file after unsuccessful locking attempt: " << utils::getLastError().message() << std::endl;
-    }
-    throw std::system_error{err, "Failed to lock file '" + path_.string() + "', previous pid: " + pid_str};
-  }
-
-  const std::string pidstr = std::to_string(utils::OsUtils::getCurrentProcessId());
-  std::span<const char> buffer = pidstr;
-  while (!buffer.empty()) {
-    ssize_t ret = write(fd, buffer.data(), buffer.size());
-    if (ret < 0) {
-      const auto err = utils::getLastError();
-      if (close(fd) == -1) {
-        std::cerr << "Failed to close file after unsuccessful pid write attempt: " << utils::getLastError().message() << std::endl;
-      }
-      throw std::system_error{err, "Failed to write pid to lock file '" + path_.string() + "'"};
-    }
-    buffer = buffer.subspan(ret);
-  }
-
-  file_handle_ = fd;
-}
-
-void FileMutex::unlock() {
-  std::lock_guard guard(mtx_);
-  gsl_Expects(file_handle_.has_value());
-  auto file_guard = gsl::finally([&] {
-    if (close(file_handle_.value()) == -1) {
-      std::cerr << "Failed to close file after unlock: " << utils::getLastError().message() << std::endl;
-    }
-    file_handle_.reset();
-  });
-  struct flock file_lock_info{};
-  file_lock_info.l_type = F_UNLCK;
-  int value = fcntl(file_handle_.value(), F_SETLK, &file_lock_info);
-  if (value == -1) {
-    throw std::system_error{utils::getLastError(), "Failed to unlock file '" + path_.string() + "'"};
-  }
-}
-
-}  // namespace org::apache::nifi::minifi::utils
-
-#endif
diff --git a/libminifi/src/utils/LineByLineInputOutputStreamCallback.cpp b/libminifi/src/utils/LineByLineInputOutputStreamCallback.cpp
deleted file mode 100644
index af2307e5c8..0000000000
--- a/libminifi/src/utils/LineByLineInputOutputStreamCallback.cpp
+++ /dev/null
@@ -1,75 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "utils/LineByLineInputOutputStreamCallback.h"
-
-#include "utils/gsl.h"
-#include "utils/span.h"
-
-namespace org::apache::nifi::minifi::utils {
-
-LineByLineInputOutputStreamCallback::LineByLineInputOutputStreamCallback(CallbackType callback)
-  : callback_(std::move(callback)) {
-}
-
-int64_t LineByLineInputOutputStreamCallback::operator()(const std::shared_ptr<io::InputStream>& input, const std::shared_ptr<io::OutputStream>& output) {
-  gsl_Expects(input);
-  gsl_Expects(output);
-
-  if (int64_t status = readInput(*input); status <= 0) {
-    return status;
-  }
-
-  std::size_t total_bytes_written_ = 0;
-  bool is_first_line = true;
-  readLine();
-  do {
-    readLine();
-    std::string output_line = callback_(*current_line_, is_first_line, isLastLine());
-    const auto bytes_written = output->write(reinterpret_cast<const uint8_t *>(output_line.data()), output_line.size());
-    if (io::isError(bytes_written)) { return -1; }
-    total_bytes_written_ += bytes_written;
-    is_first_line = false;
-  } while (!isLastLine());
-
-  return gsl::narrow<int64_t>(total_bytes_written_);
-}
-
-int64_t LineByLineInputOutputStreamCallback::readInput(io::InputStream& stream) {
-  input_.resize(stream.size());
-  const auto status = stream.read(input_);
-  if (io::isError(status)) { return -1; }
-  current_pos_ = input_.begin();
-  return gsl::narrow<int64_t>(input_.size());
-}
-
-void LineByLineInputOutputStreamCallback::readLine() {
-  if (current_pos_ == input_.end()) {
-    current_line_ = next_line_;
-    next_line_ = std::nullopt;
-    return;
-  }
-
-  auto end_of_line = std::find(current_pos_, input_.end(), static_cast<std::byte>('\n'));
-  if (end_of_line != input_.end()) { ++end_of_line; }
-
-  current_line_ = next_line_;
-  next_line_ = utils::span_to<std::string>(utils::as_span<char>(std::span(std::to_address(current_pos_), std::to_address(end_of_line))));
-  current_pos_ = end_of_line;
-}
-
-}  // namespace org::apache::nifi::minifi::utils
diff --git a/libminifi/src/utils/ProcessCpuUsageTracker.cpp b/libminifi/src/utils/ProcessCpuUsageTracker.cpp
deleted file mode 100644
index 7a2e360fc0..0000000000
--- a/libminifi/src/utils/ProcessCpuUsageTracker.cpp
+++ /dev/null
@@ -1,141 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "utils/ProcessCpuUsageTracker.h"
-
-#ifndef WIN32
-#include <sys/times.h>
-#endif
-
-#include <thread>
-#include <algorithm>
-
-namespace org::apache::nifi::minifi::utils {
-#ifndef WIN32
-ProcessCpuUsageTracker::ProcessCpuUsageTracker()
-    : cpu_times_(0),
-      sys_cpu_times_(0),
-      user_cpu_times_(0),
-      previous_cpu_times_(0),
-      previous_sys_cpu_times_(0),
-      previous_user_cpu_times_(0) {
-  queryCpuTimes();
-}
-
-double ProcessCpuUsageTracker::getCpuUsageAndRestartCollection() {
-  queryCpuTimes();
-  if (isCurrentQuerySameAsPrevious() || isCurrentQueryOlderThanPrevious()) {
-    return -1.0;
-  } else {
-    return getProcessCpuUsageBetweenLastTwoQueries();
-  }
-}
-
-void ProcessCpuUsageTracker::queryCpuTimes() {
-  previous_cpu_times_ = cpu_times_;
-  previous_sys_cpu_times_ = sys_cpu_times_;
-  previous_user_cpu_times_ = user_cpu_times_;
-
-  struct tms timeSample{};
-  cpu_times_ = times(&timeSample);
-  sys_cpu_times_ = timeSample.tms_stime;
-  user_cpu_times_ = timeSample.tms_utime;
-}
-
-bool ProcessCpuUsageTracker::isCurrentQueryOlderThanPrevious() const {
-  return (cpu_times_ < previous_cpu_times_ ||
-          sys_cpu_times_ < previous_sys_cpu_times_ ||
-          user_cpu_times_ < previous_user_cpu_times_);
-}
-
-bool ProcessCpuUsageTracker::isCurrentQuerySameAsPrevious() const {
-  return (cpu_times_ == previous_cpu_times_ &&
-          sys_cpu_times_ == previous_sys_cpu_times_ &&
-          user_cpu_times_ == previous_user_cpu_times_);
-}
-
-double ProcessCpuUsageTracker::getProcessCpuUsageBetweenLastTwoQueries() const {
-  clock_t cpu_times_diff = cpu_times_ - previous_cpu_times_;
-  if (cpu_times_diff == 0) {
-    return -1.0;
-  }
-  clock_t sys_cpu_times_diff = sys_cpu_times_ - previous_sys_cpu_times_;
-  clock_t user_cpu_times_diff = user_cpu_times_ - previous_user_cpu_times_;
-  double percent = static_cast<double>(sys_cpu_times_diff + user_cpu_times_diff) / static_cast<double>(cpu_times_diff);
-  percent = percent / (std::max)(uint32_t{1}, std::thread::hardware_concurrency());
-  return percent;
-}
-
-#else
-
-ProcessCpuUsageTracker::ProcessCpuUsageTracker() :
-    cpu_times_(0), previous_cpu_times_(0),
-    sys_cpu_times_(0), previous_sys_cpu_times_(0),
-    user_cpu_times_(0), previous_user_cpu_times_(0) {
-  self_ = GetCurrentProcess();
-  queryCpuTimes();
-}
-
-double ProcessCpuUsageTracker::getCpuUsageAndRestartCollection() {
-  queryCpuTimes();
-  if (isCurrentQuerySameAsPrevious() || isCurrentQueryOlderThanPrevious()) {
-    return -1.0;
-  } else {
-    return getProcessCpuUsageBetweenLastTwoQueries();
-  }
-}
-
-bool ProcessCpuUsageTracker::isCurrentQueryOlderThanPrevious() const {
-  return (cpu_times_ < previous_cpu_times_ ||
-          sys_cpu_times_ < previous_sys_cpu_times_ ||
-          user_cpu_times_ < previous_user_cpu_times_);
-}
-
-bool ProcessCpuUsageTracker::isCurrentQuerySameAsPrevious() const {
-  return (cpu_times_ == previous_cpu_times_ &&
-          sys_cpu_times_ == previous_sys_cpu_times_ &&
-          user_cpu_times_ == previous_user_cpu_times_);
-}
-
-void ProcessCpuUsageTracker::queryCpuTimes() {
-  previous_cpu_times_ = cpu_times_;
-  previous_sys_cpu_times_ = sys_cpu_times_;
-  previous_user_cpu_times_ = user_cpu_times_;
-  FILETIME ftime, fsys, fuser;
-  GetSystemTimeAsFileTime(&ftime);
-
-  cpu_times_ = ULARGE_INTEGER{ ftime.dwLowDateTime, ftime.dwHighDateTime }.QuadPart;
-
-  GetProcessTimes(self_, &ftime, &ftime, &fsys, &fuser);
-  sys_cpu_times_ = ULARGE_INTEGER{ fsys.dwLowDateTime, fsys.dwHighDateTime }.QuadPart;
-  user_cpu_times_ = ULARGE_INTEGER{ fuser.dwLowDateTime, fuser.dwHighDateTime }.QuadPart;
-}
-
-double ProcessCpuUsageTracker::getProcessCpuUsageBetweenLastTwoQueries() const {
-  uint64_t cpu_times_diff = cpu_times_ - previous_cpu_times_;
-  if (cpu_times_diff == 0) {
-    return -1.0;
-  }
-  uint64_t sys_cpu_times_diff = sys_cpu_times_ - previous_sys_cpu_times_;
-  uint64_t user_cpu_times_diff = user_cpu_times_ - previous_user_cpu_times_;
-  double percent = static_cast<double>(sys_cpu_times_diff + user_cpu_times_diff) / static_cast<double>(cpu_times_diff);
-  percent = percent / (std::max)(uint32_t{1}, std::thread::hardware_concurrency());
-  return percent;
-}
-#endif
-
-}  // namespace org::apache::nifi::minifi::utils
diff --git a/libminifi/src/utils/StoppableThread.cpp b/libminifi/src/utils/StoppableThread.cpp
deleted file mode 100644
index 8fea65a6dc..0000000000
--- a/libminifi/src/utils/StoppableThread.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "utils/StoppableThread.h"
-#include "utils/gsl.h"
-
-namespace org::apache::nifi::minifi::utils {
-
-static thread_local StoppableThread* current_thread;
-
-StoppableThread::StoppableThread(std::function<void()> fn) {
-  thread_ = std::thread{[fn = std::move(fn), this] {
-    current_thread = this;
-    fn();
-  }};
-}
-
-bool StoppableThread::waitForStopRequest(std::chrono::milliseconds time) {
-  gsl_Expects(current_thread);
-  std::unique_lock lock(current_thread->mtx_);
-  // wait_for returns false if the predicate is still false, i.e. the thread is running
-  return current_thread->cv_.wait_for(lock, time, [&] {return !current_thread->running_;});
-}
-
-}  // namespace org::apache::nifi::minifi::utils
diff --git a/libminifi/src/utils/SystemCpuUsageTracker.cpp b/libminifi/src/utils/SystemCpuUsageTracker.cpp
deleted file mode 100644
index 049dd07025..0000000000
--- a/libminifi/src/utils/SystemCpuUsageTracker.cpp
+++ /dev/null
@@ -1,192 +0,0 @@
-/**
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "utils/SystemCpuUsageTracker.h"
-#include "utils/gsl.h"
-
-namespace org::apache::nifi::minifi::utils {
-#ifdef __linux__
-
-SystemCpuUsageTracker::SystemCpuUsageTracker() :
-    total_user_(0), previous_total_user_(0),
-    total_user_low_(0), previous_total_user_low_(0),
-    total_sys_(0), previous_total_sys_(0),
-    total_idle_(0), previous_total_idle_(0) {
-  queryCpuTimes();
-}
-
-double SystemCpuUsageTracker::getCpuUsageAndRestartCollection() {
-  queryCpuTimes();
-  if (isCurrentQuerySameAsPrevious() || isCurrentQueryOlderThanPrevious()) {
-    return -1.0;
-  } else {
-    return getCpuUsageBetweenLastTwoQueries();
-  }
-}
-
-void SystemCpuUsageTracker::queryCpuTimes() {
-  previous_total_user_ = total_user_;
-  previous_total_user_low_ = total_user_low_;
-  previous_total_sys_ = total_sys_;
-  previous_total_idle_ = total_idle_;
-  gsl::owner<FILE*> file = fopen("/proc/stat", "r");
-  if (fscanf(file, "cpu %lu %lu %lu %lu", &total_user_, &total_user_low_, &total_sys_, &total_idle_) != 4) {  // NOLINT(cert-err34-c)
-    total_user_ = previous_total_user_;
-    total_user_low_ = previous_total_user_low_;
-    total_idle_ = previous_total_idle_;
-    total_sys_ = previous_total_sys_;
-  }
-  (void)fclose(file);
-}
-
-bool SystemCpuUsageTracker::isCurrentQueryOlderThanPrevious() const {
-  return (total_user_ < previous_total_user_ ||
-          total_user_low_ < previous_total_user_low_ ||
-          total_sys_ < previous_total_sys_ ||
-          total_idle_ < previous_total_idle_);
-}
-
-bool SystemCpuUsageTracker::isCurrentQuerySameAsPrevious() const {
-  return (total_user_ == previous_total_user_ &&
-          total_user_low_ == previous_total_user_low_ &&
-          total_sys_ == previous_total_sys_ &&
-          total_idle_ == previous_total_idle_);
-}
-
-double SystemCpuUsageTracker::getCpuUsageBetweenLastTwoQueries() const {
-  uint64_t total_user_diff = total_user_ - previous_total_user_;
-  uint64_t total_user_low_diff = total_user_low_ - previous_total_user_low_;
-  uint64_t total_system_diff = total_sys_ - previous_total_sys_;
-  uint64_t total_idle_diff = total_idle_ - previous_total_idle_;
-  uint64_t total_diff = total_user_diff + total_user_low_diff + total_system_diff;
-  if (total_diff + total_idle_diff == 0) {
-    return -1.0;
-  }
-  double percent = static_cast<double>(total_diff) / static_cast<double>(total_diff + total_idle_diff);
-
-  return percent;
-}
-#endif  // linux
-
-#ifdef WIN32
-SystemCpuUsageTracker::SystemCpuUsageTracker() :
-    total_user_(0), previous_total_user_(0),
-    total_sys_(0), previous_total_sys_(0),
-    total_idle_(0), previous_total_idle_(0) {
-  queryCpuTimes();
-}
-
-double SystemCpuUsageTracker::getCpuUsageAndRestartCollection() {
-  queryCpuTimes();
-  if (isCurrentQuerySameAsPrevious() || isCurrentQueryOlderThanPrevious()) {
-    return -1.0;
-  } else {
-    return getCpuUsageBetweenLastTwoQueries();
-  }
-}
-
-void SystemCpuUsageTracker::queryCpuTimes() {
-  previous_total_user_ = total_user_;
-  previous_total_sys_ = total_sys_;
-  previous_total_idle_ = total_idle_;
-  FILETIME fidle, fsys, fuser;
-  GetSystemTimes(&fidle, &fsys, &fuser);
-  total_user_ = ULARGE_INTEGER{ fuser.dwLowDateTime, fuser.dwHighDateTime }.QuadPart;
-  total_sys_ = ULARGE_INTEGER{ fsys.dwLowDateTime, fsys.dwHighDateTime }.QuadPart;
-  total_idle_ = ULARGE_INTEGER{ fidle.dwLowDateTime, fidle.dwHighDateTime }.QuadPart;
-}
-
-bool SystemCpuUsageTracker::isCurrentQueryOlderThanPrevious() const {
-  return (total_user_ < previous_total_user_ ||
-    total_sys_ < previous_total_sys_ ||
-    total_idle_ < previous_total_idle_);
-}
-
-bool SystemCpuUsageTracker::isCurrentQuerySameAsPrevious() const {
-  return (total_user_ == previous_total_user_ &&
-    total_sys_ == previous_total_sys_ &&
-    total_idle_ == previous_total_idle_);
-}
-
-double SystemCpuUsageTracker::getCpuUsageBetweenLastTwoQueries() const {
-  uint64_t total_user_diff = total_user_ - previous_total_user_;
-  uint64_t total_sys_diff = total_sys_ - previous_total_sys_;
-  uint64_t total_idle_diff = total_idle_ - previous_total_idle_;
-  uint64_t total_diff = total_user_diff + total_sys_diff;
-  if (total_diff == 0) {
-    return -1.0;
-  }
-  double percent = static_cast<double>(total_diff - total_idle_diff) / static_cast<double>(total_diff);
-
-  return percent;
-}
-#endif  // windows
-
-#ifdef __APPLE__
-SystemCpuUsageTracker::SystemCpuUsageTracker() :
-    total_ticks_(0), previous_total_ticks_(0),
-    idle_ticks_(0), previous_idle_ticks_(0) {
-  queryCpuTicks();
-}
-
-double SystemCpuUsageTracker::getCpuUsageAndRestartCollection() {
-  queryCpuTicks();
-  if (isCurrentQuerySameAsPrevious() || isCurrentQueryOlderThanPrevious()) {
-    return -1.0;
-  } else {
-    return getCpuUsageBetweenLastTwoQueries();
-  }
-}
-
-void SystemCpuUsageTracker::queryCpuTicks() {
-  host_cpu_load_info_data_t cpuinfo;
-  mach_msg_type_number_t count = HOST_CPU_LOAD_INFO_COUNT;
-  auto query_result = host_statistics(mach_host_self(), HOST_CPU_LOAD_INFO, (host_info_t)&cpuinfo, &count);
-  if (query_result == KERN_SUCCESS) {
-    previous_total_ticks_ = total_ticks_;
-    previous_idle_ticks_ = idle_ticks_;
-    total_ticks_ = 0;
-    for (int i = 0; i < CPU_STATE_MAX; i++) {
-      total_ticks_ += cpuinfo.cpu_ticks[i];
-    }
-    idle_ticks_ = cpuinfo.cpu_ticks[CPU_STATE_IDLE];
-  }
-}
-
-bool SystemCpuUsageTracker::isCurrentQueryOlderThanPrevious() const {
-  return (total_ticks_ < previous_total_ticks_ ||
-          idle_ticks_ < previous_idle_ticks_);
-}
-
-bool SystemCpuUsageTracker::isCurrentQuerySameAsPrevious() const {
-  return (total_ticks_ == previous_total_ticks_ &&
-          idle_ticks_ == previous_idle_ticks_);
-}
-
-double SystemCpuUsageTracker::getCpuUsageBetweenLastTwoQueries() const {
-  uint64_t total_ticks_since_last_time = total_ticks_-previous_total_ticks_;
-  uint64_t idle_ticks_since_last_time  = idle_ticks_-previous_idle_ticks_;
-  if (total_ticks_since_last_time == 0) {
-    return -1.0;
-  }
-  double percent = static_cast<double>(total_ticks_since_last_time - idle_ticks_since_last_time) / static_cast<double>(total_ticks_since_last_time);
-
-  return percent;
-}
-#endif  // macOS
-
-}  // namespace org::apache::nifi::minifi::utils
diff --git a/libminifi/test/integration/C2PropertiesUpdateTests.cpp b/libminifi/test/integration/C2PropertiesUpdateTests.cpp
index 7669f250da..6d0b80b310 100644
--- a/libminifi/test/integration/C2PropertiesUpdateTests.cpp
+++ b/libminifi/test/integration/C2PropertiesUpdateTests.cpp
@@ -26,7 +26,6 @@
 #include "spdlog/sinks/stdout_sinks.h"
 #include "spdlog/sinks/ostream_sink.h"
 #include "spdlog/sinks/dist_sink.h"
-#include "unit/LogUtils.h"
 #include "properties/PropertiesFile.h"
 #include "ConfigTestAccessor.h"
 #include "unit/Catch.h"
diff --git a/libminifi/test/keyvalue-tests/PersistentStateStorageTest.cpp b/libminifi/test/keyvalue-tests/PersistentStateStorageTest.cpp
index d032d7c8bb..a77aab2e5f 100644
--- a/libminifi/test/keyvalue-tests/PersistentStateStorageTest.cpp
+++ b/libminifi/test/keyvalue-tests/PersistentStateStorageTest.cpp
@@ -28,7 +28,7 @@
 #include "core/ProcessGroup.h"
 #include "core/yaml/YamlConfiguration.h"
 #include "controllers/keyvalue/KeyValueStateStorage.h"
-#include "controllers/keyvalue/AutoPersistor.h"
+#include "utils/AutoPersistor.h"
 #include "unit/ProvenanceTestHelper.h"
 #include "repository/VolatileContentRepository.h"
 #include "utils/file/FileUtils.h"
diff --git a/libminifi/test/keyvalue-tests/VolatileMapStateStorageTest.cpp b/libminifi/test/keyvalue-tests/VolatileMapStateStorageTest.cpp
index 62a3b0a85f..48055c98ae 100644
--- a/libminifi/test/keyvalue-tests/VolatileMapStateStorageTest.cpp
+++ b/libminifi/test/keyvalue-tests/VolatileMapStateStorageTest.cpp
@@ -22,7 +22,7 @@
 #include "unit/TestBase.h"
 #include "unit/Catch.h"
 #include "catch2/catch_session.hpp"
-#include "controllers/keyvalue/AutoPersistor.h"
+#include "utils/AutoPersistor.h"
 #include "controllers/keyvalue/KeyValueStateStorage.h"
 #include "core/ProcessGroup.h"
 #include "core/yaml/YamlConfiguration.h"
diff --git a/libminifi/test/unit/LineByLineInputOutputStreamCallbackTests.cpp b/libminifi/test/unit/LineByLineInputOutputStreamCallbackTests.cpp
index 29e6dfac43..2e3ce3c60b 100644
--- a/libminifi/test/unit/LineByLineInputOutputStreamCallbackTests.cpp
+++ b/libminifi/test/unit/LineByLineInputOutputStreamCallbackTests.cpp
@@ -14,7 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "LineByLineInputOutputStreamCallback.h"
+#include "utils/LineByLineInputOutputStreamCallback.h"
 
 #include "unit/TestBase.h"
 #include "unit/Catch.h"
diff --git a/libminifi/test/unit/NetworkInterfaceInfoTests.cpp b/libminifi/test/unit/NetworkInterfaceInfoTests.cpp
index 6c42a4f33d..bb57e294d0 100644
--- a/libminifi/test/unit/NetworkInterfaceInfoTests.cpp
+++ b/libminifi/test/unit/NetworkInterfaceInfoTests.cpp
@@ -17,7 +17,7 @@
 
 #include "unit/TestBase.h"
 #include "unit/Catch.h"
-#include "utils/NetworkInterfaceInfo.h"
+#include "utils/net/NetworkInterfaceInfo.h"
 
 namespace utils = org::apache::nifi::minifi::utils;
 
diff --git a/libminifi/test/unit/OpenTelemetryLogDataModelTests.cpp b/libminifi/test/unit/OpenTelemetryLogDataModelTests.cpp
index 1d5bd9f5b1..65b6b4b611 100644
--- a/libminifi/test/unit/OpenTelemetryLogDataModelTests.cpp
+++ b/libminifi/test/unit/OpenTelemetryLogDataModelTests.cpp
@@ -21,6 +21,8 @@
 
 namespace utils = org::apache::nifi::minifi::utils;
 
+// TODO(mzink) move to extension-utils-tests
+
 TEST_CASE("OpenTelemetryLogDataModel tests", "[testnetworkadapter]") {
   rapidjson::Document document(rapidjson::kObjectType);
   utils::OpenTelemetryLogDataModel::appendEventInformation(document, "testevent");
diff --git a/utils/include/core/ClassLoader.h b/utils/include/core/ClassLoader.h
index 84a565e699..fc6cba0431 100644
--- a/utils/include/core/ClassLoader.h
+++ b/utils/include/core/ClassLoader.h
@@ -44,4 +44,5 @@ T *ClassLoader::instantiateRaw(const std::string &class_name, const std::string
   }));
 }
 
+
 }  // namespace org::apache::nifi::minifi::core
diff --git a/utils/include/core/Deprecated.h b/utils/include/core/Deprecated.h
deleted file mode 100644
index 4dd7e54a25..0000000000
--- a/utils/include/core/Deprecated.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/**
-
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#ifndef LIBMINIFI_INCLUDE_CORE_DEPRECATED_H_
-#define LIBMINIFI_INCLUDE_CORE_DEPRECATED_H_
-
-#ifdef _MSC_VER
-#define DEPRECATED(v, ev) __declspec(deprecated)
-#elif defined(__GNUC__) | defined(__clang__)
-#define DEPRECATED(v, ev) __attribute__((__deprecated__))
-#else
-#define DEPRECATED(v, ev)
-#endif
-
-#endif /* LIBMINIFI_INCLUDE_CORE_DEPRECATED_H_ */
diff --git a/utils/include/http/BaseHTTPClient.h b/utils/include/http/BaseHTTPClient.h
index 318a14eb34..016abb12bc 100644
--- a/utils/include/http/BaseHTTPClient.h
+++ b/utils/include/http/BaseHTTPClient.h
@@ -27,7 +27,6 @@
 
 #include "utils/ByteArrayCallback.h"
 #include "minifi-cpp/controllers/SSLContextService.h"
-#include "core/Deprecated.h"
 #include "utils/gsl.h"
 
 namespace org::apache::nifi::minifi::http {
diff --git a/extension-utils/include/controllers/keyvalue/AutoPersistor.h b/utils/include/utils/AutoPersistor.h
similarity index 100%
rename from extension-utils/include/controllers/keyvalue/AutoPersistor.h
rename to utils/include/utils/AutoPersistor.h
diff --git a/extension-utils/include/utils/CallBackTimer.h b/utils/include/utils/CallBackTimer.h
similarity index 100%
rename from extension-utils/include/utils/CallBackTimer.h
rename to utils/include/utils/CallBackTimer.h
diff --git a/extension-utils/include/utils/ClassUtils.h b/utils/include/utils/ClassUtils.h
similarity index 100%
rename from extension-utils/include/utils/ClassUtils.h
rename to utils/include/utils/ClassUtils.h
diff --git a/extension-utils/include/utils/CollectionUtils.h b/utils/include/utils/CollectionUtils.h
similarity index 100%
rename from extension-utils/include/utils/CollectionUtils.h
rename to utils/include/utils/CollectionUtils.h
diff --git a/extension-utils/include/utils/Cron.h b/utils/include/utils/Cron.h
similarity index 100%
rename from extension-utils/include/utils/Cron.h
rename to utils/include/utils/Cron.h
diff --git a/extension-utils/include/utils/Error.h b/utils/include/utils/Error.h
similarity index 100%
rename from extension-utils/include/utils/Error.h
rename to utils/include/utils/Error.h
diff --git a/extension-utils/include/utils/Export.h b/utils/include/utils/Export.h
similarity index 100%
rename from extension-utils/include/utils/Export.h
rename to utils/include/utils/Export.h
diff --git a/extension-utils/include/utils/FifoExecutor.h b/utils/include/utils/FifoExecutor.h
similarity index 100%
rename from extension-utils/include/utils/FifoExecutor.h
rename to utils/include/utils/FifoExecutor.h
diff --git a/extension-utils/include/utils/FileMutex.h b/utils/include/utils/FileMutex.h
similarity index 100%
rename from extension-utils/include/utils/FileMutex.h
rename to utils/include/utils/FileMutex.h
diff --git a/extension-utils/include/utils/IntervalSwitch.h b/utils/include/utils/IntervalSwitch.h
similarity index 100%
rename from extension-utils/include/utils/IntervalSwitch.h
rename to utils/include/utils/IntervalSwitch.h
diff --git a/extension-utils/include/utils/JsonCallback.h b/utils/include/utils/JsonCallback.h
similarity index 100%
rename from extension-utils/include/utils/JsonCallback.h
rename to utils/include/utils/JsonCallback.h
diff --git a/extension-utils/include/utils/LineByLineInputOutputStreamCallback.h b/utils/include/utils/LineByLineInputOutputStreamCallback.h
similarity index 100%
rename from extension-utils/include/utils/LineByLineInputOutputStreamCallback.h
rename to utils/include/utils/LineByLineInputOutputStreamCallback.h
diff --git a/extension-utils/include/utils/LogUtils.h b/utils/include/utils/LogUtils.h
similarity index 100%
rename from extension-utils/include/utils/LogUtils.h
rename to utils/include/utils/LogUtils.h
diff --git a/extension-utils/include/utils/MapUtils.h b/utils/include/utils/MapUtils.h
similarity index 100%
rename from extension-utils/include/utils/MapUtils.h
rename to utils/include/utils/MapUtils.h
diff --git a/extension-utils/include/utils/ProcessCpuUsageTracker.h b/utils/include/utils/ProcessCpuUsageTracker.h
similarity index 100%
rename from extension-utils/include/utils/ProcessCpuUsageTracker.h
rename to utils/include/utils/ProcessCpuUsageTracker.h
diff --git a/extension-utils/include/utils/StoppableThread.h b/utils/include/utils/StoppableThread.h
similarity index 100%
rename from extension-utils/include/utils/StoppableThread.h
rename to utils/include/utils/StoppableThread.h
diff --git a/extension-utils/include/utils/SystemCpuUsageTracker.h b/utils/include/utils/SystemCpuUsageTracker.h
similarity index 100%
rename from extension-utils/include/utils/SystemCpuUsageTracker.h
rename to utils/include/utils/SystemCpuUsageTracker.h
diff --git a/extension-utils/include/utils/UnicodeConversion.h b/utils/include/utils/UnicodeConversion.h
similarity index 100%
rename from extension-utils/include/utils/UnicodeConversion.h
rename to utils/include/utils/UnicodeConversion.h
diff --git a/extension-utils/include/utils/NetworkInterfaceInfo.h b/utils/include/utils/net/NetworkInterfaceInfo.h
similarity index 100%
rename from extension-utils/include/utils/NetworkInterfaceInfo.h
rename to utils/include/utils/net/NetworkInterfaceInfo.h
diff --git a/extension-utils/include/utils/requirements/Container.h b/utils/include/utils/requirements/Container.h
similarity index 100%
rename from extension-utils/include/utils/requirements/Container.h
rename to utils/include/utils/requirements/Container.h
diff --git a/extension-utils/include/utils/requirements/EqualityComparable.h b/utils/include/utils/requirements/EqualityComparable.h
similarity index 100%
rename from extension-utils/include/utils/requirements/EqualityComparable.h
rename to utils/include/utils/requirements/EqualityComparable.h
diff --git a/extension-utils/include/utils/requirements/LegacyForwardIterator.h b/utils/include/utils/requirements/LegacyForwardIterator.h
similarity index 100%
rename from extension-utils/include/utils/requirements/LegacyForwardIterator.h
rename to utils/include/utils/requirements/LegacyForwardIterator.h
diff --git a/extension-utils/include/utils/requirements/LegacyInputIterator.h b/utils/include/utils/requirements/LegacyInputIterator.h
similarity index 100%
rename from extension-utils/include/utils/requirements/LegacyInputIterator.h
rename to utils/include/utils/requirements/LegacyInputIterator.h
diff --git a/extension-utils/include/utils/requirements/LegacyIterator.h b/utils/include/utils/requirements/LegacyIterator.h
similarity index 100%
rename from extension-utils/include/utils/requirements/LegacyIterator.h
rename to utils/include/utils/requirements/LegacyIterator.h
diff --git a/extension-utils/include/utils/requirements/Swappable.h b/utils/include/utils/requirements/Swappable.h
similarity index 100%
rename from extension-utils/include/utils/requirements/Swappable.h
rename to utils/include/utils/requirements/Swappable.h
diff --git a/extension-utils/src/controllers/keyvalue/AutoPersistor.cpp b/utils/src/utils/AutoPersistor.cpp
similarity index 98%
rename from extension-utils/src/controllers/keyvalue/AutoPersistor.cpp
rename to utils/src/utils/AutoPersistor.cpp
index bc52cff277..6684d4b50b 100644
--- a/extension-utils/src/controllers/keyvalue/AutoPersistor.cpp
+++ b/utils/src/utils/AutoPersistor.cpp
@@ -17,7 +17,7 @@
 
 #include <cinttypes>
 
-#include "controllers/keyvalue/AutoPersistor.h"
+#include "utils/AutoPersistor.h"
 #include "core/TypedValues.h"
 
 using namespace std::literals::chrono_literals;
diff --git a/extension-utils/src/utils/ClassUtils.cpp b/utils/src/utils/ClassUtils.cpp
similarity index 100%
rename from extension-utils/src/utils/ClassUtils.cpp
rename to utils/src/utils/ClassUtils.cpp
diff --git a/extension-utils/src/utils/Cron.cpp b/utils/src/utils/Cron.cpp
similarity index 100%
rename from extension-utils/src/utils/Cron.cpp
rename to utils/src/utils/Cron.cpp
diff --git a/extension-utils/src/utils/Error.cpp b/utils/src/utils/Error.cpp
similarity index 100%
rename from extension-utils/src/utils/Error.cpp
rename to utils/src/utils/Error.cpp
diff --git a/extension-utils/src/utils/FifoExecutor.cpp b/utils/src/utils/FifoExecutor.cpp
similarity index 100%
rename from extension-utils/src/utils/FifoExecutor.cpp
rename to utils/src/utils/FifoExecutor.cpp
diff --git a/extension-utils/src/utils/FileMutex.cpp b/utils/src/utils/FileMutex.cpp
similarity index 100%
rename from extension-utils/src/utils/FileMutex.cpp
rename to utils/src/utils/FileMutex.cpp
diff --git a/extension-utils/src/utils/LineByLineInputOutputStreamCallback.cpp b/utils/src/utils/LineByLineInputOutputStreamCallback.cpp
similarity index 100%
rename from extension-utils/src/utils/LineByLineInputOutputStreamCallback.cpp
rename to utils/src/utils/LineByLineInputOutputStreamCallback.cpp
diff --git a/extension-utils/src/utils/ProcessCpuUsageTracker.cpp b/utils/src/utils/ProcessCpuUsageTracker.cpp
similarity index 100%
rename from extension-utils/src/utils/ProcessCpuUsageTracker.cpp
rename to utils/src/utils/ProcessCpuUsageTracker.cpp
diff --git a/extension-utils/src/utils/StoppableThread.cpp b/utils/src/utils/StoppableThread.cpp
similarity index 100%
rename from extension-utils/src/utils/StoppableThread.cpp
rename to utils/src/utils/StoppableThread.cpp
diff --git a/extension-utils/src/utils/SystemCpuUsageTracker.cpp b/utils/src/utils/SystemCpuUsageTracker.cpp
similarity index 100%
rename from extension-utils/src/utils/SystemCpuUsageTracker.cpp
rename to utils/src/utils/SystemCpuUsageTracker.cpp
diff --git a/libminifi/src/utils/NetworkInterfaceInfo.cpp b/utils/src/utils/net/NetworkInterfaceInfo.cpp
similarity index 99%
rename from libminifi/src/utils/NetworkInterfaceInfo.cpp
rename to utils/src/utils/net/NetworkInterfaceInfo.cpp
index f61b9ba821..bc1c1d0b1b 100644
--- a/libminifi/src/utils/NetworkInterfaceInfo.cpp
+++ b/utils/src/utils/net/NetworkInterfaceInfo.cpp
@@ -14,7 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#include "utils/NetworkInterfaceInfo.h"
+#include "utils/net/NetworkInterfaceInfo.h"
 #include "utils/net/Socket.h"
 #include "core/logging/LoggerFactory.h"
 #ifdef WIN32