Moved jaeger/prometheus check logic into reporters and added iterator utils

Signed-off-by: Alexandros Filios <[email protected]>

Author: alexandrosfilios

integration/fabric/iou/commands.go

@@ -94,7 +94,7 @@ func CheckJaegerTraces(ii *integration.Infrastructure, nodeName, viewName string
 	it, err := cli.FindTraces(nodeName, viewName)
 	gomega.Expect(err).NotTo(gomega.HaveOccurred())
 
-	spans, err := iterators.ReadAllPointers(iterators.Flatten(it, func(c *api_v2.SpansResponseChunk) ([]model2.Span, error) { return c.Spans, nil }))
+	spans, err := iterators.ReadAllPointers(iterators.FlattenValues(it, func(c *api_v2.SpansResponseChunk) ([]model2.Span, error) { return c.Spans, nil }))
 
 	gomega.Expect(err).NotTo(gomega.HaveOccurred())
 	logger.Infof("Received jaeger %d spans for [%s:%s]: %s", len(spans), nodeName, viewName, spans)
@@ -117,5 +117,5 @@ func CheckPrometheusMetrics(ii *integration.Infrastructure, viewName string) {
 	gomega.Expect(err).To(gomega.BeNil())
 	ops, err := cli.GetViewOperations("", viewName)
 	gomega.Expect(err).ToNot(gomega.HaveOccurred())
-	gomega.Expect(ops).To(gomega.Equal(1))
+	gomega.Expect(ops).To(gomega.Equal(2))
 }

platform/common/utils/collections/iterators/flatten.go

@@ -13,16 +13,16 @@ import (
 
 // Flatten flattens a nested iterator
 func Flatten[A any, B any](iterator Iterator[A], transformer Transformer[A, []B]) Iterator[B] {
-	return &flattened[A, B]{Iterator: iterator, transformer: transformer, remaining: []B{}}
+	return &flattenedPointers[A, B]{Iterator: iterator, transformer: transformer, remaining: []B{}}
 }
 
-type flattened[A any, B any] struct {
+type flattenedPointers[A any, B any] struct {
 	Iterator[A]
 	transformer func(A) ([]B, error)
 	remaining   []B
 }
 
-func (it *flattened[A, B]) Next() (B, error) {
+func (it *flattenedPointers[A, B]) Next() (B, error) {
 	if len(it.remaining) > 0 {
 		n := it.remaining[0]
 		it.remaining = it.remaining[1:]
@@ -40,3 +40,31 @@ func (it *flattened[A, B]) Next() (B, error) {
 		return next[0], nil
 	}
 }
+func FlattenValues[A any, B any](iterator Iterator[A], transformer Transformer[A, []B]) Iterator[*B] {
+	return &flattenedValues[A, B]{Iterator: iterator, transformer: transformer, remaining: []B{}}
+}
+
+type flattenedValues[A any, B any] struct {
+	Iterator[A]
+	transformer func(A) ([]B, error)
+	remaining   []B
+}
+
+func (it *flattenedValues[A, B]) Next() (*B, error) {
+	if len(it.remaining) > 0 {
+		n := it.remaining[0]
+		it.remaining = it.remaining[1:]
+		return &n, nil
+	} else if next, err := it.Iterator.Next(); err != nil {
+		return nil, errors.Wrapf(err, "failed fetching")
+	} else if utils.IsNil(next) {
+		return nil, nil
+	} else if next, err := it.transformer(next); err != nil {
+		return nil, errors.Wrapf(err, "failed transforming")
+	} else if len(next) == 0 {
+		return nil, nil
+	} else {
+		it.remaining = next[1:]
+		return &next[0], nil
+	}
+}