public AggregatedMetric Aggregate(AggregatedMetric original, Metric metric)
        {
            var countMetric = metric;

            return new AggregatedMetric
            {
                LastValue = countMetric.Value,
                NumMetrics = ++original.NumMetrics,
                Value = original.Value + countMetric.Value
            };
        }
Exemple #2
0
        private static async Task RunConsumer(ConnectionMultiplexer conn, string consumerName)
        {
            var redisDb = conn.GetDatabase();

            while (true)
            {
                var currentSeconds = TimeStampProvider.GetCurrentTimeStamp(TimePrecisionUnit.Seconds, 10);

                var sortedSetEntries = await redisDb.SortedSetRangeByScoreWithScoresAsync("recentlyset:" + consumerName, double.NegativeInfinity, currentSeconds, take : 1);

                if (sortedSetEntries.Length == 1)
                {
                    var metricId  = sortedSetEntries[0].Element.ToString();
                    var metricKey = metricId.Split(':')[1];
                    var timestamp = long.Parse(metricId.Split(':')[2]);

                    // Aggreagate this metric
                    var metricValues = await redisDb.SortedSetRangeByRankWithScoresAsync(metricId, 0, -1);

                    var values = new List <long>();
                    foreach (var metricValue in metricValues)
                    {
                        var temp = metricValue.Element.ToString();
                        values.Add(long.Parse(temp));
                    }

                    var aggregatedMetric = new AggregatedMetric()
                    {
                        Count     = values.Count,
                        Max       = values.Max(),
                        Min       = values.Min(),
                        Sum       = values.Sum(),
                        Timestamp = timestamp
                    };

                    var isInserted = await redisDb.SortedSetAddAsync(metricKey + ":values", aggregatedMetric.ToString(), timestamp);

                    // delete the recentry set metric
                    var deletedCount = await redisDb.SortedSetRemoveRangeByScoreAsync("recentlyset:" + consumerName, sortedSetEntries[0].Score, sortedSetEntries[0].Score);

                    // delete the metric's values in the specific time range
                    var metricValuesDeleted = await redisDb.KeyDeleteAsync(metricId);

                    // Remove the metric assigned to consumer key
                    var assignedKeyRemoved = await redisDb.KeyDeleteAsync("assigned.consumer:" + metricId);
                }
                else
                {
                    await Task.Delay(100);
                }
            }
        }
Exemple #3
0
        public async Task Run()
        {
            var redisDb = conn.GetDatabase(DBNbr);

            //await TestResults();

            //await TestSortedSet();

            await ConsumersManager();

            //var consumerTask = RunConsumer("consumer_1");
            //var consumerTask2 = RunConsumer("consumer_2");


            var stopwatch = Stopwatch.StartNew();

            for (int i = 1; i <= 1_000_000; i++)
            {
                try
                {
                    var result = new AggregatedMetric()
                    {
                        Count     = i,
                        Max       = i,
                        Min       = i,
                        Sum       = i,
                        Timestamp = 1602414000 + i
                    };

                    await redisDb.SortedSetAddAsync("test2", JsonConvert.SerializeObject(result), result.Timestamp);

                    if (i % 10000 == 0)
                    {
                        stopwatch.Stop();
                        Console.WriteLine($"Took: {i}  -  {stopwatch.ElapsedMilliseconds} ms.");
                        stopwatch = Stopwatch.StartNew();
                    }

                    //await HandleRequest("Metric_" + 1, i);
                    //await HandleRequest("Metric_" + 2, i);
                    //await HandleRequest("Metric_" + 3, i);
                    //await HandleRequest("Metric_" + 4, i);
                    //await HandleRequest("Metric_" + 5, i);
                    //await HandleRequest("Metric_" + 6, i);
                }
                catch (Exception ex)
                { }
            }

            //Task.WaitAll(consumerTask, consumerTask2);
        }