elastic · edsavage · Mar 12, 2026 · Mar 13, 2026 · Mar 13, 2026 · Mar 13, 2026
diff --git a/bin/pytorch_inference/Main.cc b/bin/pytorch_inference/Main.cc
@@ -294,7 +294,7 @@ int main(int argc, char** argv) {
     // allocations rather than per allocation. But macOS is not supported for
     // production, but just as a convenience for developers. So the most
     // important thing is that the threading works as intended on Linux.
-    at::set_num_threads(threadSettings.numThreadsPerAllocation());
+    at::set_num_threads(static_cast<int>(threadSettings.numThreadsPerAllocation()));
 
     // This is not used as we don't call at::launch anywhere.
     // Setting it to 1 to ensure there is no thread pool sitting around.

diff --git a/cmake/compiler/clang.cmake b/cmake/compiler/clang.cmake
@@ -32,6 +32,9 @@ list(APPEND ML_C_FLAGS
   "-Wno-padded"
   "-Wno-poison-system-directories"
   "-Wno-sign-conversion"
+  "-Wno-missing-noreturn"
+  "-Wno-nrvo"
+  "-Wno-switch-default"
   "-Wno-unknown-warning-option"
   "-Wno-unreachable-code"
   "-Wno-used-but-marked-unused"

diff --git a/include/core/CConcurrentWrapper.h b/include/core/CConcurrentWrapper.h
@@ -58,7 +58,7 @@ class CConcurrentWrapper final : private CNonCopyable {
     //! The code inside of this lambda is guaranteed to be executed in an atomic fashion.
     template<typename F>
     void operator()(F f) const {
-        m_Queue.push([=] { f(m_Resource); });
+        m_Queue.push([this, f] { f(m_Resource); });
     }
 
     //! Debug the memory used by this component.

diff --git a/include/maths/common/CBasicStatistics.h b/include/maths/common/CBasicStatistics.h
@@ -1420,7 +1420,7 @@ struct SCentralMomentsCustomAdd {
     static inline void add(const U& x,
                            typename SCoordinate<T>::Type n,
                            CBasicStatistics::SSampleCentralMoments<T, ORDER>& moments) {
-        moments.add(x, n, 0);
+        moments.add(x, static_cast<double>(n), 0);
     }
 };
 }

diff --git a/include/maths/common/CBootstrapClusterer.h b/include/maths/common/CBootstrapClusterer.h
@@ -677,8 +677,6 @@ class CBootstrapClusterer {
         this->visit(next, graph, parities, state);
 
         double lowestCost = state.cost();
-        double bestCut = state.s_Cut;
-        std::size_t bestA = state.s_A;
         TBoolVec best = parities;
 
         while (state.s_A + 1 < V) {
@@ -725,16 +723,19 @@ class CBootstrapClusterer {
             double cutCost = state.cost();
             if (cutCost < lowestCost) {
                 lowestCost = cutCost;
-                bestCut = state.s_Cut;
-                bestA = state.s_A;
                 best = parities;
             }
         }
 
         cost = lowestCost;
         parities.swap(best);
 
-        LOG_TRACE(<< "Best cut = " << bestCut << ", |A| = " << bestA << ", |B| = " << V - bestA
+        LOG_TRACE(<< "Best cut |A| = "
+                  << static_cast<std::size_t>(
+                         std::count(parities.begin(), parities.end(), true))
+                  << ", |B| = "
+                  << V - static_cast<std::size_t>(
+                             std::count(parities.begin(), parities.end(), true))
                   << ", cost = " << cost << ", threshold = " << threshold);
 
         return cost < threshold;

diff --git a/include/model/CMetricModelFactory.h b/include/model/CMetricModelFactory.h
@@ -135,7 +135,7 @@ class MODEL_EXPORT CMetricModelFactory final : public CModelFactory {
     void features(const TFeatureVec& features) override;
 
     //! Set the modeled bucket length.
-    virtual void bucketLength(core_t::TTime bucketLength);
+    void bucketLength(core_t::TTime bucketLength);
     //@}
 
     //! Get the minimum seasonal variance scale

diff --git a/lib/api/CDataFrameAnalysisInstrumentation.cc b/lib/api/CDataFrameAnalysisInstrumentation.cc
@@ -56,14 +56,11 @@ const std::string MEMORY_TYPE_TAG{"analytics_memory_usage"};
 const std::string OUTLIER_DETECTION_STATS{"outlier_detection_stats"};
 const std::string PARAMETERS_TAG{"parameters"};
 const std::string PEAK_MEMORY_USAGE_TAG{"peak_usage_bytes"};
-const std::string PROGRESS_TAG{"progress"};
 const std::string REGRESSION_STATS_TAG{"regression_stats"};
-const std::string STEP_TAG{"step"};
 const std::string TIMESTAMP_TAG{"timestamp"};
 const std::string TIMING_ELAPSED_TIME_TAG{"elapsed_time"};
 const std::string TIMING_ITERATION_TIME_TAG{"iteration_time"};
 const std::string TIMING_STATS_TAG{"timing_stats"};
-const std::string TYPE_TAG{"type"};
 const std::string VALIDATION_FOLD_TAG{"fold"};
 const std::string VALIDATION_FOLD_VALUES_TAG{"fold_values"};
 const std::string VALIDATION_LOSS_TAG{"validation_loss"};

diff --git a/lib/api/CDetectionRulesJsonParser.cc b/lib/api/CDetectionRulesJsonParser.cc
@@ -22,7 +22,6 @@ namespace {
 const std::string ACTIONS("actions");
 const std::string ACTUAL("actual");
 const std::string APPLIES_TO("applies_to");
-const std::string CONDITION("condition");
 const std::string CONDITIONS("conditions");
 const std::string DIFF_FROM_TYPICAL("diff_from_typical");
 const std::string EXCLUDE("exclude");

diff --git a/lib/api/CFieldDataCategorizer.cc b/lib/api/CFieldDataCategorizer.cc
@@ -603,11 +603,11 @@ bool CFieldDataCategorizer::periodicPersistStateInBackground() {
     // Do NOT pass the captures by reference - they
     // MUST be copied for thread safety
     if (m_PersistenceManager->addPersistFunc([
-            this, partitionFieldValues = std::move(partitionFieldValues),
-            dataCategorizerPersistFuncs = std::move(dataCategorizerPersistFuncs),
+            this, partitionFieldValuesInner = std::move(partitionFieldValues),
+            dataCategorizerPersistFuncsInner = std::move(dataCategorizerPersistFuncs),
             categorizerAllocationFailures = m_CategorizerAllocationFailures
         ](core::CDataAdder & persister) {
-            return this->doPersistState(partitionFieldValues, dataCategorizerPersistFuncs,
+            return this->doPersistState(partitionFieldValuesInner, dataCategorizerPersistFuncsInner,
                                         categorizerAllocationFailures, persister);
         }) == false) {
         LOG_ERROR(<< "Failed to add categorizer background persistence function");

diff --git a/lib/api/CForecastRunner.cc b/lib/api/CForecastRunner.cc
@@ -442,7 +442,7 @@ bool CForecastRunner::parseAndValidateForecastRequest(const std::string& control
     if (forecastJob.s_MaxForecastModelMemory != DEFAULT_MAX_FORECAST_MODEL_MEMORY &&
         (forecastJob.s_MaxForecastModelMemory >= MAX_FORECAST_MODEL_PERSISTANCE_MEMORY ||
          forecastJob.s_MaxForecastModelMemory >=
-             static_cast<std::size_t>(jobBytesSizeLimit * 0.40))) {
+             static_cast<std::size_t>(static_cast<double>(jobBytesSizeLimit) * 0.40))) {
         errorFunction(forecastJob, ERROR_BAD_MODEL_MEMORY_LIMIT);
         return false;
     }

diff --git a/lib/api/CModelSizeStatsJsonWriter.cc b/lib/api/CModelSizeStatsJsonWriter.cc
@@ -25,7 +25,6 @@ const std::string JOB_ID{"job_id"};
 const std::string MODEL_SIZE_STATS{"model_size_stats"};
 const std::string MODEL_BYTES{"model_bytes"};
 const std::string PEAK_MODEL_BYTES{"peak_model_bytes"};
-const std::string SYSTEM_MEMORY_BYTES{"system_memory_bytes"};
 const std::string MAX_SYSTEM_MEMORY_BYTES{"max_system_memory_bytes"};
 const std::string MODEL_BYTES_EXCEEDED{"model_bytes_exceeded"};
 const std::string MODEL_BYTES_MEMORY_LIMIT{"model_bytes_memory_limit"};

diff --git a/lib/api/CSingleFieldDataCategorizer.cc b/lib/api/CSingleFieldDataCategorizer.cc
@@ -104,10 +104,11 @@ CSingleFieldDataCategorizer::makeForegroundPersistFunc() const {
     model::CDataCategorizer::TPersistFunc categorizerPersistFunc{
         m_DataCategorizer->makeForegroundPersistFunc()};
 
-    return [ categorizerPersistFunc = std::move(categorizerPersistFunc),
-             this ](core::CStatePersistInserter & inserter) {
+    return [
+        categorizerPersistFuncInner = std::move(categorizerPersistFunc), this
+    ](core::CStatePersistInserter & inserter) {
         CSingleFieldDataCategorizer::acceptPersistInserter(
-            categorizerPersistFunc, m_DataCategorizer->examplesCollector(),
+            categorizerPersistFuncInner, m_DataCategorizer->examplesCollector(),
             *m_CategoryIdMapper, inserter);
     };
 }
@@ -126,12 +127,13 @@ CSingleFieldDataCategorizer::makeBackgroundPersistFunc() const {
     // function must be able to operate in a different thread on a snapshot of
     // the data at the time it was created.
     return [
-        categorizerPersistFunc = std::move(categorizerPersistFunc),
-        examplesCollector = std::move(examplesCollector),
-        categoryIdMapperClone = std::move(categoryIdMapperClone)
+        categorizerPersistFuncInner = std::move(categorizerPersistFunc),
+        examplesCollectorInner = std::move(examplesCollector),
+        categoryIdMapperCloneInner = std::move(categoryIdMapperClone)
     ](core::CStatePersistInserter & inserter) {
         CSingleFieldDataCategorizer::acceptPersistInserter(
-            categorizerPersistFunc, examplesCollector, *categoryIdMapperClone, inserter);
+            categorizerPersistFuncInner, examplesCollectorInner,
+            *categoryIdMapperCloneInner, inserter);
     };
 }
 

diff --git a/lib/api/unittest/CAnomalyJobTest.cc b/lib/api/unittest/CAnomalyJobTest.cc
@@ -306,8 +306,8 @@ BOOST_AUTO_TEST_CASE(testOutputBucketResultsUntilGivenIncompleteInitialBucket) {
         "testfiles/testLogErrors.boost.log.ini"));
 
     // Start by creating a detector with non-trivial state
-    static const core_t::TTime BUCKET_SIZE{900};
-    static const std::string JOB_ID{"pop_sum_bytes_by_status_over_clientip"};
+    static const core_t::TTime testBucketSize{900};
+    static const std::string testJobId{"pop_sum_bytes_by_status_over_clientip"};
 
     // Open the input and output files
     std::ifstream inputStrm{inputFileName.c_str()};
@@ -321,15 +321,15 @@ BOOST_AUTO_TEST_CASE(testOutputBucketResultsUntilGivenIncompleteInitialBucket) {
     BOOST_TEST_REQUIRE(jobConfig.initFromFile(configFileName));
 
     model::CAnomalyDetectorModelConfig modelConfig =
-        model::CAnomalyDetectorModelConfig::defaultConfig(BUCKET_SIZE, model_t::E_None,
-                                                          "", 0, false);
+        model::CAnomalyDetectorModelConfig::defaultConfig(
+            testBucketSize, model_t::E_None, "", 0, false);
 
     core::CJsonOutputStreamWrapper wrappedOutputStream{outputStrm};
 
     std::string origSnapshotId;
     std::size_t numOrigDocs{0};
 
-    CTestAnomalyJob origJob{JOB_ID,
+    CTestAnomalyJob origJob{testJobId,
                             limits,
                             jobConfig,
                             modelConfig,
@@ -367,7 +367,7 @@ BOOST_AUTO_TEST_CASE(testOutputBucketResultsUntilGivenIncompleteInitialBucket) {
     std::size_t numRestoredDocs{0};
 
     CTestAnomalyJob restoredJob{
-        JOB_ID,
+        testJobId,
         limits,
         jobConfig,
         modelConfig,
@@ -879,7 +879,7 @@ BOOST_AUTO_TEST_CASE(testConfigUpdate) {
     auto generateRandomAlpha = [](int strLen) {
         std::random_device rd;
         std::mt19937 gen(rd());
-        std::uniform_int_distribution dis(0, 25);
+        std::uniform_int_distribution<int> dis(0, 25);
 
         std::string str;
         for (int i = 0; i < strLen; ++i) {

diff --git a/lib/api/unittest/CDataFrameAnalyzerTrainingTest.cc b/lib/api/unittest/CDataFrameAnalyzerTrainingTest.cc
@@ -2232,8 +2232,7 @@ BOOST_AUTO_TEST_CASE(testProgressMonitoringFromRestart) {
         TLossFunctionType::E_MseRegression, fieldNames, fieldValues, analyzer, 400);
     analyzer.handleRecord(fieldNames, {"", "", "", "", "", "", "", "$"});
 
-    TStrVec persistedStates{
-        splitOnNull(std::stringstream{std::move(persistenceStream->str())})};
+    TStrVec persistedStates{splitOnNull(std::stringstream{persistenceStream->str()})};
 
     LOG_DEBUG(<< "# states = " << persistedStates.size());
 

diff --git a/lib/api/unittest/CInferenceModelMetadataTest.cc b/lib/api/unittest/CInferenceModelMetadataTest.cc
@@ -306,7 +306,7 @@ BOOST_AUTO_TEST_CASE(testDataSummarization) {
 
     // check correct number of rows up to a rounding error
     BOOST_REQUIRE_CLOSE_ABSOLUTE(static_cast<double>(dataSummarizationNumRows),
-                                 numRows * summarizationFraction, 1.0);
+                                 static_cast<double>(numRows) * summarizationFraction, 1.0);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/lib/api/unittest/CTestAnomalyJob.cc b/lib/api/unittest/CTestAnomalyJob.cc
@@ -71,4 +71,4 @@ ml::api::CAnomalyJobConfig CTestAnomalyJob::makeJobConfig(const std::string& det
     ml::api::CAnomalyJobConfig jobConfig;
     jobConfig.analysisConfig().parseDetectorsConfig(obj);
     return jobConfig;
-}
+}
diff --git a/lib/core/CJsonStateRestoreTraverser.cc b/lib/core/CJsonStateRestoreTraverser.cc
@@ -319,7 +319,7 @@ bool CJsonStateRestoreTraverser::start() {
         }
 
         // Enhanced error logging with comprehensive debugging information
-        std::string tokenTypeName;
+        std::string tokenTypeName{"unknown"};
         switch (m_Handler.s_Type) {
         case SBoostJsonHandler::E_TokenNull:
             tokenTypeName = "null";
@@ -360,9 +360,6 @@ bool CJsonStateRestoreTraverser::start() {
         case SBoostJsonHandler::E_TokenStringPart:
             tokenTypeName = "string_part";
             break;
-        default:
-            tokenTypeName = "unknown";
-            break;
         }
 
         LOG_ERROR(<< "JSON state must be object at root. Found token type: " << tokenTypeName

diff --git a/lib/core/CStateMachine.cc b/lib/core/CStateMachine.cc
@@ -31,11 +31,6 @@ namespace {
 //const std::string MACHINE_TAG("a"); No longer used
 const core::TPersistenceTag STATE_TAG("b", "state");
 
-// CStateMachine::SMachine
-const std::string ALPHABET_TAG("a");
-const std::string STATES_TAG("b");
-const std::string TRANSITION_FUNCTION_TAG("c");
-
 std::size_t BAD_MACHINE = std::numeric_limits<std::size_t>::max();
 CFastMutex mutex;
 }

diff --git a/lib/core/unittest/CConcurrencyTest.cc b/lib/core/unittest/CConcurrencyTest.cc
@@ -30,7 +30,7 @@ namespace {
 using TIntVec = std::vector<int>;
 using TIntVecVec = std::vector<TIntVec>;
 
-double throws() {
+[[noreturn]] double throws() {
     throw std::runtime_error("don't run me");
 };
 

diff --git a/lib/maths/analytics/CBoostedTreeFactory.cc b/lib/maths/analytics/CBoostedTreeFactory.cc
@@ -1903,7 +1903,6 @@ const std::string FACTORY_TAG{"factory"};
 const std::string GAIN_PER_NODE_1ST_PERCENTILE_TAG{"gain_per_node_1st_percentile"};
 const std::string GAIN_PER_NODE_50TH_PERCENTILE_TAG{"gain_per_node_50th_percentile"};
 const std::string GAIN_PER_NODE_90TH_PERCENTILE_TAG{"gain_per_node_90th_percentile"};
-const std::string HYPERPARAMETERS_LOSSES_TAG{"hyperparameters_losses"};
 const std::string INITIALIZATION_CHECKPOINT_TAG{"initialization_checkpoint"};
 const std::string LOSS_GAP_TAG{"loss_gap"};
 const std::string NUMBER_TREES_TAG{"number_trees"};

diff --git a/lib/maths/analytics/CBoostedTreeLoss.cc b/lib/maths/analytics/CBoostedTreeLoss.cc
@@ -57,7 +57,6 @@ const std::size_t HUBER_OPTIMIZATION_ITERATIONS{15};
 const std::string NUMBER_CLASSES_TAG{"number_classes"};
 const std::string OFFSET_TAG{"offset"};
 const std::string DELTA_TAG{"delta"};
-const std::string NAME_TAG{"name"};
 
 double logOneMinusLogistic(double logOdds) {
     // For large x logistic(x) = 1 - e^(-x) + O(e^(-2x))

diff --git a/lib/maths/analytics/unittest/CDataFrameUtilsTest.cc b/lib/maths/analytics/unittest/CDataFrameUtilsTest.cc
@@ -846,7 +846,8 @@ BOOST_AUTO_TEST_CASE(testDistributionPreservingSamplingRowMasks) {
 
         BOOST_REQUIRE_EQUAL(actualCategoryCounts.size(), expectedCategoryCounts.size());
         for (std::size_t i = 0; i < expectedCategoryCounts.size(); ++i) {
-            BOOST_REQUIRE_EQUAL(actualCategoryCounts[i], expectedCategoryCounts[i]);
+            BOOST_REQUIRE_EQUAL(actualCategoryCounts[i],
+                                expectedCategoryCounts[static_cast<double>(i)]);
         }
     }
 

diff --git a/lib/maths/common/CCategoricalTools.cc b/lib/maths/common/CCategoricalTools.cc
@@ -41,7 +41,7 @@ logBinomialProbabilityFastLowerBound(std::size_t n, double p, std::size_t m, dou
 
     result = 0.0;
 
-    if (!(p >= 0.0 || p <= 1.0)) {
+    if (!(p >= 0.0 && p <= 1.0)) {
         LOG_ERROR(<< "Bad probability: " << p);
         return maths_t::E_FpFailed;
     }
@@ -588,7 +588,7 @@ CCategoricalTools::logMultinomialProbability(const TDoubleVec& probabilities,
         double ni_ = static_cast<double>(ni[i]);
         if (ni_ > 0.0) {
             double pi_ = probabilities[i];
-            if (!(pi_ >= 0.0 || pi_ <= 1.0)) {
+            if (!(pi_ >= 0.0 && pi_ <= 1.0)) {
                 LOG_ERROR(<< "Bad probability: " << pi_);
                 return maths_t::E_FpFailed;
             }

diff --git a/lib/maths/common/CGammaRateConjugate.cc b/lib/maths/common/CGammaRateConjugate.cc
@@ -724,7 +724,6 @@ const core::TPersistenceTag DECAY_RATE_TAG("j", "decay_rate");
 const std::string MEAN_TAG("mean");
 const std::string STANDARD_DEVIATION_TAG("standard_deviation");
 const std::string EMPTY_STRING;
-const std::string UNKNOWN_VALUE_STRING("<unknown>");
 }
 
 CGammaRateConjugate::CGammaRateConjugate(maths_t::EDataType dataType,

diff --git a/lib/maths/common/CLogNormalMeanPrecConjugate.cc b/lib/maths/common/CLogNormalMeanPrecConjugate.cc
@@ -630,7 +630,6 @@ const core::TPersistenceTag NUMBER_SAMPLES_TAG("f", "number_samples");
 const core::TPersistenceTag DECAY_RATE_TAG("i", "decay_rate");
 const std::string MEAN_TAG("mean");
 const std::string STANDARD_DEVIATION_TAG("standard_deviation");
-const std::string EMPTY_STRING;
 }
 
 CLogNormalMeanPrecConjugate::CLogNormalMeanPrecConjugate(maths_t::EDataType dataType,

diff --git a/lib/maths/common/CModel.cc b/lib/maths/common/CModel.cc
@@ -26,7 +26,6 @@ namespace maths {
 namespace common {
 namespace {
 
-const std::string EMPTY_STRING;
 const double EFFECTIVE_COUNT[]{1.0,  0.8,  0.7,  0.65, 0.6,
                                0.57, 0.54, 0.52, 0.51};
 

diff --git a/lib/maths/common/CMultimodalPrior.cc b/lib/maths/common/CMultimodalPrior.cc
@@ -131,8 +131,6 @@ const core::TPersistenceTag SEED_PRIOR_TAG("b", "seed_prior");
 const core::TPersistenceTag MODE_TAG("c", "mode");
 const core::TPersistenceTag NUMBER_SAMPLES_TAG("d", "number_samples");
 const core::TPersistenceTag DECAY_RATE_TAG("g", "decay_rate");
-
-const std::string EMPTY_STRING;
 }
 
 //////// CMultimodalPrior Implementation ////////

diff --git a/lib/maths/common/CMultinomialConjugate.cc b/lib/maths/common/CMultinomialConjugate.cc
@@ -248,8 +248,6 @@ const core::TPersistenceTag CONCENTRATION_TAG("c", "concentration");
 const core::TPersistenceTag TOTAL_CONCENTRATION_TAG("d", "total_concentration");
 const core::TPersistenceTag NUMBER_SAMPLES_TAG("e", "number_samples");
 const core::TPersistenceTag DECAY_RATE_TAG("h", "decay_rate");
-
-const std::string EMPTY_STRING;
 }
 
 CMultinomialConjugate::CMultinomialConjugate()

diff --git a/lib/maths/common/CMultivariateConstantPrior.cc b/lib/maths/common/CMultivariateConstantPrior.cc
@@ -56,8 +56,6 @@ void setConstant(std::size_t dimension, TDouble10Vec value, TOptionalDouble10Vec
 
 // We use short field names to reduce the state size
 const std::string CONSTANT_TAG("a");
-
-const std::string EMPTY_STRING;
 }
 
 CMultivariateConstantPrior::CMultivariateConstantPrior(std::size_t dimension,

diff --git a/lib/maths/common/CNaturalBreaksClassifier.cc b/lib/maths/common/CNaturalBreaksClassifier.cc
@@ -40,7 +40,6 @@ const core::TPersistenceTag SPACE_TAG("a", "space");
 const core::TPersistenceTag CATEGORY_TAG("b", "category");
 const core::TPersistenceTag POINTS_TAG("c", "points");
 const core::TPersistenceTag DECAY_RATE_TAG("d", "decay_rate");
-const std::string EMPTY_STRING;
 const double ALMOST_ONE = 0.99999;
 }
 

diff --git a/lib/maths/common/CNormalMeanPrecConjugate.cc b/lib/maths/common/CNormalMeanPrecConjugate.cc
@@ -450,7 +450,6 @@ const core::TPersistenceTag NUMBER_SAMPLES_TAG("e", "number_samples");
 const core::TPersistenceTag DECAY_RATE_TAG("h", "decay_rate");
 const std::string MEAN_TAG("mean");
 const std::string STANDARD_DEVIATION_TAG("standard_deviation");
-const std::string EMPTY_STRING;
 }
 
 CNormalMeanPrecConjugate::CNormalMeanPrecConjugate(maths_t::EDataType dataType,

diff --git a/lib/maths/common/COneOfNPrior.cc b/lib/maths/common/COneOfNPrior.cc
@@ -77,8 +77,6 @@ const std::string DECAY_RATE_OLD_TAG("e");
 const core::TPersistenceTag WEIGHT_TAG("a", "weight");
 const core::TPersistenceTag PRIOR_TAG("b", "prior");
 
-const std::string EMPTY_STRING;
-
 //! Persist state for a models by passing information to \p inserter.
 void modelAcceptPersistInserter(const CModelWeight& weight,
                                 const CPrior& prior,