public async Task SendMetrics_WhenInvoked_CompletesSuccessfully()
        {
            var metricsBucket = new ThreadSafeMetricsBucket();

            metricsBucket.RegisterCount("Demo123", true);
            metricsBucket.RegisterCount("Demo123", false);

            var result = await Client.SendMetrics(metricsBucket, CancellationToken.None);

            Assert.True(result);

            // Check result:
            // http://unleash.herokuapp.com/#/features/view/Demo123
            // http://unleash.herokuapp.com/api/admin/metrics/feature-toggles
        }
        public async Task SendMetrics_Success()
        {
            var metricsBucket = new ThreadSafeMetricsBucket();

            metricsBucket.RegisterCount("Demo123", true);
            metricsBucket.RegisterCount("Demo123", false);

            var result = await api.SendMetrics(metricsBucket, CancellationToken.None);

            result.Should().Be(true);

            // Check result:
            // http://unleash.herokuapp.com/#/features/view/Demo123
            // http://unleash.herokuapp.com/api/admin/metrics/feature-toggles
        }
示例#3
0
        public void RegisterCount_WhenInvokedFromMultipleThreadsAndCheckedIncrementally_BehavesPredictably(int maxDegreeOfParallelism, long totalRegistrations, int featureToggleCount, double breakPercent)
        {
            var metricsBucket = new ThreadSafeMetricsBucket();

            var options = new ParallelOptions
            {
                MaxDegreeOfParallelism = maxDegreeOfParallelism
            };

            var breaks = totalRegistrations * breakPercent;

            var toggleCounter = 0L;
            var recordedTasks = 0L;
            var exceptions    = new ConcurrentBag <Exception>();
            var result        = Parallel.For(1, totalRegistrations + 1, options, state =>
            {
                try
                {
                    Interlocked.Increment(ref recordedTasks);

                    var toggleName = (state % featureToggleCount).ToString();
                    var active     = DateTime.Now.Ticks % 2 == 0;

                    metricsBucket.RegisterCount(toggleName, active);

                    if (state % breaks == 0)
                    {
                        using (metricsBucket.StopCollectingMetrics(out var bucket))
                        {
                            var count = GetNumberOfRegistrations(bucket);

                            Interlocked.Add(ref toggleCounter, count);
                            _testOutputHelper.WriteLine($"Locking bucket at #{state} with {toggleCounter} toggle registrations");
                        }
                    }
        public void SingleBucket_OneCountPerTask3()
        {
            var metricsBucket = new ThreadSafeMetricsBucket();

            var options = new ParallelOptions
            {
                MaxDegreeOfParallelism = 10,
            };

            var  totalTasks    = 1000000L;
            var  breaks        = totalTasks / 10;
            long toggleCounter = 0;
            long recordedTasks = 0;

            var result = Parallel.For(1, totalTasks + 1, options, state =>
            {
                Interlocked.Increment(ref recordedTasks);

                var toggleName = (state % 50).ToString();
                var active     = DateTime.Now.Ticks % 2 == 0;

                metricsBucket.RegisterCount(toggleName, active);

                if (state % breaks == 0)
                {
                    using (metricsBucket.StopCollectingMetrics(out var bucket))
                    {
                        var count = GetNumberOfRegistrations(bucket);

                        Interlocked.Add(ref toggleCounter, count);
                        Console.WriteLine($"Locking bucket at #{state} with {toggleCounter} toggle registrations");
                    }
                }
        public void SingleBucket_No_WriteOperations()
        {
            var metricsBucket = new ThreadSafeMetricsBucket();

            var options = new ParallelOptions
            {
                MaxDegreeOfParallelism = 50,
            };

            var totalTasks        = 1000000;
            var numFeatureToggles = 50;

            Parallel.For(0, totalTasks, options, state =>
            {
                var i         = (state % numFeatureToggles).ToString();
                var predicate = DateTime.Now.Ticks % 2 == 0;

                metricsBucket.RegisterCount(i, predicate);
            });

            using (metricsBucket.StopCollectingMetrics(out var bucket))
            {
                bucket.Toggles.Count.Should().Be(numFeatureToggles);

                // Should be cleared
                var count = GetNumberOfRegistrations(bucket);
                count.Should().Be(totalTasks);
            }
        }
示例#6
0
        public void RegisterCount_WhenInvokedFromMultipleThreadsAndCheckedAtCompletion_BehavesPredictably(int maxDegreeOfParallelism, int totalRegistrations, int featureToggleCount)
        {
            var metricsBucket = new ThreadSafeMetricsBucket();

            var options = new ParallelOptions
            {
                MaxDegreeOfParallelism = maxDegreeOfParallelism
            };

            var exceptions = new ConcurrentBag <Exception>();
            var result     = Parallel.For(0, totalRegistrations, options, state =>
            {
                try
                {
                    var toggleName = (state % featureToggleCount).ToString();
                    var active     = DateTime.Now.Ticks % 2 == 0;

                    metricsBucket.RegisterCount(toggleName, active);
                }
                catch (Exception exc)
                {
                    exceptions.Add(exc);
                }
            });

            if (exceptions.Count > 0)
            {
                throw new AggregateException(exceptions);
            }

            Assert.True(result.IsCompleted);

            using (metricsBucket.StopCollectingMetrics(out var bucket))
            {
                Assert.Equal(featureToggleCount, bucket.Toggles.Count);

                var actualRegistrations = GetNumberOfRegistrations(bucket);
                Assert.Equal(totalRegistrations, actualRegistrations);
            }
        }