influxdata · cypressious · May 8, 2018 · May 9, 2018 · May 8, 2018
diff --git a/src/InfluxDB.Collector/CollectorConfiguration.cs b/src/InfluxDB.Collector/CollectorConfiguration.cs
@@ -10,6 +10,7 @@ public class CollectorConfiguration
         readonly PipelinedCollectorTagConfiguration _tag;
         readonly PipelinedCollectorEmitConfiguration _emitter;
         readonly PipelinedCollectorBatchConfiguration _batcher;
+        readonly PipelinedCollectorAggregateConfiguration _aggregator;
 
         public CollectorConfiguration()
             : this(null)
@@ -22,6 +23,7 @@ internal CollectorConfiguration(IPointEmitter parent = null)
             _tag = new PipelinedCollectorTagConfiguration(this);
             _emitter = new PipelinedCollectorEmitConfiguration(this);
             _batcher = new PipelinedCollectorBatchConfiguration(this);
+            _aggregator = new PipelinedCollectorAggregateConfiguration(this);
         }
 
         public CollectorTagConfiguration Tag => _tag;
@@ -30,6 +32,8 @@ internal CollectorConfiguration(IPointEmitter parent = null)
 
         public CollectorBatchConfiguration Batch => _batcher;
 
+        public CollectorAggregateConfiguration Aggregate => _aggregator;
+
         public MetricsCollector CreateCollector()
         {
             Action disposeEmitter;
@@ -38,6 +42,7 @@ public MetricsCollector CreateCollector()
             var emitter = _parent;
             emitter = _emitter.CreateEmitter(emitter, out disposeEmitter);
             emitter = _batcher.CreateEmitter(emitter, out disposeBatcher);
+            emitter = _aggregator.CreateEmitter(emitter, out disposeEmitter);
 
             return new PipelinedMetricsCollector(emitter, _tag.CreateEnricher(), () =>
             {
@@ -46,4 +51,4 @@ public MetricsCollector CreateCollector()
             });
         }
     }
-}
+}
diff --git a/src/InfluxDB.Collector/Configuration/AggregateEmitter.cs b/src/InfluxDB.Collector/Configuration/AggregateEmitter.cs
@@ -4,7 +4,7 @@
 
 namespace InfluxDB.Collector.Configuration
 {
-    class AggregateEmitter : IPointEmitter
+    class AggregateEmitter : IPointEmitter, ISinglePointEmitter
     {
         readonly List<IPointEmitter> _emitters;
 
@@ -19,5 +19,20 @@ public void Emit(PointData[] points)
             foreach (var emitter in _emitters)
                 emitter.Emit(points);
         }
+
+        public void Emit(PointData point)
+        {
+            foreach (var emitter in _emitters)
+            {
+                if (emitter is ISinglePointEmitter singlePointEmitter)
+                {
+                    singlePointEmitter.Emit(point);
+                }
+                else
+                {
+                    emitter.Emit(new[] { point });
+                }
+            }
+        }
     }
 }
diff --git a/src/InfluxDB.Collector/Configuration/CollectorAggregateConfiguration.cs b/src/InfluxDB.Collector/Configuration/CollectorAggregateConfiguration.cs
@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+
+namespace InfluxDB.Collector.Configuration
+{
+    public abstract class CollectorAggregateConfiguration
+    {
+        public abstract CollectorConfiguration AtInterval(TimeSpan interval);
+
+        public abstract CollectorConfiguration SumIncrements();
+
+        public abstract CollectorConfiguration AggregateTimes(Func<IEnumerable<long>, double> func);
+    }
+}
diff --git a/src/InfluxDB.Collector/Configuration/PipelinedCollectorAggregateConfiguration.cs b/src/InfluxDB.Collector/Configuration/PipelinedCollectorAggregateConfiguration.cs
@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using InfluxDB.Collector.Pipeline;
+using InfluxDB.Collector.Pipeline.Aggregate;
+
+namespace InfluxDB.Collector.Configuration
+{
+    class PipelinedCollectorAggregateConfiguration : CollectorAggregateConfiguration
+    {
+        private readonly CollectorConfiguration _configuration;
+
+        bool _sumIncrements;
+        Func<IEnumerable<long>, double> _timeAggregation;
+        TimeSpan? _interval;
+
+        public PipelinedCollectorAggregateConfiguration(CollectorConfiguration configuration)
+        {
+            if (configuration == null) throw new ArgumentNullException(nameof(configuration));
+            _configuration = configuration;
+        }
+
+        public override CollectorConfiguration AtInterval(TimeSpan interval)
+        {
+            _interval = interval;
+            return _configuration;
+        }
+
+        public override CollectorConfiguration SumIncrements()
+        {
+            _sumIncrements = true;
+            return _configuration;
+        }
+
+        public override CollectorConfiguration AggregateTimes(Func<IEnumerable<long>, double> func)
+        {
+            _timeAggregation = func;
+            return _configuration;
+        }
+
+        public IPointEmitter CreateEmitter(IPointEmitter parent, out Action dispose)
+        {
+            if (_interval == null)
+            {
+                dispose = null;
+                return parent;
+            }
+
+            var aggregator = new AggregatePointEmitter(_interval.Value, _sumIncrements, _timeAggregation, parent);
+            dispose = aggregator.Dispose;
+            return aggregator;
+        }
+    }
+}
diff --git a/src/InfluxDB.Collector/MetricsCollector.cs b/src/InfluxDB.Collector/MetricsCollector.cs
@@ -5,7 +5,7 @@
 
 namespace InfluxDB.Collector
 {
-    public abstract class MetricsCollector : IPointEmitter, IDisposable
+    public abstract class MetricsCollector : IPointEmitter, ISinglePointEmitter, IDisposable
     {
         readonly Util.ITimestampSource _timestampSource = new Util.PseudoHighResTimestampSource();
 
@@ -34,14 +34,16 @@ public void Dispose()
             Dispose(true);
         }
 
-        protected virtual void Dispose(bool disposing) { }
+        protected virtual void Dispose(bool disposing)
+        {
+        }
 
         public void Write(string measurement, IReadOnlyDictionary<string, object> fields, IReadOnlyDictionary<string, string> tags = null, DateTime? timestamp = null)
         {
             try
             {
                 var point = new PointData(measurement, fields, tags, timestamp ?? _timestampSource.GetUtcNow());
-                Emit(new[] { point });
+                Emit(point);
             }
             catch (Exception ex)
             {
@@ -54,6 +56,16 @@ void IPointEmitter.Emit(PointData[] points)
             Emit(points);
         }
 
+        void ISinglePointEmitter.Emit(PointData point)
+        {
+            Emit(point);
+        }
+
         protected abstract void Emit(PointData[] points);
+
+        protected virtual void Emit(PointData point)
+        {
+            Emit(new[] { point });
+        }
     }
-}
+}
diff --git a/src/InfluxDB.Collector/Pipeline/Aggregate/AggregateGroupingKey.cs b/src/InfluxDB.Collector/Pipeline/Aggregate/AggregateGroupingKey.cs
@@ -0,0 +1,92 @@
+using System;
+using System.Collections.Generic;
+
+namespace InfluxDB.Collector.Pipeline.Aggregate
+{
+    struct GroupingKey : IEquatable<GroupingKey>
+    {
+        private static readonly Dictionary<string, string> EmptyDict = new Dictionary<string, string>();
+
+        public long Bucket { get; }
+
+        public MeasurementKind Kind { get; }
+
+        public string Measurement { get; }
+
+        public Dictionary<string, string> Tags { get; }
+
+        public GroupingKey(long bucket, MeasurementKind kind, string measurement, Dictionary<string, string> tags)
+        {
+            Bucket = bucket;
+            Kind = kind;
+            Measurement = measurement;
+            Tags = tags ?? EmptyDict;
+        }
+
+        public bool Equals(GroupingKey other)
+        {
+            return Bucket == other.Bucket && Kind == other.Kind && Measurement == other.Measurement && DictionaryEquals(Tags, other.Tags);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj))
+            {
+                return false;
+            }
+
+            return obj is GroupingKey key && Equals(key);
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                int hashCode = Bucket.GetHashCode();
+                hashCode = (hashCode * 397) ^ (int) Kind;
+                hashCode = (hashCode * 397) ^ Measurement.GetHashCode();
+                hashCode = (hashCode * 397) ^ TagsHashCode();
+                return hashCode;
+            }
+        }
+
+        int TagsHashCode()
+        {
+            unchecked
+            {
+                int hashCode = 1;
+                foreach (var kvp in Tags)
+                {
+                    hashCode *= (kvp.Key.GetHashCode() * 397) ^ kvp.Key.GetHashCode();
+                }
+
+                return hashCode;
+            }
+        }
+
+        static bool DictionaryEquals(Dictionary<string, string> dict, Dictionary<string, string> dict2)
+        {
+            if (dict.Count != dict2.Count)
+            {
+                return false;
+            }
+
+            foreach (var kvp in dict)
+            {
+                if (dict2.TryGetValue(kvp.Key, out string value))
+                {
+                    if (value != kvp.Value)
+                    {
+                        return false;
+                    }
+                }
+                else
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+    }
+}