Exemplo n.º 1
0
        /// <inheritdoc />
        public void AddProvider(string name, IMetricProvider provider)
        {
            Guard.NotNullOrWhitespace(nameof(name), name);
            Guard.NotNull(nameof(provider), provider);

            _providers.AddOrUpdate(name, provider, (currentName, currentProvider) => provider);
        }
Exemplo n.º 2
0
        static void Main(string[] args)
        {
            if (args.Length != 1)
            {
                Console.WriteLine("Usage ./MetricsDemo.exe {ArmId}");
                Console.WriteLine("For VM: ArmId format is /subscriptions/{subscriptionId}/resourceGroups/{RG}/providers/Microsoft.Compute/virtualMachines/{vmName}");
                Console.WriteLine("For Storage: ArmId format is /subscriptions/{subsriptionId}/resourcegroups/{RG}/providers/Microsoft.Storage/storageaccounts/{accountName}/services/{serviceType}");
                return;
            }
            IMetricProvider metricProvier = MetricProviderFactory.GetProvider();

            // Query  Metircs
            var resourceId = args[0];

            Console.WriteLine(metricProvier.GetMetricsDefinitions(resourceId, ""));
            var values = metricProvier.GetMetricsValues(resourceId, "").Result;

            foreach (var value in values)
            {
                Console.WriteLine(value);
            }
            Console.ReadLine();
        }
Exemplo n.º 3
0
 public void AddMetricProvider(IMetricProvider provider)
 {
     this.metricProviders.Add(provider);
 }
 public AccountProductMetricController(IMetricProvider <AccountProductModel> metricProvider,
                                       IAppSettings appSettings)
 {
     _metricProvider = metricProvider;
     _appSettings    = appSettings;
 }
Exemplo n.º 5
0
 public Analyzer(IMetricProvider metricProvider, string[] supportedFileTypesForAnalysis)
 {
     _metricsProvider = metricProvider;
     _supportedFileTypesForAnalysis = supportedFileTypesForAnalysis;
 }
 public static void SetDefaultMetrics(IMetricProvider logProvider)
 {
     _current = new MetricStore(logProvider);
 }
 public MetricStore(IMetricProvider provider)
 {
     _provider = provider;
 }
Exemplo n.º 8
0
 public AccountProductMetric(IMetricProvider <AccountProductModel> metricProviderService, IAppSettings appSettings)
 {
     _appSettings = appSettings;
     Field <ListGraphType <AccountProduct> >("accountProducts", resolve: context => metricProviderService.GetAll(_appSettings.AccountProductMetricEndpoint));
 }
Exemplo n.º 9
0
        public T Sum_MinCurrentMetricSum(T argument, Func <T, int, T> memberFormula, int startIndex, int endIndex, IMetricProvider <T> metricProvider)
        {
            // Все храним в LinkedList.

            LinkedList <KeyValuePair <int, T> > listPositive = new LinkedList <KeyValuePair <int, T> >();       // с положительными метриками
            LinkedList <KeyValuePair <int, T> > listNegative = new LinkedList <KeyValuePair <int, T> >();       // с отрицательными метриками
            LinkedList <KeyValuePair <int, T> > listZero     = new LinkedList <KeyValuePair <int, T> >();       // с нулевыми метриками

            IComparer <KeyValuePair <int, T> > comparer = new _ABS_INT_COMPARER().createKVPComparerOnKey <int, T>();

            // ---- добавляем в список -----

            if (startIndex >= endIndex)
            {
                for (int i = startIndex; i <= endIndex; i++)
                {
                    T   res = memberFormula(argument, i);
                    int m   = metricProvider.GetMetric(res);

                    if (m > 0)
                    {
                        listPositive.AddLast(new KeyValuePair <int, T>(m, res));
                    }
                    else if (m < 0)
                    {
                        listNegative.AddLast(new KeyValuePair <int, T>(m, res));
                    }
                    else
                    {
                        listZero.AddLast(new KeyValuePair <int, T>(0, res));
                    }
                }
            }
            else
            {
                for (int i = endIndex; i >= startIndex; i--)
                {
                    T   res = memberFormula(argument, i);
                    int m   = metricProvider.GetMetric(res);

                    if (m > 0)
                    {
                        listPositive.AddLast(new KeyValuePair <int, T>(m, res));
                    }
                    else if (m < 0)
                    {
                        listNegative.AddLast(new KeyValuePair <int, T>(m, res));
                    }
                    else
                    {
                        listZero.AddLast(new KeyValuePair <int, T>(0, res));
                    }
                }
            }

            // ------------------------------
            // Сортируем список по возрастающему абсолютному значению ключа.
            // TODO: сортировка должна выполняться быстрее.

            listPositive.InsertionSort(comparer);
            listNegative.InsertionSort(comparer);

            // нули сортировать не надо :)

            // ---------- А ВОТ ТЕПЕРЬ СУММАЦИЯ. Сначала все числа с нулевой метрикой - они не увеличат суммы.

            T    sum       = this.OperatorPlus(this.Zero, Sum_KeyValueSequence(listZero));
            long metricSum = 0;

            LinkedListNode <KeyValuePair <int, T> > analyzedNode;

            // ---------- Готово. Приступаем.

            while (listPositive.Count > 0 || listNegative.Count > 0)
            {
                #if DEBUG
                Console.WriteLine(Math.Abs(metricSum));
                #endif

                // Если кончился отрицательный список - ничем не поможешь.

                if (listNegative.Count == 0)
                {
                    return(this.OperatorPlus(sum, Sum_KeyValueSequence(listPositive)));
                }

                // Если кончился положительный - тоже

                else if (listPositive.Count == 0)
                {
                    return(this.OperatorPlus(sum, Sum_KeyValueSequence(listNegative)));
                }

                if (metricSum > 0)
                {
                    // Ищем ключ в отрицательном списке, чтобы максимально уменьшить абсолютное значение суммы.

                    analyzedNode = listNegative.First;

                    // Первое условие здесь - абсолютное значение
                    // ключа анализируемого узла меньше суммы метрик + абсолютное значение текущего отрицательного узла
                    // Остальные нет смысла проверять - там неоптимально.

                    while (Math.Abs(analyzedNode.Value.Key) <= metricSum && analyzedNode != null)
                    {
                        analyzedNode = analyzedNode.Next;
                    }

                    // Крайний случай - дошли до края.

                    if (analyzedNode == null)
                    {
                        // Одно из двух - или последний отрицательный, или первый положительный.
                        // В зависимости от того, что хуже.

                        long positiveKeySum = metricSum + listPositive.First.Value.Key;
                        long negativeKeySum = metricSum + listNegative.Last.Value.Key;

                        // Если прибавить отрицательное выгоднее.
                        if (Math.Abs(positiveKeySum) > Math.Abs(negativeKeySum))
                        {
                            metricSum = negativeKeySum;
                            sum       = this.OperatorPlus(sum, listNegative.Last.Value.Value);

                            listNegative.RemoveLast();
                        }
                        else
                        {
                            metricSum = positiveKeySum;
                            sum       = this.OperatorPlus(sum, listPositive.First.Value.Value);

                            listPositive.RemoveFirst();
                        }
                    }

                    // Еще один край - если это первый же узел.

                    if (analyzedNode == listNegative.First)
                    {
                        // Одно из двух - или первый отрицательный, или первый положительный.
                        // В зависимости от того, что хуже.

                        long positiveKeySum = metricSum + listPositive.First.Value.Key;
                        long negativeKeySum = metricSum + listNegative.First.Value.Key;

                        // Если прибавить отрицательное выгоднее.
                        if (Math.Abs(negativeKeySum) < Math.Abs(positiveKeySum))
                        {
                            metricSum = negativeKeySum;
                            sum       = this.OperatorPlus(sum, listNegative.First.Value.Value);

                            listNegative.RemoveFirst();
                        }
                        else
                        {
                            metricSum = positiveKeySum;
                            sum       = this.OperatorPlus(sum, listPositive.First.Value.Value);

                            listPositive.RemoveFirst();
                        }
                    }

                    // Иначе анализируем одно из трех.

                    else
                    {
                        long positiveKeySum  = metricSum + listPositive.First.Value.Key;
                        long negativeKeySum1 = metricSum + analyzedNode.Previous.Value.Key;
                        long negativeKeySum2 = metricSum + analyzedNode.Value.Key;

                        if (Math.Abs(negativeKeySum1) <= Math.Abs(negativeKeySum2) && Math.Abs(negativeKeySum1) <= Math.Abs(positiveKeySum))
                        {
                            metricSum = negativeKeySum1;
                            sum       = this.OperatorPlus(sum, analyzedNode.Previous.Value.Value);

                            listNegative.Remove(analyzedNode.Previous);
                        }
                        else if (Math.Abs(negativeKeySum2) <= Math.Abs(negativeKeySum1) && Math.Abs(negativeKeySum2) <= Math.Abs(positiveKeySum))
                        {
                            metricSum = negativeKeySum2;
                            sum       = this.OperatorPlus(sum, analyzedNode.Value.Value);

                            listNegative.Remove(analyzedNode);
                        }
                        else
                        {
                            metricSum = positiveKeySum;
                            sum       = this.OperatorPlus(sum, listPositive.First.Value.Value);

                            listPositive.RemoveFirst();
                        }
                    }
                }
                else if (metricSum < 0)     // ищем максимальный по модулю и не превосходящий текущего элемент
                {
                    // Ищем ключ в положительном списке, чтобы максимально уменьшить абсолютное значение суммы.

                    analyzedNode = listPositive.First;

                    // Первое условие здесь - абсолютное значение
                    // ключа анализируемого узла меньше суммы метрик + абсолютное значение текущего отрицательного узла
                    // Остальные нет смысла проверять - там неоптимально.

                    while (analyzedNode.Value.Key <= Math.Abs(metricSum) && analyzedNode != null)
                    {
                        analyzedNode = analyzedNode.Next;
                    }

                    // Крайний случай - дошли до края.

                    if (analyzedNode == null)
                    {
                        // Одно из двух - или последний положительный, или первый отрицательный.
                        // В зависимости от того, что хуже.

                        long positiveKeySum = metricSum + listPositive.Last.Value.Key;
                        long negativeKeySum = metricSum + listNegative.First.Value.Key;

                        // Если прибавить положительное выгоднее.
                        if (Math.Abs(positiveKeySum) < Math.Abs(negativeKeySum))
                        {
                            metricSum = positiveKeySum;
                            sum       = this.OperatorPlus(sum, listPositive.Last.Value.Value);

                            listPositive.RemoveLast();
                        }
                        else
                        {
                            metricSum = negativeKeySum;
                            sum       = this.OperatorPlus(sum, listNegative.First.Value.Value);

                            listNegative.RemoveFirst();
                        }
                    }

                    // Еще один край - если это первый же узел.

                    if (analyzedNode == listPositive.First)
                    {
                        // Одно из двух - или первый отрицательный, или первый положительный.
                        // В зависимости от того, что хуже.

                        long positiveKeySum = metricSum + listPositive.First.Value.Key;
                        long negativeKeySum = metricSum + listNegative.First.Value.Key;

                        // Если прибавить отрицательное выгоднее.
                        if (Math.Abs(positiveKeySum) > Math.Abs(negativeKeySum))
                        {
                            metricSum = negativeKeySum;
                            sum       = this.OperatorPlus(sum, listNegative.First.Value.Value);

                            listNegative.RemoveFirst();
                        }
                        else
                        {
                            metricSum = positiveKeySum;
                            sum       = this.OperatorPlus(sum, listPositive.First.Value.Value);

                            listPositive.RemoveFirst();
                        }
                    }

                    // Иначе анализируем одно из трех.

                    else
                    {
                        long negativeKeySum  = metricSum + listNegative.First.Value.Key;
                        long positiveKeySum1 = metricSum + analyzedNode.Previous.Value.Key;
                        long positiveKeySum2 = metricSum + analyzedNode.Value.Key;

                        if (Math.Abs(positiveKeySum1) <= Math.Abs(positiveKeySum2) && Math.Abs(positiveKeySum1) <= Math.Abs(negativeKeySum))
                        {
                            metricSum = positiveKeySum1;
                            sum       = this.OperatorPlus(sum, analyzedNode.Previous.Value.Value);

                            listPositive.Remove(analyzedNode.Previous);
                        }
                        else if (Math.Abs(positiveKeySum2) <= Math.Abs(positiveKeySum1) && Math.Abs(positiveKeySum2) <= Math.Abs(negativeKeySum))
                        {
                            metricSum = positiveKeySum2;
                            sum       = this.OperatorPlus(sum, analyzedNode.Value.Value);

                            listPositive.Remove(analyzedNode);
                        }
                        else
                        {
                            metricSum = negativeKeySum;
                            sum       = this.OperatorPlus(sum, listNegative.First.Value.Value);

                            listNegative.RemoveFirst();
                        }
                    }
                }
                else
                {
                    // сумма метрик равна нулю, уменьшать некуда. Можно не искать, а сразу добавлять.
                    // Смотрим, что хуже. Прибавить первое положительное или первое отрицательное.

                    if (listPositive.First.Value.Key < listNegative.First.Value.Key)
                    {
                        metricSum += listPositive.First.Value.Key;     // прибавляем к сумме.
                        sum        = this.OperatorPlus(sum, listPositive.First.Value.Value);

                        listPositive.RemoveFirst();
                    }
                    else
                    {
                        metricSum += listNegative.First.Value.Key;     // прибавляем к сумме.
                        sum        = this.OperatorPlus(sum, listNegative.First.Value.Value);

                        listNegative.RemoveFirst();
                    }
                }
            }

            return(sum);
        }
Exemplo n.º 10
0
 public T Sum_MinCurrentMetricSum(Func <int, T> memberFormula, int startIndex, int endIndex, IMetricProvider <T> metricProvider)
 {
     return(Sum_MinCurrentMetricSum(this.Zero, delegate(T arg, int index) { return memberFormula(index); }, startIndex, endIndex, metricProvider));
 }
Exemplo n.º 11
0
        // --------------------------------------
        // ------ By minimum current metric -----
        // --------------------------------------

        public T Sum_ByMinimumMetricSum(Func <int, T> memberFormula, int startIndex, int endIndex, IMetricProvider <T> metricProvider)
        {
            return(default(T));
        }
Exemplo n.º 12
0
        /// <summary>
        /// Performs the summation of sequence members according to their integer metric provided by a IMetricProvider object.
        /// The summation is performed starting with lowest metric and ending up with highest.
        /// Works slower than a simple sequential summation.
        ///
        /// Requires a general term formula dependent on both argument and integer index (<paramref name="memberFormula"/>) as well as the current function argument.
        /// </summary>
        /// <param name="startIndex">The inclusive beginning index of sequence summation.</param>
        /// <param name="endIndex">The inclusive ending index of sequence summation.</param>
        /// <param name="metricProvider">The metric mapping values of type <typeparamref name="T"/> to their integer metric.</param>
        /// <param name="memberFormula">The general term formula dependent on both argument and integer index.</param>
        /// <param name="argument">The current argument for the sequence.</param>
        /// <returns>The result of sequential summation of the sequence starting with index <paramref name="startIndex"/> and ending with index <paramref name="endIndex"/>, both inclusive.</returns>
        public T Sum_ByIncreasingMetric(T argument, Func <T, int, T> memberFormula, int startIndex, int endIndex, IMetricProvider <T> metricProvider)
        {
            IComparer <KeyValuePair <int, T> > comparer = Comparer <int> .Default.createKVPComparerOnKey <int, T>();

            IPriorityQueue <KeyValuePair <int, T> > queue = new BinaryHeap <KeyValuePair <int, T> >(comparer);

            if (startIndex >= endIndex)
            {
                for (int i = startIndex; i <= endIndex; i++)
                {
                    T res = memberFormula(argument, i);
                    queue.Insert(new KeyValuePair <int, T>(metricProvider.GetMetric(res), res));
                }
            }
            else
            {
                for (int i = endIndex; i >= startIndex; i--)
                {
                    T res = memberFormula(argument, i);
                    queue.Insert(new KeyValuePair <int, T>(metricProvider.GetMetric(res), res));
                }
            }

            T sum = this.Zero;

            while (!queue.IsEmpty)
            {
                KeyValuePair <int, T> kvp = queue.Pop();
                sum = this.OperatorPlus(sum, kvp.Value);
            }

            return(sum);
        }