private static void Log(StringBuilder builder, Metric metric, List<object> metricValues)
 {
     if (metricValues == null || metricValues.Count == 0)
         LogHelper(builder, metric);
     else
         LogHelper(builder, metric, metricValues.ToArray());
 }

        public async void RestClient_posts_metrics()
        {
            var metricName = GetUniqueMetricName();

            var dataPoint = new DataPoint(DateTime.UtcNow.MillisecondsSinceEpoch(), 5L);

            var metric = new Metric(metricName)
                .AddTag("route_id", "1")
                .AddDataPoint(dataPoint);

            await _client.AddMetricsAsync(new[] {metric});

            var query = new QueryBuilder()
                .SetStart(TimeSpan.FromSeconds(5))
                .AddQueryMetric(new QueryMetric(metricName));

            Thread.Sleep(TimeSpan.FromSeconds(2));

            var response = await _client.QueryMetricsAsync(query);

            response.Queries.Should().HaveCount(1);
            response.Queries[0].SampleSize.Should().Be(1);
            response.Queries[0].Results.Should().HaveCount(1);
            response.Queries[0].Results[0].DataPoints.Single().ShouldBeEquivalentTo(dataPoint);
        }

        /// <summary>
        ///		Create a new <see cref="PerformanceCounterMonitor"/> actor.
        /// </summary>
        /// <param name="seriesName">
        ///		The name of the data series that tracks the performance counter's value.
        /// </param>
        /// <param name="performanceCounterFactory">
        ///		A factory delegate that creates the <see cref="PerformanceCounter"/> to monitor.
        /// </param>
        public PerformanceCounterMonitor(string seriesName, Func<PerformanceCounter> performanceCounterFactory)
        {
            if (String.IsNullOrWhiteSpace(seriesName))
                throw new ArgumentException("Argument cannot be null, empty, or entirely componsed of whitespace: 'seriesName'.", nameof(seriesName));

            if (performanceCounterFactory == null)
                throw new ArgumentNullException(nameof(performanceCounterFactory));

            _seriesName = seriesName;
            _performanceCounterFactory = performanceCounterFactory;
            _cancelPublishing = new Cancelable(Context.System.Scheduler);

            Receive<GatherMetrics>(_ =>
            {
                Metric metric = new Metric(
                    _seriesName,
                    _performanceCounter.NextValue()
                );
                foreach (IActorRef subscriber in _subscribers)
                    subscriber.Tell(metric);
            });
            Receive<SubscribePerformanceCounter>(request =>
            {
                _subscribers.Add(request.Subscriber);
            });
            Receive<UnsubscribePerformanceCounter>(request =>
            {
                _subscribers.Remove(request.Subscriber);
            });
        }

        public async void QueryMetricsAsync_uses_sum_aggregator()
        {
            var metricName = GetUniqueMetricName();

            var time = DateTime.UtcNow.MillisecondsSinceEpoch();

            var dataPoint = new DataPoint(time, 10L);
            var dataPoint2 = new DataPoint(time + 1, 30L);

            var metric = new Metric(metricName)
                .AddTag("route_id", "1")
                .AddDataPoint(dataPoint2)
                .AddDataPoint(dataPoint);

            await _client.AddMetricsAsync(new[] { metric });

            var queryMetric = new QueryMetric(metricName)
                .AddAggregator(new SumAggregator(1, TimeUnit.Minutes));

            var query = new QueryBuilder()
                .SetStart(TimeSpan.FromSeconds(10))
                .AddQueryMetric(queryMetric);

            Thread.Sleep(TimeSpan.FromSeconds(2));

            var response = await _client.QueryMetricsAsync(query);

            response.Queries.Should().HaveCount(1);
            response.Queries[0].Results.Should().HaveCount(1);
            response.Queries[0].Results[0].DataPoints.Single().Value.Should().Be(40L);
        }

 public async Task Publish(Metric[] metrics)
 {
     foreach (var metric in metrics)
     {
         Publish(metric);
     }
 }

        public override void ViewDidLoad ()
        {
            base.ViewDidLoad ();

            AddPullToRefresh ();

            // add the nav button.
            UIBarButtonItem addButton = new UIBarButtonItem (UIBarButtonSystemItem.Add);
            addButton.Clicked += async (sender, e) => {

                var addController = new AddCheckinViewController();
                this.NavigationController.PushViewController(addController,true);
                _dataSource.Clear();

                var result = await Buddy.RecordMetricAsync("adding_checkin", null, TimeSpan.FromDays(1));

                if (result.IsSuccess) {
                    _timedMetric = result.Value;
                }
            };

            this.NavigationItem.RightBarButtonItem = addButton;

            UIBarButtonItem logoutButton = new UIBarButtonItem ("Logout", UIBarButtonItemStyle.Plain, 
                async (s, e) => {
                    await Buddy.LogoutUserAsync();
                });

            this.NavigationItem.LeftBarButtonItem = logoutButton;

            _dataSource = new CheckinDataSource (this);
            this.checkinTable.Source = _dataSource;
        }

        public bool IsMetricMatch(Metric metric)
        {
            if (metric == null)
                return false;

            return this.typeCheck.IsMatch(metric.Type)
                && this.backend.SupportedTypes.Contains(metric.Type, StringComparer.OrdinalIgnoreCase);
        }

 public TracerFactory(string metricName, string name, string transactionNamingPriority, Metric metric)
     : this()
 {
     this.Name = name;
     this.TransactionNamingPriority = transactionNamingPriority;
     this.MetricName = metricName;
     this.Metric = metric;
 }

 public static Action<StatrContext> IsRouted(Metric metric)
 {
     return context =>
     {
         var router = context.Container.Resolve<IMetricRouter>();
         router.Route(metric);
     };
 }

 public void NotifyMetric(Metric metric)
 {
     var handler = MetricReceived;
     if (handler != null)
     {
         handler(this, new MetricEventArgs(metric));
     }
 }

 public InstrumentationTarget(IMethodDetails target, string metricName, string name, string transactionNamingPriority, Metric metric)
 {
     this.Target = target;
     this.MetricName = metricName;
     this.Name = name;
     this.TransactionNamingPriority = transactionNamingPriority;
     this.Metric = metric;
 }

 public bool TryAppend(Metric metric, Encoding encoding)
 {
     try {
         position += metric.GetBytes(encoding, bytes, position);
         return true;
     } catch(ArgumentException) {
         return false;
     }
 }

        public InstrumentAttribute(string metricName, string name, string transactionNamingPriority, Metric metric)
        {
            this.Scopes = InstrumentationScopes.All;

            this.Name = name;
            this.TransactionNamingPriority = transactionNamingPriority;
            this.MetricName = metricName;
            this.Metric = metric;
        }

		public void parsing(string input, string name, string value, MetricType type) {
			var result = new Metric();
			Check.That(
				() => Metric.TryParse(input, out result),
				() => result.Name == name,
				() => result.Value.ToString() == value,
				() => result.Value.Type == type
			);
		}

        public Timer(
            Metric.Client.ITimingCompletionRecorder timingCompletionRecorder,
            string key)
        {
            this.c_timingCompletionRecorder = timingCompletionRecorder;
            this.c_key = key;

            this.c_stopWatch = Stopwatch.StartNew();
        }

        public Metric Parse(string block)
        {
            var metric = new Metric {
                Name = ExtractName(block),
                Value = resultCounter.Matches(block).Count,
                Warning = block.Contains("<h3>Warning:"),
                Error = block.Contains("<h3>Error:")
            };

            return metric;
        }

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

            return new AggregatedMetric
            {
                LastValue = countMetric.Value,
                NumMetrics = ++original.NumMetrics,
                Value = original.Value + countMetric.Value
            };
        }

 public static void SendMetric(Metric metric, object metricObject)
 {
     try
     {
         AnalyticsSoapClient client = new AnalyticsSoapClient();
         client.UpdateAnalyticAsync(getGuid(), metric.ToString(), metricObject.ToString());
     }
     catch (Exception e)
     {
         Debug.WriteLine(e.StackTrace);
     }
 }

        public void Submit(Metric metric, string metricsPrefix)
        {
            if (this.disposed)
                throw new ObjectDisposedException(typeof(StatsDBackend).Name);

            if (!supportedTypes.Contains(metric.Type, StringComparer.OrdinalIgnoreCase))
                throw new ArgumentException("Metric type not supported.", "metric");

            this.graphiteChannel.Report(
                Helper.BuildKey(metric.Key, metricsPrefix),
                (int)metric.Value);
        }

        public void ShouldCallFormatterOnceWhenPassedOneStatistic()
        {
            var statistics = new Metric[] {
                new Metric { Name = "Test Metric" }
            };

            var builder = new TeamCityInfoBuilder(_formatterMock.Object);

            builder.AddStatistics(statistics);

            _formatterMock.Verify(m => m.Format(It.IsAny<string>()), Times.Once());
        }