private void ExtractAndPostMetric()

in WEB/Src/EventCounterCollector/EventCounterCollector/EventCounterListener.cs [154:270]
108 lines of code
21 McCabe index (conditional complexity)

        private void ExtractAndPostMetric(string eventSourceName, IDictionary<string, object> eventPayload)
        {
            try
            {
                MetricTelemetry metricTelemetry = new MetricTelemetry();
                bool calculateRate = false;
                double actualValue = 0.0;
                double actualInterval = 0.0;
                int actualCount = 0;
                string counterName = string.Empty;
                string counterDisplayName = string.Empty;
                string counterDisplayUnit = string.Empty;
                foreach (KeyValuePair<string, object> payload in eventPayload)
                {
                    var key = payload.Key;
                    if (key.Equals("Name", StringComparison.OrdinalIgnoreCase))
                    {
                        counterName = payload.Value.ToString();
                        if (!this.countersToCollect[eventSourceName].Contains(counterName))
                        {
                            EventCounterCollectorEventSource.Log.IgnoreEventWrittenAsCounterNotInConfiguredList(eventSourceName, counterName);
                            return;
                        }
                    }
                    else if (key.Equals("DisplayName", StringComparison.OrdinalIgnoreCase))
                    {
                        counterDisplayName = payload.Value.ToString();
                    }
                    else if (key.Equals("DisplayUnits", StringComparison.OrdinalIgnoreCase))
                    {
                        counterDisplayUnit = payload.Value.ToString();
                    }
                    else if (key.Equals("Mean", StringComparison.OrdinalIgnoreCase))
                    {
                        actualValue = Convert.ToDouble(payload.Value, CultureInfo.InvariantCulture);
                    }
                    else if (key.Equals("Increment", StringComparison.OrdinalIgnoreCase))
                    {
                        // Increment indicates we have to calculate rate.
                        actualValue = Convert.ToDouble(payload.Value, CultureInfo.InvariantCulture);
                        calculateRate = true;
                    }
                    else if (key.Equals("IntervalSec", StringComparison.OrdinalIgnoreCase))
                    {
                        // Even though we configure 60 sec, we parse the actual duration from here. It'll be very close to the configured interval of 60.
                        // If for some reason this value is 0, then we default to 60 sec.
                        actualInterval = Convert.ToDouble(payload.Value, CultureInfo.InvariantCulture);
                        if (actualInterval < this.refreshInternalInSecInt)
                        {
                            EventCounterCollectorEventSource.Log.EventCounterRefreshIntervalLessThanConfigured(actualInterval, this.refreshInternalInSecInt);
                        }
                    }
                    else if (key.Equals("Count", StringComparison.OrdinalIgnoreCase))
                    {
                        actualCount = Convert.ToInt32(payload.Value, CultureInfo.InvariantCulture);
                    }
                    else if (key.Equals("Metadata", StringComparison.OrdinalIgnoreCase))
                    {
                        var metadata = payload.Value.ToString();
                        if (!string.IsNullOrEmpty(metadata))
                        {
                            var keyValuePairStrings = metadata.Split(',');
                            foreach (var keyValuePairString in keyValuePairStrings)
                            {
                                var keyValuePair = keyValuePairString.Split(':');
                                if (!metricTelemetry.Properties.ContainsKey(keyValuePair[0]))
                                {
                                    metricTelemetry.Properties.Add(keyValuePair[0], keyValuePair[1]);
                                }
                            }
                        }
                    }
                }

                if (calculateRate)
                {
                    if (actualInterval > 0)
                    {
                        metricTelemetry.Sum = actualValue / actualInterval;
                    }
                    else
                    {
                        metricTelemetry.Sum = actualValue / this.refreshInternalInSecInt;
                        EventCounterCollectorEventSource.Log.EventCounterIntervalZero(metricTelemetry.Name);
                    }
                }
                else
                {
                    metricTelemetry.Sum = actualValue;
                }

                // DisplayName is the recommended name. We fallback to counterName is DisplayName not available.
                var name = string.IsNullOrEmpty(counterDisplayName) ? counterName : counterDisplayName;

                if (this.useEventSourceNameAsMetricsNamespace)
                {
                    metricTelemetry.Name = name;
                    metricTelemetry.MetricNamespace = eventSourceName;
                }
                else
                {
                    metricTelemetry.Name = eventSourceName + "|" + name;
                }

                if (!string.IsNullOrEmpty(counterDisplayUnit))
                {
                    metricTelemetry.Properties.Add("DisplayUnits", counterDisplayUnit);
                }

                metricTelemetry.Count = actualCount;
                this.telemetryClient.TrackMetric(metricTelemetry);
            }
            catch (Exception ex)
            {
                EventCounterCollectorEventSource.Log.EventCounterCollectorWarning("ExtractMetric", ex.Message);
            }
        }