Convert `IngestStats` & internal objects to records (#96217)

Co-authored-by: Joe Gallo <joe.gallo@elastic.co>

modules/ingest-common/src/internalClusterTest/java/org/elasticsearch/ingest/common/IngestRestartIT.java

@@ -98,9 +98,9 @@ public class IngestRestartIT extends ESIntegTestCase {
         NodesStatsResponse r = client().admin().cluster().prepareNodesStats(internalCluster().getNodeNames()).setIngest(true).get();
         int nodeCount = r.getNodes().size();
         for (int k = 0; k < nodeCount; k++) {
-            List<IngestStats.ProcessorStat> stats = r.getNodes().get(k).getIngestStats().getProcessorStats().get(pipelineId);
+            List<IngestStats.ProcessorStat> stats = r.getNodes().get(k).getIngestStats().processorStats().get(pipelineId);
             for (IngestStats.ProcessorStat st : stats) {
-                assertThat(st.getStats().getIngestCurrent(), greaterThanOrEqualTo(0L));
+                assertThat(st.stats().ingestCurrent(), greaterThanOrEqualTo(0L));
             }
         }
     }

server/src/internalClusterTest/java/org/elasticsearch/ingest/IngestStatsNamesAndTypesIT.java

@@ -109,35 +109,35 @@ public class IngestStatsNamesAndTypesIT extends ESIntegTestCase {
             assertThat(nodesStatsResponse.getNodes().size(), equalTo(1));
 
             NodeStats stats = nodesStatsResponse.getNodes().get(0);
-            assertThat(stats.getIngestStats().getTotalStats().getIngestCount(), equalTo(1L));
-            assertThat(stats.getIngestStats().getPipelineStats().size(), equalTo(1));
+            assertThat(stats.getIngestStats().totalStats().ingestCount(), equalTo(1L));
+            assertThat(stats.getIngestStats().pipelineStats().size(), equalTo(1));
 
-            IngestStats.PipelineStat pipelineStat = stats.getIngestStats().getPipelineStats().get(0);
-            assertThat(pipelineStat.getPipelineId(), equalTo("pipeline1"));
-            assertThat(pipelineStat.getStats().getIngestCount(), equalTo(1L));
+            IngestStats.PipelineStat pipelineStat = stats.getIngestStats().pipelineStats().get(0);
+            assertThat(pipelineStat.pipelineId(), equalTo("pipeline1"));
+            assertThat(pipelineStat.stats().ingestCount(), equalTo(1L));
 
-            List<IngestStats.ProcessorStat> processorStats = stats.getIngestStats().getProcessorStats().get("pipeline1");
+            List<IngestStats.ProcessorStat> processorStats = stats.getIngestStats().processorStats().get("pipeline1");
             assertThat(processorStats.size(), equalTo(4));
 
             IngestStats.ProcessorStat setA = processorStats.get(0);
-            assertThat(setA.getName(), equalTo("set:set-a"));
-            assertThat(setA.getType(), equalTo("set"));
-            assertThat(setA.getStats().getIngestCount(), equalTo(1L));
+            assertThat(setA.name(), equalTo("set:set-a"));
+            assertThat(setA.type(), equalTo("set"));
+            assertThat(setA.stats().ingestCount(), equalTo(1L));
 
             IngestStats.ProcessorStat setB = processorStats.get(1);
-            assertThat(setB.getName(), equalTo("set:set-b"));
-            assertThat(setB.getType(), equalTo("set"));
-            assertThat(setB.getStats().getIngestCount(), equalTo(0L)); // see false_script above
+            assertThat(setB.name(), equalTo("set:set-b"));
+            assertThat(setB.type(), equalTo("set"));
+            assertThat(setB.stats().ingestCount(), equalTo(0L)); // see false_script above
 
             IngestStats.ProcessorStat setC = processorStats.get(2);
-            assertThat(setC.getName(), equalTo("set:set-c"));
-            assertThat(setC.getType(), equalTo("set"));
-            assertThat(setC.getStats().getIngestCount(), equalTo(1L));
+            assertThat(setC.name(), equalTo("set:set-c"));
+            assertThat(setC.type(), equalTo("set"));
+            assertThat(setC.stats().ingestCount(), equalTo(1L));
 
             IngestStats.ProcessorStat setD = processorStats.get(3);
-            assertThat(setD.getName(), equalTo("set:set-d"));
-            assertThat(setD.getType(), equalTo("set"));
-            assertThat(setD.getStats().getIngestCount(), equalTo(1L));
+            assertThat(setD.name(), equalTo("set:set-d"));
+            assertThat(setD.type(), equalTo("set"));
+            assertThat(setD.stats().ingestCount(), equalTo(1L));
         }
 
         {

server/src/main/java/org/elasticsearch/action/admin/cluster/stats/ClusterStatsNodes.java

@@ -715,23 +715,23 @@ public class ClusterStatsNodes implements ToXContentFragment {
                 if (nodeStat.getIngestStats() != null) {
                     for (Map.Entry<String, List<org.elasticsearch.ingest.IngestStats.ProcessorStat>> processorStats : nodeStat
                         .getIngestStats()
-                        .getProcessorStats()
+                        .processorStats()
                         .entrySet()) {
                         pipelineIds.add(processorStats.getKey());
                         for (org.elasticsearch.ingest.IngestStats.ProcessorStat stat : processorStats.getValue()) {
-                            stats.compute(stat.getType(), (k, v) -> {
-                                org.elasticsearch.ingest.IngestStats.Stats nodeIngestStats = stat.getStats();
+                            stats.compute(stat.type(), (k, v) -> {
+                                org.elasticsearch.ingest.IngestStats.Stats nodeIngestStats = stat.stats();
                                 if (v == null) {
                                     return new long[] {
-                                        nodeIngestStats.getIngestCount(),
-                                        nodeIngestStats.getIngestFailedCount(),
-                                        nodeIngestStats.getIngestCurrent(),
-                                        nodeIngestStats.getIngestTimeInMillis() };
+                                        nodeIngestStats.ingestCount(),
+                                        nodeIngestStats.ingestFailedCount(),
+                                        nodeIngestStats.ingestCurrent(),
+                                        nodeIngestStats.ingestTimeInMillis() };
                                 } else {
-                                    v[0] += nodeIngestStats.getIngestCount();
-                                    v[1] += nodeIngestStats.getIngestFailedCount();
-                                    v[2] += nodeIngestStats.getIngestCurrent();
-                                    v[3] += nodeIngestStats.getIngestTimeInMillis();
+                                    v[0] += nodeIngestStats.ingestCount();
+                                    v[1] += nodeIngestStats.ingestFailedCount();
+                                    v[2] += nodeIngestStats.ingestCurrent();
+                                    v[3] += nodeIngestStats.ingestTimeInMillis();
                                     return v;
                                 }
                             });

server/src/main/java/org/elasticsearch/ingest/IngestStats.java

@@ -15,6 +15,7 @@ import org.elasticsearch.common.io.stream.Writeable;
 import org.elasticsearch.common.util.Maps;
 import org.elasticsearch.common.xcontent.ChunkedToXContent;
 import org.elasticsearch.core.TimeValue;
+import org.elasticsearch.core.Tuple;
 import org.elasticsearch.xcontent.ToXContent;
 import org.elasticsearch.xcontent.ToXContentFragment;
 import org.elasticsearch.xcontent.XContentBuilder;
@@ -26,23 +27,21 @@ import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
-import java.util.Objects;
 import java.util.concurrent.TimeUnit;
 
-public class IngestStats implements Writeable, ChunkedToXContent {
-    private final Stats totalStats;
-    private final List<PipelineStat> pipelineStats;
-    private final Map<String, List<ProcessorStat>> processorStats;
+public record IngestStats(Stats totalStats, List<PipelineStat> pipelineStats, Map<String, List<ProcessorStat>> processorStats)
+    implements
+        Writeable,
+        ChunkedToXContent {
 
     /**
-     * @param totalStats - The total stats for Ingest. This is the logically the sum of all pipeline stats,
+     * @param totalStats - The total stats for Ingest. This is logically the sum of all pipeline stats,
      *                   and pipeline stats are logically the sum of the processor stats.
      * @param pipelineStats - The stats for a given ingest pipeline.
      * @param processorStats - The per-processor stats for a given pipeline. A map keyed by the pipeline identifier.
      */
-    public IngestStats(Stats totalStats, List<PipelineStat> pipelineStats, Map<String, List<ProcessorStat>> processorStats) {
-        this.totalStats = totalStats;
-        this.pipelineStats = pipelineStats.stream().sorted((p1, p2) -> {
+    public IngestStats {
+        pipelineStats = pipelineStats.stream().sorted((p1, p2) -> {
             final IngestStats.Stats p2Stats = p2.stats;
             final IngestStats.Stats p1Stats = p1.stats;
             final int ingestTimeCompare = Long.compare(p2Stats.ingestTimeInMillis, p1Stats.ingestTimeInMillis);
@@ -52,22 +51,27 @@ public class IngestStats implements Writeable, ChunkedToXContent {
                 return ingestTimeCompare;
             }
         }).toList();
-        this.processorStats = processorStats;
-
     }
 
     /**
      * Read from a stream.
      */
     public IngestStats(StreamInput in) throws IOException {
-        this.totalStats = new Stats(in);
-        int size = in.readVInt();
-        this.pipelineStats = new ArrayList<>(size);
-        this.processorStats = Maps.newMapWithExpectedSize(size);
+        this(new Stats(in), readPipelineStats(in));
+    }
+
+    IngestStats(Stats stats, Tuple<List<PipelineStat>, Map<String, List<ProcessorStat>>> tuple) {
+        this(stats, tuple.v1(), tuple.v2());
+    }
+
+    private static Tuple<List<PipelineStat>, Map<String, List<ProcessorStat>>> readPipelineStats(StreamInput in) throws IOException {
+        var size = in.readVInt();
+        var pipelineStats = new ArrayList<PipelineStat>(size);
+        var processorStats = Maps.<String, List<ProcessorStat>>newMapWithExpectedSize(size);
         for (int i = 0; i < size; i++) {
             String pipelineId = in.readString();
             Stats pipelineStat = new Stats(in);
-            this.pipelineStats.add(new PipelineStat(pipelineId, pipelineStat));
+            pipelineStats.add(new PipelineStat(pipelineId, pipelineStat));
             int processorsSize = in.readVInt();
             List<ProcessorStat> processorStatsPerPipeline = new ArrayList<>(processorsSize);
             for (int j = 0; j < processorsSize; j++) {
@@ -76,8 +80,10 @@ public class IngestStats implements Writeable, ChunkedToXContent {
                 Stats processorStat = new Stats(in);
                 processorStatsPerPipeline.add(new ProcessorStat(processorName, processorType, processorStat));
             }
-            this.processorStats.put(pipelineId, processorStatsPerPipeline);
+            processorStats.put(pipelineId, Collections.unmodifiableList(processorStatsPerPipeline));
         }
+
+        return Tuple.tuple(Collections.unmodifiableList(pipelineStats), Collections.unmodifiableMap(processorStats));
     }
 
     @Override
@@ -85,16 +91,16 @@ public class IngestStats implements Writeable, ChunkedToXContent {
         totalStats.writeTo(out);
         out.writeVInt(pipelineStats.size());
         for (PipelineStat pipelineStat : pipelineStats) {
-            out.writeString(pipelineStat.getPipelineId());
-            pipelineStat.getStats().writeTo(out);
-            List<ProcessorStat> processorStatsForPipeline = processorStats.get(pipelineStat.getPipelineId());
+            out.writeString(pipelineStat.pipelineId());
+            pipelineStat.stats().writeTo(out);
+            List<ProcessorStat> processorStatsForPipeline = processorStats.get(pipelineStat.pipelineId());
             if (processorStatsForPipeline == null) {
                 out.writeVInt(0);
             } else {
                 out.writeCollection(processorStatsForPipeline, (o, processorStat) -> {
-                    o.writeString(processorStat.getName());
-                    o.writeString(processorStat.getType());
-                    processorStat.getStats().writeTo(o);
+                    o.writeString(processorStat.name());
+                    o.writeString(processorStat.type());
+                    processorStat.stats().writeTo(o);
                 });
             }
         }
@@ -118,20 +124,20 @@ public class IngestStats implements Writeable, ChunkedToXContent {
                 pipelineStat -> Iterators.concat(
 
                     Iterators.single((builder, params) -> {
-                        builder.startObject(pipelineStat.getPipelineId());
-                        pipelineStat.getStats().toXContent(builder, params);
+                        builder.startObject(pipelineStat.pipelineId());
+                        pipelineStat.stats().toXContent(builder, params);
                         builder.startArray("processors");
                         return builder;
                     }),
 
                     Iterators.flatMap(
-                        processorStats.getOrDefault(pipelineStat.getPipelineId(), List.of()).iterator(),
+                        processorStats.getOrDefault(pipelineStat.pipelineId(), List.of()).iterator(),
                         processorStat -> Iterators.<ToXContent>single((builder, params) -> {
                             builder.startObject();
-                            builder.startObject(processorStat.getName());
-                            builder.field("type", processorStat.getType());
+                            builder.startObject(processorStat.name());
+                            builder.field("type", processorStat.type());
                             builder.startObject("stats");
-                            processorStat.getStats().toXContent(builder, params);
+                            processorStat.stats().toXContent(builder, params);
                             builder.endObject();
                             builder.endObject();
                             builder.endObject();
@@ -147,55 +153,16 @@ public class IngestStats implements Writeable, ChunkedToXContent {
         );
     }
 
-    public Stats getTotalStats() {
-        return totalStats;
-    }
-
-    public List<PipelineStat> getPipelineStats() {
-        return pipelineStats;
-    }
-
-    public Map<String, List<ProcessorStat>> getProcessorStats() {
-        return processorStats;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-        IngestStats that = (IngestStats) o;
-        return Objects.equals(totalStats, that.totalStats)
-            && Objects.equals(pipelineStats, that.pipelineStats)
-            && Objects.equals(processorStats, that.processorStats);
-    }
-
-    @Override
-    public int hashCode() {
-        return Objects.hash(totalStats, pipelineStats, processorStats);
-    }
-
-    public static class Stats implements Writeable, ToXContentFragment {
-
-        private final long ingestCount;
-        private final long ingestTimeInMillis;
-        private final long ingestCurrent;
-        private final long ingestFailedCount;
-
-        public Stats(long ingestCount, long ingestTimeInMillis, long ingestCurrent, long ingestFailedCount) {
-            this.ingestCount = ingestCount;
-            this.ingestTimeInMillis = ingestTimeInMillis;
-            this.ingestCurrent = ingestCurrent;
-            this.ingestFailedCount = ingestFailedCount;
-        }
+    public record Stats(long ingestCount, long ingestTimeInMillis, long ingestCurrent, long ingestFailedCount)
+        implements
+            Writeable,
+            ToXContentFragment {
 
         /**
          * Read from a stream.
          */
         public Stats(StreamInput in) throws IOException {
-            ingestCount = in.readVLong();
-            ingestTimeInMillis = in.readVLong();
-            ingestCurrent = in.readVLong();
-            ingestFailedCount = in.readVLong();
+            this(in.readVLong(), in.readVLong(), in.readVLong(), in.readVLong());
         }
 
         @Override
@@ -206,34 +173,6 @@ public class IngestStats implements Writeable, ChunkedToXContent {
             out.writeVLong(ingestFailedCount);
         }
 
-        /**
-         * @return The total number of executed ingest preprocessing operations.
-         */
-        public long getIngestCount() {
-            return ingestCount;
-        }
-
-        /**
-         * @return The total time spent of ingest preprocessing in millis.
-         */
-        public long getIngestTimeInMillis() {
-            return ingestTimeInMillis;
-        }
-
-        /**
-         * @return The total number of ingest preprocessing operations currently executing.
-         */
-        public long getIngestCurrent() {
-            return ingestCurrent;
-        }
-
-        /**
-         * @return The total number of ingest preprocessing operations that have failed.
-         */
-        public long getIngestFailedCount() {
-            return ingestFailedCount;
-        }
-
         @Override
         public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
             builder.field("count", ingestCount);
@@ -242,33 +181,18 @@ public class IngestStats implements Writeable, ChunkedToXContent {
             builder.field("failed", ingestFailedCount);
             return builder;
         }
-
-        @Override
-        public boolean equals(Object o) {
-            if (this == o) return true;
-            if (o == null || getClass() != o.getClass()) return false;
-            IngestStats.Stats that = (IngestStats.Stats) o;
-            return Objects.equals(ingestCount, that.ingestCount)
-                && Objects.equals(ingestTimeInMillis, that.ingestTimeInMillis)
-                && Objects.equals(ingestFailedCount, that.ingestFailedCount)
-                && Objects.equals(ingestCurrent, that.ingestCurrent);
-        }
-
-        @Override
-        public int hashCode() {
-            return Objects.hash(ingestCount, ingestTimeInMillis, ingestFailedCount, ingestCurrent);
-        }
     }
 
     /**
      * Easy conversion from scoped {@link IngestMetric} objects to a serializable Stats objects
      */
     static class Builder {
-        private Stats totalStats;
-        private List<PipelineStat> pipelineStats = new ArrayList<>();
-        private Map<String, List<ProcessorStat>> processorStats = new HashMap<>();
+        private Stats totalStats = null;
+        private final List<PipelineStat> pipelineStats = new ArrayList<>();
+        private final Map<String, List<ProcessorStat>> processorStats = new HashMap<>();
 
         Builder addTotalMetrics(IngestMetric totalMetric) {
+            assert totalStats == null;
             this.totalStats = totalMetric.createStats();
             return this;
         }
@@ -292,74 +216,10 @@ public class IngestStats implements Writeable, ChunkedToXContent {
     /**
      * Container for pipeline stats.
      */
-    public static class PipelineStat {
-        private final String pipelineId;
-        private final Stats stats;
-
-        public PipelineStat(String pipelineId, Stats stats) {
-            this.pipelineId = pipelineId;
-            this.stats = stats;
-        }
-
-        public String getPipelineId() {
-            return pipelineId;
-        }
-
-        public Stats getStats() {
-            return stats;
-        }
-
-        @Override
-        public boolean equals(Object o) {
-            if (this == o) return true;
-            if (o == null || getClass() != o.getClass()) return false;
-            IngestStats.PipelineStat that = (IngestStats.PipelineStat) o;
-            return Objects.equals(pipelineId, that.pipelineId) && Objects.equals(stats, that.stats);
-        }
-
-        @Override
-        public int hashCode() {
-            return Objects.hash(pipelineId, stats);
-        }
-    }
+    public record PipelineStat(String pipelineId, Stats stats) {}
 
     /**
      * Container for processor stats.
      */
-    public static class ProcessorStat {
-        private final String name;
-        private final String type;
-        private final Stats stats;
-
-        public ProcessorStat(String name, String type, Stats stats) {
-            this.name = name;
-            this.type = type;
-            this.stats = stats;
-        }
-
-        public String getName() {
-            return name;
-        }
-
-        public String getType() {
-            return type;
-        }
-
-        public Stats getStats() {
-            return stats;
-        }
-
-        @Override
-        public boolean equals(Object o) {
-            if (this == o) return true;
-            if (o == null || getClass() != o.getClass()) return false;
-            IngestStats.ProcessorStat that = (IngestStats.ProcessorStat) o;
-            return Objects.equals(name, that.name) && Objects.equals(type, that.type) && Objects.equals(stats, that.stats);
-        }
-
-        @Override
-        public int hashCode() {
-            return Objects.hash(name, type, stats);
-        }
-    }
+    public record ProcessorStat(String name, String type, Stats stats) {}
 }

server/src/test/java/org/elasticsearch/action/admin/cluster/node/stats/NodeStatsTests.java

@@ -467,40 +467,31 @@ public class NodeStatsTests extends ESTestCase {
                 if (ingestStats == null) {
                     assertNull(deserializedIngestStats);
                 } else {
-                    IngestStats.Stats totalStats = ingestStats.getTotalStats();
-                    assertEquals(totalStats.getIngestCount(), deserializedIngestStats.getTotalStats().getIngestCount());
-                    assertEquals(totalStats.getIngestCurrent(), deserializedIngestStats.getTotalStats().getIngestCurrent());
-                    assertEquals(totalStats.getIngestFailedCount(), deserializedIngestStats.getTotalStats().getIngestFailedCount());
-                    assertEquals(totalStats.getIngestTimeInMillis(), deserializedIngestStats.getTotalStats().getIngestTimeInMillis());
-                    assertEquals(ingestStats.getPipelineStats().size(), deserializedIngestStats.getPipelineStats().size());
-                    for (IngestStats.PipelineStat pipelineStat : ingestStats.getPipelineStats()) {
-                        String pipelineId = pipelineStat.getPipelineId();
-                        IngestStats.Stats deserializedPipelineStats = getPipelineStats(
-                            deserializedIngestStats.getPipelineStats(),
-                            pipelineId
-                        );
-                        assertEquals(pipelineStat.getStats().getIngestFailedCount(), deserializedPipelineStats.getIngestFailedCount());
-                        assertEquals(pipelineStat.getStats().getIngestTimeInMillis(), deserializedPipelineStats.getIngestTimeInMillis());
-                        assertEquals(pipelineStat.getStats().getIngestCurrent(), deserializedPipelineStats.getIngestCurrent());
-                        assertEquals(pipelineStat.getStats().getIngestCount(), deserializedPipelineStats.getIngestCount());
-                        List<IngestStats.ProcessorStat> processorStats = ingestStats.getProcessorStats().get(pipelineId);
+                    IngestStats.Stats totalStats = ingestStats.totalStats();
+                    assertEquals(totalStats.ingestCount(), deserializedIngestStats.totalStats().ingestCount());
+                    assertEquals(totalStats.ingestCurrent(), deserializedIngestStats.totalStats().ingestCurrent());
+                    assertEquals(totalStats.ingestFailedCount(), deserializedIngestStats.totalStats().ingestFailedCount());
+                    assertEquals(totalStats.ingestTimeInMillis(), deserializedIngestStats.totalStats().ingestTimeInMillis());
+                    assertEquals(ingestStats.pipelineStats().size(), deserializedIngestStats.pipelineStats().size());
+                    for (IngestStats.PipelineStat pipelineStat : ingestStats.pipelineStats()) {
+                        String pipelineId = pipelineStat.pipelineId();
+                        IngestStats.Stats deserializedPipelineStats = getPipelineStats(deserializedIngestStats.pipelineStats(), pipelineId);
+                        assertEquals(pipelineStat.stats().ingestFailedCount(), deserializedPipelineStats.ingestFailedCount());
+                        assertEquals(pipelineStat.stats().ingestTimeInMillis(), deserializedPipelineStats.ingestTimeInMillis());
+                        assertEquals(pipelineStat.stats().ingestCurrent(), deserializedPipelineStats.ingestCurrent());
+                        assertEquals(pipelineStat.stats().ingestCount(), deserializedPipelineStats.ingestCount());
+                        List<IngestStats.ProcessorStat> processorStats = ingestStats.processorStats().get(pipelineId);
                         // intentionally validating identical order
-                        Iterator<IngestStats.ProcessorStat> it = deserializedIngestStats.getProcessorStats().get(pipelineId).iterator();
+                        Iterator<IngestStats.ProcessorStat> it = deserializedIngestStats.processorStats().get(pipelineId).iterator();
                         for (IngestStats.ProcessorStat processorStat : processorStats) {
                             IngestStats.ProcessorStat deserializedProcessorStat = it.next();
+                            assertEquals(processorStat.stats().ingestFailedCount(), deserializedProcessorStat.stats().ingestFailedCount());
                             assertEquals(
-                                processorStat.getStats().getIngestFailedCount(),
-                                deserializedProcessorStat.getStats().getIngestFailedCount()
-                            );
-                            assertEquals(
-                                processorStat.getStats().getIngestTimeInMillis(),
-                                deserializedProcessorStat.getStats().getIngestTimeInMillis()
+                                processorStat.stats().ingestTimeInMillis(),
+                                deserializedProcessorStat.stats().ingestTimeInMillis()
                             );
-                            assertEquals(
-                                processorStat.getStats().getIngestCurrent(),
-                                deserializedProcessorStat.getStats().getIngestCurrent()
-                            );
-                            assertEquals(processorStat.getStats().getIngestCount(), deserializedProcessorStat.getStats().getIngestCount());
+                            assertEquals(processorStat.stats().ingestCurrent(), deserializedProcessorStat.stats().ingestCurrent());
+                            assertEquals(processorStat.stats().ingestCount(), deserializedProcessorStat.stats().ingestCount());
                         }
                         assertFalse(it.hasNext());
                     }
@@ -580,11 +571,9 @@ public class NodeStatsTests extends ESTestCase {
     private static int expectedChunks(@Nullable IngestStats ingestStats) {
         return ingestStats == null
             ? 0
-            : 2 + ingestStats.getPipelineStats()
+            : 2 + ingestStats.pipelineStats()
                 .stream()
-                .mapToInt(
-                    pipelineStats -> 2 + ingestStats.getProcessorStats().getOrDefault(pipelineStats.getPipelineId(), List.of()).size()
-                )
+                .mapToInt(pipelineStats -> 2 + ingestStats.processorStats().getOrDefault(pipelineStats.pipelineId(), List.of()).size())
                 .sum();
     }
 
@@ -1130,6 +1119,6 @@ public class NodeStatsTests extends ESTestCase {
     }
 
     private IngestStats.Stats getPipelineStats(List<IngestStats.PipelineStat> pipelineStats, String id) {
-        return pipelineStats.stream().filter(p1 -> p1.getPipelineId().equals(id)).findFirst().map(p2 -> p2.getStats()).orElse(null);
+        return pipelineStats.stream().filter(p1 -> p1.pipelineId().equals(id)).findFirst().map(p2 -> p2.stats()).orElse(null);
     }
 }

server/src/test/java/org/elasticsearch/action/admin/cluster/stats/ClusterStatsNodesTests.java

@@ -64,20 +64,20 @@ public class ClusterStatsNodesTests extends ESTestCase {
     public void testIngestStats() throws Exception {
         NodeStats nodeStats = randomValueOtherThanMany(n -> n.getIngestStats() == null, NodeStatsTests::createNodeStats);
         SortedMap<String, long[]> processorStats = new TreeMap<>();
-        nodeStats.getIngestStats().getProcessorStats().values().forEach(stats -> {
+        nodeStats.getIngestStats().processorStats().values().forEach(stats -> {
             stats.forEach(stat -> {
-                processorStats.compute(stat.getType(), (key, value) -> {
+                processorStats.compute(stat.type(), (key, value) -> {
                     if (value == null) {
                         return new long[] {
-                            stat.getStats().getIngestCount(),
-                            stat.getStats().getIngestFailedCount(),
-                            stat.getStats().getIngestCurrent(),
-                            stat.getStats().getIngestTimeInMillis() };
+                            stat.stats().ingestCount(),
+                            stat.stats().ingestFailedCount(),
+                            stat.stats().ingestCurrent(),
+                            stat.stats().ingestTimeInMillis() };
                     } else {
-                        value[0] += stat.getStats().getIngestCount();
-                        value[1] += stat.getStats().getIngestFailedCount();
-                        value[2] += stat.getStats().getIngestCurrent();
-                        value[3] += stat.getStats().getIngestTimeInMillis();
+                        value[0] += stat.stats().ingestCount();
+                        value[1] += stat.stats().ingestFailedCount();
+                        value[2] += stat.stats().ingestCurrent();
+                        value[3] += stat.stats().ingestTimeInMillis();
                         return value;
                     }
                 });
@@ -85,7 +85,7 @@ public class ClusterStatsNodesTests extends ESTestCase {
         });
 
         ClusterStatsNodes.IngestStats stats = new ClusterStatsNodes.IngestStats(List.of(nodeStats));
-        assertThat(stats.pipelineCount, equalTo(nodeStats.getIngestStats().getProcessorStats().size()));
+        assertThat(stats.pipelineCount, equalTo(nodeStats.getIngestStats().processorStats().size()));
         StringBuilder processorStatsString = new StringBuilder("{");
         Iterator<Map.Entry<String, long[]>> iter = processorStats.entrySet().iterator();
         while (iter.hasNext()) {

server/src/test/java/org/elasticsearch/ingest/CompoundProcessorTests.java

@@ -634,9 +634,9 @@ public class CompoundProcessorTests extends ESTestCase {
 
     private void assertStats(int processor, CompoundProcessor compoundProcessor, long current, long count, long failed, long time) {
         IngestStats.Stats stats = compoundProcessor.getProcessorsWithMetrics().get(processor).v2().createStats();
-        assertThat(stats.getIngestCount(), equalTo(count));
-        assertThat(stats.getIngestCurrent(), equalTo(current));
-        assertThat(stats.getIngestFailedCount(), equalTo(failed));
-        assertThat(stats.getIngestTimeInMillis(), equalTo(time));
+        assertThat(stats.ingestCount(), equalTo(count));
+        assertThat(stats.ingestCurrent(), equalTo(current));
+        assertThat(stats.ingestFailedCount(), equalTo(failed));
+        assertThat(stats.ingestTimeInMillis(), equalTo(time));
     }
 }

server/src/test/java/org/elasticsearch/ingest/ConditionalProcessorTests.java

@@ -279,10 +279,10 @@ public class ConditionalProcessorTests extends ESTestCase {
 
     private static void assertStats(ConditionalProcessor conditionalProcessor, long count, long failed, long time) {
         IngestStats.Stats stats = conditionalProcessor.getMetric().createStats();
-        assertThat(stats.getIngestCount(), equalTo(count));
-        assertThat(stats.getIngestCurrent(), equalTo(0L));
-        assertThat(stats.getIngestFailedCount(), equalTo(failed));
-        assertThat(stats.getIngestTimeInMillis(), greaterThanOrEqualTo(time));
+        assertThat(stats.ingestCount(), equalTo(count));
+        assertThat(stats.ingestCurrent(), equalTo(0L));
+        assertThat(stats.ingestFailedCount(), equalTo(failed));
+        assertThat(stats.ingestTimeInMillis(), greaterThanOrEqualTo(time));
     }
 
     private static void execProcessor(Processor processor, IngestDocument doc, BiConsumer<IngestDocument, Exception> handler) {

server/src/test/java/org/elasticsearch/ingest/IngestMetricTests.java

@@ -17,9 +17,9 @@ public class IngestMetricTests extends ESTestCase {
     public void testIngestCurrent() {
         IngestMetric metric = new IngestMetric();
         metric.preIngest();
-        assertThat(1L, equalTo(metric.createStats().getIngestCurrent()));
+        assertThat(1L, equalTo(metric.createStats().ingestCurrent()));
         metric.postIngest(0);
-        assertThat(0L, equalTo(metric.createStats().getIngestCurrent()));
+        assertThat(0L, equalTo(metric.createStats().ingestCurrent()));
     }
 
     public void testIngestTimeInNanos() {
@@ -28,22 +28,22 @@ public class IngestMetricTests extends ESTestCase {
         metric.postIngest(500000L);
         metric.preIngest();
         metric.postIngest(500000L);
-        assertThat(1L, equalTo(metric.createStats().getIngestTimeInMillis()));
+        assertThat(1L, equalTo(metric.createStats().ingestTimeInMillis()));
     }
 
     public void testPostIngestDoubleDecrement() {
         IngestMetric metric = new IngestMetric();
 
         metric.preIngest();
-        assertThat(1L, equalTo(metric.createStats().getIngestCurrent()));
+        assertThat(1L, equalTo(metric.createStats().ingestCurrent()));
 
         metric.postIngest(500000L);
-        assertThat(0L, equalTo(metric.createStats().getIngestCurrent()));
+        assertThat(0L, equalTo(metric.createStats().ingestCurrent()));
 
         // the second postIngest triggers an assertion error
         expectThrows(AssertionError.class, () -> metric.postIngest(500000L));
         // We never allow the reported ingestCurrent to be negative:
-        assertThat(metric.createStats().getIngestCurrent(), equalTo(0L));
+        assertThat(metric.createStats().ingestCurrent(), equalTo(0L));
     }
 
 }

server/src/test/java/org/elasticsearch/ingest/IngestServiceTests.java

@@ -1464,8 +1464,8 @@ public class IngestServiceTests extends ESTestCase {
         {
             // all zeroes since nothing has executed
             final IngestStats ingestStats = ingestService.stats();
-            assertThat(ingestStats.getPipelineStats().size(), equalTo(0));
-            assertStats(ingestStats.getTotalStats(), 0, 0, 0);
+            assertThat(ingestStats.pipelineStats().size(), equalTo(0));
+            assertStats(ingestStats.totalStats(), 0, 0, 0);
         }
 
         // put some pipelines, and now there are pipeline and processor stats, too
@@ -1497,14 +1497,14 @@ public class IngestServiceTests extends ESTestCase {
 
         {
             final IngestStats ingestStats = ingestService.stats();
-            assertThat(ingestStats.getPipelineStats().size(), equalTo(3));
+            assertThat(ingestStats.pipelineStats().size(), equalTo(3));
 
             // total
-            assertStats(ingestStats.getTotalStats(), 0, 0, 0);
+            assertStats(ingestStats.totalStats(), 0, 0, 0);
             // pipeline
-            assertPipelineStats(ingestStats.getPipelineStats(), "_id1", 0, 0, 0);
-            assertPipelineStats(ingestStats.getPipelineStats(), "_id2", 0, 0, 0);
-            assertPipelineStats(ingestStats.getPipelineStats(), "_id3", 0, 0, 0);
+            assertPipelineStats(ingestStats.pipelineStats(), "_id1", 0, 0, 0);
+            assertPipelineStats(ingestStats.pipelineStats(), "_id2", 0, 0, 0);
+            assertPipelineStats(ingestStats.pipelineStats(), "_id3", 0, 0, 0);
             // processor
             assertProcessorStats(0, ingestStats, "_id1", 0, 0, 0);
             assertProcessorStats(0, ingestStats, "_id2", 0, 0, 0);
@@ -1519,14 +1519,14 @@ public class IngestServiceTests extends ESTestCase {
 
         {
             final IngestStats ingestStats = ingestService.stats();
-            assertThat(ingestStats.getPipelineStats().size(), equalTo(3));
+            assertThat(ingestStats.pipelineStats().size(), equalTo(3));
 
             // total
-            assertStats(ingestStats.getTotalStats(), 1, 0, 0);
+            assertStats(ingestStats.totalStats(), 1, 0, 0);
             // pipeline
-            assertPipelineStats(ingestStats.getPipelineStats(), "_id1", 1, 0, 0);
-            assertPipelineStats(ingestStats.getPipelineStats(), "_id2", 1, 0, 0);
-            assertPipelineStats(ingestStats.getPipelineStats(), "_id3", 1, 0, 0);
+            assertPipelineStats(ingestStats.pipelineStats(), "_id1", 1, 0, 0);
+            assertPipelineStats(ingestStats.pipelineStats(), "_id2", 1, 0, 0);
+            assertPipelineStats(ingestStats.pipelineStats(), "_id3", 1, 0, 0);
             // processor
             assertProcessorStats(0, ingestStats, "_id1", 1, 0, 0);
             assertProcessorStats(0, ingestStats, "_id2", 1, 0, 0);
@@ -1561,8 +1561,8 @@ public class IngestServiceTests extends ESTestCase {
         IngestService ingestService = createWithProcessors(map);
 
         final IngestStats initialStats = ingestService.stats();
-        assertThat(initialStats.getPipelineStats().size(), equalTo(0));
-        assertStats(initialStats.getTotalStats(), 0, 0, 0);
+        assertThat(initialStats.pipelineStats().size(), equalTo(0));
+        assertStats(initialStats.totalStats(), 0, 0, 0);
 
         PutPipelineRequest putRequest = new PutPipelineRequest(
             "_id1",
@@ -1588,16 +1588,16 @@ public class IngestServiceTests extends ESTestCase {
         indexRequest.source(randomAlphaOfLength(10), randomAlphaOfLength(10));
         ingestService.executeBulkRequest(1, List.of(indexRequest), indexReq -> {}, failureHandler, completionHandler, Names.WRITE);
         final IngestStats afterFirstRequestStats = ingestService.stats();
-        assertThat(afterFirstRequestStats.getPipelineStats().size(), equalTo(2));
+        assertThat(afterFirstRequestStats.pipelineStats().size(), equalTo(2));
 
-        afterFirstRequestStats.getProcessorStats().get("_id1").forEach(p -> assertEquals(p.getName(), "mock:mockTag"));
-        afterFirstRequestStats.getProcessorStats().get("_id2").forEach(p -> assertEquals(p.getName(), "mock:mockTag"));
+        afterFirstRequestStats.processorStats().get("_id1").forEach(p -> assertEquals(p.name(), "mock:mockTag"));
+        afterFirstRequestStats.processorStats().get("_id2").forEach(p -> assertEquals(p.name(), "mock:mockTag"));
 
         // total
-        assertStats(afterFirstRequestStats.getTotalStats(), 1, 0, 0);
+        assertStats(afterFirstRequestStats.totalStats(), 1, 0, 0);
         // pipeline
-        assertPipelineStats(afterFirstRequestStats.getPipelineStats(), "_id1", 1, 0, 0);
-        assertPipelineStats(afterFirstRequestStats.getPipelineStats(), "_id2", 0, 0, 0);
+        assertPipelineStats(afterFirstRequestStats.pipelineStats(), "_id1", 1, 0, 0);
+        assertPipelineStats(afterFirstRequestStats.pipelineStats(), "_id2", 0, 0, 0);
         // processor
         assertProcessorStats(0, afterFirstRequestStats, "_id1", 1, 0, 0);
         assertProcessorStats(0, afterFirstRequestStats, "_id2", 0, 0, 0);
@@ -1605,12 +1605,12 @@ public class IngestServiceTests extends ESTestCase {
         indexRequest.setPipeline("_id2");
         ingestService.executeBulkRequest(1, List.of(indexRequest), indexReq -> {}, failureHandler, completionHandler, Names.WRITE);
         final IngestStats afterSecondRequestStats = ingestService.stats();
-        assertThat(afterSecondRequestStats.getPipelineStats().size(), equalTo(2));
+        assertThat(afterSecondRequestStats.pipelineStats().size(), equalTo(2));
         // total
-        assertStats(afterSecondRequestStats.getTotalStats(), 2, 0, 0);
+        assertStats(afterSecondRequestStats.totalStats(), 2, 0, 0);
         // pipeline
-        assertPipelineStats(afterSecondRequestStats.getPipelineStats(), "_id1", 1, 0, 0);
-        assertPipelineStats(afterSecondRequestStats.getPipelineStats(), "_id2", 1, 0, 0);
+        assertPipelineStats(afterSecondRequestStats.pipelineStats(), "_id1", 1, 0, 0);
+        assertPipelineStats(afterSecondRequestStats.pipelineStats(), "_id2", 1, 0, 0);
         // processor
         assertProcessorStats(0, afterSecondRequestStats, "_id1", 1, 0, 0);
         assertProcessorStats(0, afterSecondRequestStats, "_id2", 1, 0, 0);
@@ -1627,12 +1627,12 @@ public class IngestServiceTests extends ESTestCase {
         indexRequest.setPipeline("_id1");
         ingestService.executeBulkRequest(1, List.of(indexRequest), indexReq -> {}, failureHandler, completionHandler, Names.WRITE);
         final IngestStats afterThirdRequestStats = ingestService.stats();
-        assertThat(afterThirdRequestStats.getPipelineStats().size(), equalTo(2));
+        assertThat(afterThirdRequestStats.pipelineStats().size(), equalTo(2));
         // total
-        assertStats(afterThirdRequestStats.getTotalStats(), 3, 0, 0);
+        assertStats(afterThirdRequestStats.totalStats(), 3, 0, 0);
         // pipeline
-        assertPipelineStats(afterThirdRequestStats.getPipelineStats(), "_id1", 2, 0, 0);
-        assertPipelineStats(afterThirdRequestStats.getPipelineStats(), "_id2", 1, 0, 0);
+        assertPipelineStats(afterThirdRequestStats.pipelineStats(), "_id1", 2, 0, 0);
+        assertPipelineStats(afterThirdRequestStats.pipelineStats(), "_id2", 1, 0, 0);
         // The number of processors for the "id1" pipeline changed, so the per-processor metrics are not carried forward. This is
         // due to the parallel array's used to identify which metrics to carry forward. Without unique ids or semantic equals for each
         // processor, parallel arrays are the best option for of carrying forward metrics between pipeline changes. However, in some cases,
@@ -1650,12 +1650,12 @@ public class IngestServiceTests extends ESTestCase {
         indexRequest.setPipeline("_id1");
         ingestService.executeBulkRequest(1, List.of(indexRequest), indexReq -> {}, failureHandler, completionHandler, Names.WRITE);
         final IngestStats afterForthRequestStats = ingestService.stats();
-        assertThat(afterForthRequestStats.getPipelineStats().size(), equalTo(2));
+        assertThat(afterForthRequestStats.pipelineStats().size(), equalTo(2));
         // total
-        assertStats(afterForthRequestStats.getTotalStats(), 4, 0, 0);
+        assertStats(afterForthRequestStats.totalStats(), 4, 0, 0);
         // pipeline
-        assertPipelineStats(afterForthRequestStats.getPipelineStats(), "_id1", 3, 0, 0);
-        assertPipelineStats(afterForthRequestStats.getPipelineStats(), "_id2", 1, 0, 0);
+        assertPipelineStats(afterForthRequestStats.pipelineStats(), "_id1", 3, 0, 0);
+        assertPipelineStats(afterForthRequestStats.pipelineStats(), "_id2", 1, 0, 0);
         // processor
         assertProcessorStats(0, afterForthRequestStats, "_id1", 1, 1, 0); // not carried forward since type changed
         assertProcessorStats(1, afterForthRequestStats, "_id1", 2, 0, 0); // carried forward and added from old stats
@@ -2422,7 +2422,7 @@ public class IngestServiceTests extends ESTestCase {
     }
 
     private void assertProcessorStats(int processor, IngestStats stats, String pipelineId, long count, long failed, long time) {
-        assertStats(stats.getProcessorStats().get(pipelineId).get(processor).getStats(), count, failed, time);
+        assertStats(stats.processorStats().get(pipelineId).get(processor).stats(), count, failed, time);
     }
 
     private void assertPipelineStats(List<IngestStats.PipelineStat> pipelineStats, String pipelineId, long count, long failed, long time) {
@@ -2430,14 +2430,14 @@ public class IngestServiceTests extends ESTestCase {
     }
 
     private void assertStats(IngestStats.Stats stats, long count, long failed, long time) {
-        assertThat(stats.getIngestCount(), equalTo(count));
-        assertThat(stats.getIngestCurrent(), equalTo(0L));
-        assertThat(stats.getIngestFailedCount(), equalTo(failed));
-        assertThat(stats.getIngestTimeInMillis(), greaterThanOrEqualTo(time));
+        assertThat(stats.ingestCount(), equalTo(count));
+        assertThat(stats.ingestCurrent(), equalTo(0L));
+        assertThat(stats.ingestFailedCount(), equalTo(failed));
+        assertThat(stats.ingestTimeInMillis(), greaterThanOrEqualTo(time));
     }
 
     private IngestStats.Stats getPipelineStats(List<IngestStats.PipelineStat> pipelineStats, String id) {
-        return pipelineStats.stream().filter(p1 -> p1.getPipelineId().equals(id)).findFirst().map(p2 -> p2.getStats()).orElse(null);
+        return pipelineStats.stream().filter(p1 -> p1.pipelineId().equals(id)).findFirst().map(p2 -> p2.stats()).orElse(null);
     }
 
     private static List<IngestService.PipelineClusterStateUpdateTask> oneTask(DeletePipelineRequest request) {

server/src/test/java/org/elasticsearch/ingest/IngestStatsTests.java

@@ -25,17 +25,17 @@ public class IngestStatsTests extends ESTestCase {
         Map<String, List<IngestStats.ProcessorStat>> processorStats = createProcessorStats(pipelineStats);
         IngestStats ingestStats = new IngestStats(totalStats, pipelineStats, processorStats);
         IngestStats serializedStats = serialize(ingestStats);
-        assertIngestStats(ingestStats, serializedStats, true, true);
+        assertIngestStats(ingestStats, serializedStats);
     }
 
-    private List<IngestStats.PipelineStat> createPipelineStats() {
+    private static List<IngestStats.PipelineStat> createPipelineStats() {
         IngestStats.PipelineStat pipeline1Stats = new IngestStats.PipelineStat("pipeline1", new IngestStats.Stats(3, 3, 3, 3));
         IngestStats.PipelineStat pipeline2Stats = new IngestStats.PipelineStat("pipeline2", new IngestStats.Stats(47, 97, 197, 297));
         IngestStats.PipelineStat pipeline3Stats = new IngestStats.PipelineStat("pipeline3", new IngestStats.Stats(0, 0, 0, 0));
         return List.of(pipeline1Stats, pipeline2Stats, pipeline3Stats);
     }
 
-    private Map<String, List<IngestStats.ProcessorStat>> createProcessorStats(List<IngestStats.PipelineStat> pipelineStats) {
+    private static Map<String, List<IngestStats.ProcessorStat>> createProcessorStats(List<IngestStats.PipelineStat> pipelineStats) {
         assert (pipelineStats.size() >= 2);
         IngestStats.ProcessorStat processor1Stat = new IngestStats.ProcessorStat("processor1", "type", new IngestStats.Stats(1, 1, 1, 1));
         IngestStats.ProcessorStat processor2Stat = new IngestStats.ProcessorStat("processor2", "type", new IngestStats.Stats(2, 2, 2, 2));
@@ -46,74 +46,56 @@ public class IngestStatsTests extends ESTestCase {
         );
         // pipeline1 -> processor1,processor2; pipeline2 -> processor3
         return Map.of(
-            pipelineStats.get(0).getPipelineId(),
+            pipelineStats.get(0).pipelineId(),
             List.of(processor1Stat, processor2Stat),
-            pipelineStats.get(1).getPipelineId(),
+            pipelineStats.get(1).pipelineId(),
             List.of(processor3Stat)
         );
     }
 
-    private IngestStats serialize(IngestStats stats) throws IOException {
+    private static IngestStats serialize(IngestStats stats) throws IOException {
         BytesStreamOutput out = new BytesStreamOutput();
         stats.writeTo(out);
         StreamInput in = out.bytes().streamInput();
         return new IngestStats(in);
     }
 
-    private void assertIngestStats(
-        IngestStats ingestStats,
-        IngestStats serializedStats,
-        boolean expectProcessors,
-        boolean expectProcessorTypes
-    ) {
+    private static void assertIngestStats(IngestStats ingestStats, IngestStats serializedStats) {
         assertNotSame(ingestStats, serializedStats);
-        assertNotSame(ingestStats.getTotalStats(), serializedStats.getTotalStats());
-        assertNotSame(ingestStats.getPipelineStats(), serializedStats.getPipelineStats());
-        assertNotSame(ingestStats.getProcessorStats(), serializedStats.getProcessorStats());
+        assertNotSame(ingestStats.totalStats(), serializedStats.totalStats());
+        assertNotSame(ingestStats.pipelineStats(), serializedStats.pipelineStats());
+        assertNotSame(ingestStats.processorStats(), serializedStats.processorStats());
 
-        assertStats(ingestStats.getTotalStats(), serializedStats.getTotalStats());
-        assertEquals(ingestStats.getPipelineStats().size(), serializedStats.getPipelineStats().size());
+        assertEquals(ingestStats.totalStats(), serializedStats.totalStats());
+        assertEquals(ingestStats.pipelineStats().size(), serializedStats.pipelineStats().size());
 
-        for (IngestStats.PipelineStat serializedPipelineStat : serializedStats.getPipelineStats()) {
-            assertStats(
-                getPipelineStats(ingestStats.getPipelineStats(), serializedPipelineStat.getPipelineId()),
-                serializedPipelineStat.getStats()
+        for (IngestStats.PipelineStat serializedPipelineStat : serializedStats.pipelineStats()) {
+            assertEquals(
+                getPipelineStats(ingestStats.pipelineStats(), serializedPipelineStat.pipelineId()),
+                serializedPipelineStat.stats()
             );
-            List<IngestStats.ProcessorStat> serializedProcessorStats = serializedStats.getProcessorStats()
-                .get(serializedPipelineStat.getPipelineId());
-            List<IngestStats.ProcessorStat> processorStat = ingestStats.getProcessorStats().get(serializedPipelineStat.getPipelineId());
-            if (expectProcessors) {
-                if (processorStat != null) {
-                    Iterator<IngestStats.ProcessorStat> it = processorStat.iterator();
-                    // intentionally enforcing the identical ordering
-                    for (IngestStats.ProcessorStat serializedProcessorStat : serializedProcessorStats) {
-                        IngestStats.ProcessorStat ps = it.next();
-                        assertEquals(ps.getName(), serializedProcessorStat.getName());
-                        if (expectProcessorTypes) {
-                            assertEquals(ps.getType(), serializedProcessorStat.getType());
-                        } else {
-                            assertEquals("_NOT_AVAILABLE", serializedProcessorStat.getType());
-                        }
-                        assertStats(ps.getStats(), serializedProcessorStat.getStats());
-                    }
-                    assertFalse(it.hasNext());
+            List<IngestStats.ProcessorStat> serializedProcessorStats = serializedStats.processorStats()
+                .get(serializedPipelineStat.pipelineId());
+            List<IngestStats.ProcessorStat> processorStat = ingestStats.processorStats().get(serializedPipelineStat.pipelineId());
+            if (processorStat != null) {
+                Iterator<IngestStats.ProcessorStat> it = processorStat.iterator();
+                // intentionally enforcing the identical ordering
+                for (IngestStats.ProcessorStat serializedProcessorStat : serializedProcessorStats) {
+                    IngestStats.ProcessorStat ps = it.next();
+                    assertEquals(ps.name(), serializedProcessorStat.name());
+                    assertEquals(ps.type(), serializedProcessorStat.type());
+                    assertEquals(ps.stats(), serializedProcessorStat.stats());
                 }
-            } else {
-                // pre 6.5 did not serialize any processor stats
-                assertNull(serializedProcessorStats);
+                assertFalse(it.hasNext());
             }
         }
-
-    }
-
-    private void assertStats(IngestStats.Stats fromObject, IngestStats.Stats fromStream) {
-        assertEquals(fromObject.getIngestCount(), fromStream.getIngestCount());
-        assertEquals(fromObject.getIngestFailedCount(), fromStream.getIngestFailedCount());
-        assertEquals(fromObject.getIngestTimeInMillis(), fromStream.getIngestTimeInMillis());
-        assertEquals(fromObject.getIngestCurrent(), fromStream.getIngestCurrent());
     }
 
-    private IngestStats.Stats getPipelineStats(List<IngestStats.PipelineStat> pipelineStats, String id) {
-        return pipelineStats.stream().filter(p1 -> p1.getPipelineId().equals(id)).findFirst().map(p2 -> p2.getStats()).orElse(null);
+    private static IngestStats.Stats getPipelineStats(List<IngestStats.PipelineStat> pipelineStats, String id) {
+        return pipelineStats.stream()
+            .filter(p1 -> p1.pipelineId().equals(id))
+            .findFirst()
+            .map(IngestStats.PipelineStat::stats)
+            .orElse(null);
     }
 }

server/src/test/java/org/elasticsearch/ingest/PipelineProcessorTests.java

@@ -191,24 +191,24 @@ public class PipelineProcessorTests extends ESTestCase {
         IngestStats.Stats pipeline3Stats = pipeline3.getMetrics().createStats();
 
         // current
-        assertThat(pipeline1Stats.getIngestCurrent(), equalTo(0L));
-        assertThat(pipeline2Stats.getIngestCurrent(), equalTo(0L));
-        assertThat(pipeline3Stats.getIngestCurrent(), equalTo(0L));
+        assertThat(pipeline1Stats.ingestCurrent(), equalTo(0L));
+        assertThat(pipeline2Stats.ingestCurrent(), equalTo(0L));
+        assertThat(pipeline3Stats.ingestCurrent(), equalTo(0L));
 
         // count
-        assertThat(pipeline1Stats.getIngestCount(), equalTo(1L));
-        assertThat(pipeline2Stats.getIngestCount(), equalTo(1L));
-        assertThat(pipeline3Stats.getIngestCount(), equalTo(1L));
+        assertThat(pipeline1Stats.ingestCount(), equalTo(1L));
+        assertThat(pipeline2Stats.ingestCount(), equalTo(1L));
+        assertThat(pipeline3Stats.ingestCount(), equalTo(1L));
 
         // time
-        assertThat(pipeline1Stats.getIngestTimeInMillis(), equalTo(0L));
-        assertThat(pipeline2Stats.getIngestTimeInMillis(), equalTo(3L));
-        assertThat(pipeline3Stats.getIngestTimeInMillis(), equalTo(2L));
+        assertThat(pipeline1Stats.ingestTimeInMillis(), equalTo(0L));
+        assertThat(pipeline2Stats.ingestTimeInMillis(), equalTo(3L));
+        assertThat(pipeline3Stats.ingestTimeInMillis(), equalTo(2L));
 
         // failure
-        assertThat(pipeline1Stats.getIngestFailedCount(), equalTo(0L));
-        assertThat(pipeline2Stats.getIngestFailedCount(), equalTo(0L));
-        assertThat(pipeline3Stats.getIngestFailedCount(), equalTo(1L));
+        assertThat(pipeline1Stats.ingestFailedCount(), equalTo(0L));
+        assertThat(pipeline2Stats.ingestFailedCount(), equalTo(0L));
+        assertThat(pipeline3Stats.ingestFailedCount(), equalTo(1L));
     }
 
     public void testIngestPipelineMetadata() {

x-pack/plugin/core/src/main/java/org/elasticsearch/xpack/core/ml/action/GetTrainedModelsStatsAction.java

@@ -304,7 +304,7 @@ public class GetTrainedModelsStatsAction extends ActionType<GetTrainedModelsStat
                                 modelId,
                                 modelSizeStats,
                                 ingestStats,
-                                ingestStats == null ? 0 : ingestStats.getPipelineStats().size(),
+                                ingestStats == null ? 0 : ingestStats.pipelineStats().size(),
                                 inferenceStats,
                                 null // no assignment stats for undeployed models
                             )
@@ -327,7 +327,7 @@ public class GetTrainedModelsStatsAction extends ActionType<GetTrainedModelsStat
                                     modelId,
                                     modelSizeStats,
                                     ingestStats,
-                                    ingestStats == null ? 0 : ingestStats.getPipelineStats().size(),
+                                    ingestStats == null ? 0 : ingestStats.pipelineStats().size(),
                                     inferenceStats,
                                     assignmentStats
                                 )

x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/MachineLearningUsageTransportAction.java

@@ -475,11 +475,11 @@ public class MachineLearningUsageTransportAction extends XPackUsageFeatureTransp
 
         for (GetTrainedModelsStatsAction.Response.TrainedModelStats modelStats : statsResponse.getResources().results()) {
             pipelineCount += modelStats.getPipelineCount();
-            modelStats.getIngestStats().getProcessorStats().values().stream().flatMap(List::stream).forEach(processorStat -> {
-                if (processorStat.getName().equals(InferenceProcessor.TYPE)) {
-                    docCountStats.add(processorStat.getStats().getIngestCount());
-                    timeStats.add(processorStat.getStats().getIngestTimeInMillis());
-                    failureStats.add(processorStat.getStats().getIngestFailedCount());
+            modelStats.getIngestStats().processorStats().values().stream().flatMap(List::stream).forEach(processorStat -> {
+                if (processorStat.name().equals(InferenceProcessor.TYPE)) {
+                    docCountStats.add(processorStat.stats().ingestCount());
+                    timeStats.add(processorStat.stats().ingestTimeInMillis());
+                    failureStats.add(processorStat.stats().ingestFailedCount());
                 }
             });
         }

x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/action/TransportGetTrainedModelsStatsAction.java

@@ -374,11 +374,11 @@ public class TransportGetTrainedModelsStatsAction extends HandledTransportAction
 
     static IngestStats ingestStatsForPipelineIds(NodeStats nodeStats, Set<String> pipelineIds) {
         IngestStats fullNodeStats = nodeStats.getIngestStats();
-        Map<String, List<IngestStats.ProcessorStat>> filteredProcessorStats = new HashMap<>(fullNodeStats.getProcessorStats());
+        Map<String, List<IngestStats.ProcessorStat>> filteredProcessorStats = new HashMap<>(fullNodeStats.processorStats());
         filteredProcessorStats.keySet().retainAll(pipelineIds);
-        List<IngestStats.PipelineStat> filteredPipelineStats = fullNodeStats.getPipelineStats()
+        List<IngestStats.PipelineStat> filteredPipelineStats = fullNodeStats.pipelineStats()
             .stream()
-            .filter(pipelineStat -> pipelineIds.contains(pipelineStat.getPipelineId()))
+            .filter(pipelineStat -> pipelineIds.contains(pipelineStat.pipelineId()))
             .collect(Collectors.toList());
         CounterMetric ingestCount = new CounterMetric();
         CounterMetric ingestTimeInMillis = new CounterMetric();
@@ -386,11 +386,11 @@ public class TransportGetTrainedModelsStatsAction extends HandledTransportAction
         CounterMetric ingestFailedCount = new CounterMetric();
 
         filteredPipelineStats.forEach(pipelineStat -> {
-            IngestStats.Stats stats = pipelineStat.getStats();
-            ingestCount.inc(stats.getIngestCount());
-            ingestTimeInMillis.inc(stats.getIngestTimeInMillis());
-            ingestCurrent.inc(stats.getIngestCurrent());
-            ingestFailedCount.inc(stats.getIngestFailedCount());
+            IngestStats.Stats stats = pipelineStat.stats();
+            ingestCount.inc(stats.ingestCount());
+            ingestTimeInMillis.inc(stats.ingestTimeInMillis());
+            ingestCurrent.inc(stats.ingestCurrent());
+            ingestFailedCount.inc(stats.ingestFailedCount());
         });
 
         return new IngestStats(
@@ -407,23 +407,23 @@ public class TransportGetTrainedModelsStatsAction extends HandledTransportAction
         IngestStatsAccumulator totalStats = new IngestStatsAccumulator();
         ingestStatsList.forEach(ingestStats -> {
 
-            ingestStats.getPipelineStats()
+            ingestStats.pipelineStats()
                 .forEach(
-                    pipelineStat -> pipelineStatsAcc.computeIfAbsent(pipelineStat.getPipelineId(), p -> new IngestStatsAccumulator())
-                        .inc(pipelineStat.getStats())
+                    pipelineStat -> pipelineStatsAcc.computeIfAbsent(pipelineStat.pipelineId(), p -> new IngestStatsAccumulator())
+                        .inc(pipelineStat.stats())
                 );
 
-            ingestStats.getProcessorStats().forEach((pipelineId, processorStat) -> {
+            ingestStats.processorStats().forEach((pipelineId, processorStat) -> {
                 Map<String, IngestStatsAccumulator> processorAcc = processorStatsAcc.computeIfAbsent(
                     pipelineId,
                     k -> new LinkedHashMap<>()
                 );
                 processorStat.forEach(
-                    p -> processorAcc.computeIfAbsent(p.getName(), k -> new IngestStatsAccumulator(p.getType())).inc(p.getStats())
+                    p -> processorAcc.computeIfAbsent(p.name(), k -> new IngestStatsAccumulator(p.type())).inc(p.stats())
                 );
             });
 
-            totalStats.inc(ingestStats.getTotalStats());
+            totalStats.inc(ingestStats.totalStats());
         });
 
         List<IngestStats.PipelineStat> pipelineStatList = new ArrayList<>(pipelineStatsAcc.size());
@@ -458,10 +458,10 @@ public class TransportGetTrainedModelsStatsAction extends HandledTransportAction
         }
 
         void inc(IngestStats.Stats s) {
-            ingestCount.inc(s.getIngestCount());
-            ingestTimeInMillis.inc(s.getIngestTimeInMillis());
-            ingestCurrent.inc(s.getIngestCurrent());
-            ingestFailedCount.inc(s.getIngestFailedCount());
+            ingestCount.inc(s.ingestCount());
+            ingestTimeInMillis.inc(s.ingestTimeInMillis());
+            ingestCurrent.inc(s.ingestCurrent());
+            ingestFailedCount.inc(s.ingestFailedCount());
         }
 
         IngestStats.Stats build() {

x-pack/plugin/ml/src/main/java/org/elasticsearch/xpack/ml/rest/cat/RestCatTrainedModelsAction.java

@@ -280,14 +280,14 @@ public class RestCatTrainedModelsAction extends AbstractCatAction {
             GetTrainedModelsStatsAction.Response.TrainedModelStats modelStats = statsMap.get(config.getModelId());
             table.addCell(modelStats.getPipelineCount());
             boolean hasIngestStats = modelStats != null && modelStats.getIngestStats() != null;
-            table.addCell(hasIngestStats ? modelStats.getIngestStats().getTotalStats().getIngestCount() : 0);
+            table.addCell(hasIngestStats ? modelStats.getIngestStats().totalStats().ingestCount() : 0);
             table.addCell(
                 hasIngestStats
-                    ? TimeValue.timeValueMillis(modelStats.getIngestStats().getTotalStats().getIngestTimeInMillis())
+                    ? TimeValue.timeValueMillis(modelStats.getIngestStats().totalStats().ingestTimeInMillis())
                     : TimeValue.timeValueMillis(0)
             );
-            table.addCell(hasIngestStats ? modelStats.getIngestStats().getTotalStats().getIngestCurrent() : 0);
-            table.addCell(hasIngestStats ? modelStats.getIngestStats().getTotalStats().getIngestFailedCount() : 0);
+            table.addCell(hasIngestStats ? modelStats.getIngestStats().totalStats().ingestCurrent() : 0);
+            table.addCell(hasIngestStats ? modelStats.getIngestStats().totalStats().ingestFailedCount() : 0);
 
             DataFrameAnalyticsConfig dataFrameAnalyticsConfig = config.getTags()
                 .stream()

x-pack/plugin/ml/src/test/java/org/elasticsearch/xpack/ml/action/TransportGetTrainedModelsStatsActionTests.java

@@ -248,7 +248,7 @@ public class TransportGetTrainedModelsStatsActionTests extends ESTestCase {
         List<IngestStats.PipelineStat> pipelineNames,
         List<List<IngestStats.ProcessorStat>> processorStats
     ) {
-        List<String> pipelineids = pipelineNames.stream().map(IngestStats.PipelineStat::getPipelineId).collect(Collectors.toList());
+        List<String> pipelineids = pipelineNames.stream().map(IngestStats.PipelineStat::pipelineId).collect(Collectors.toList());
         IngestStats ingestStats = new IngestStats(
             overallStats,
             pipelineNames,