public async Task TrackDependencyAsync(string dependencyType, string dependencyName, DateTimeOffset startTime, TimeSpan duration, bool success, int resultCode = 0, Exception exception = null)
        {
            try
            {
                var builder = HitBuilder.CreateTiming(dependencyType, dependencyName, duration, success.ToString());
                //  builder.set

                var dependencyToTrack = builder.Build();

                dependencyToTrack.Add("ResultCode", resultCode.ToString());

                if (exception != null)
                {
                    dependencyToTrack.Add("Exception message", exception.Message);
                    dependencyToTrack.Add("StackTrace", exception.StackTrace);

                    if (exception.InnerException != null)
                    {
                        dependencyToTrack.Add("Inner exception message", exception.InnerException.Message);
                        dependencyToTrack.Add("Inner exception stackTrace", exception.InnerException.StackTrace);
                    }
                }

                Tracker.Send(dependencyToTrack);
            }
            catch (Exception ex)
            {
                _ = TinyInsights.TrackErrorAsync(ex);
            }
        }
        public void TrackFeatureEnd(string feature)
        {
            string category;
            string eventAction;

            this.SplitFeatureName(feature, out category, out eventAction);
            TimeSpan?timing = null;

            if (this.featureTimings.ContainsKey(eventAction))
            {
                timing = DateTime.Now - this.featureTimings[eventAction];
                this.featureTimings.Remove(eventAction);
            }

            var unLoadTiming = HitBuilder.CreateTiming(category, eventAction, timing).Build();

            tracker.Send(unLoadTiming);
        }
        public void TrackFeatureStart(string feature)
        {
            // Measuring timings provides a native way to measure a period of time in Google Analytics.
            // This can be useful to measure resource load times, for example.
            //TimeSpan ts = TimeSpan.FromSeconds(2.2);
            string category;
            string eventAction;

            this.SplitFeatureName(feature, out category, out eventAction);
            if (!this.featureTimings.ContainsKey(eventAction))
            {
                this.featureTimings.Add(eventAction, DateTime.Now);
            }
            else
            {
                this.featureTimings[eventAction] = DateTime.Now;
            }

            var loadTiming = HitBuilder.CreateTiming(category, eventAction, TimeSpan.FromSeconds(0)).Build();

            tracker.Send(loadTiming);
        }
        public async Task SendTiming()
        {
            var hit = HitBuilder.CreateTiming("category", "variable", TimeSpan.FromSeconds(2), "label");

            await SendHitAsync(hit);
        }
 private void ButtonTiming_Click(object sender, RoutedEventArgs e)
 {
     App.Tracker.Send(HitBuilder.CreateTiming("someaction", "loadtime", TimeSpan.FromSeconds(2)).Build());
 }