Ejemplo n.º 1
0
    /// <summary>
    /// Initializes the telemetry client.
    /// </summary>
    public static void Initialize(IServiceProvider serviceProvider, string version, string telemetryKey)
    {
        if (_telemetry != null)
            throw new NotSupportedException("The telemetry client is already initialized");

        var dte = (DTE2)serviceProvider.GetService(typeof(DTE));

        _telemetry = new TelemetryClient();
        _telemetry.Context.Session.Id = Guid.NewGuid().ToString();
        _telemetry.Context.Device.Model = dte.Edition;
        _telemetry.InstrumentationKey = telemetryKey;
        _telemetry.Context.Component.Version = version;

        byte[] enc = Encoding.UTF8.GetBytes(Environment.UserName + Environment.MachineName);
        using (var crypto = new MD5CryptoServiceProvider())
        {
            byte[] hash = crypto.ComputeHash(enc);
            _telemetry.Context.User.Id = Convert.ToBase64String(hash);
        }

        _events = dte.Events.DTEEvents;
        _events.OnBeginShutdown += delegate { _telemetry.Flush(); };

        Enabled = true;
    }
Ejemplo n.º 2
0
        public static void Main(string[] args)
        {
            var config = new Configuration();
            var telemetry = new TelemetryClient();
            telemetry.InstrumentationKey = config.InstrumentationKey;
            telemetry.Context.Device.Id = Environment.MachineName;
            telemetry.Context.Session.Id = Guid.NewGuid().ToString();
            telemetry.Context.Location.Ip = Dns.GetHostEntryAsync(Dns.GetHostName())
                                                .Result
                                                .AddressList
                                                .FirstOrDefault(addr => addr.AddressFamily == AddressFamily.InterNetwork)
                                                .ToString();

            using (var amz = new AmazonSynchronizer(config, telemetry))
            {
                amz.WithInterval(TimeSpan.FromSeconds(1))
                    .StopWhen((obj) => false)
                    .Start(CancellationToken.None)
                    .Wait();
            }

            if (telemetry != null)
                telemetry.Flush();

            Console.WriteLine("Sync Server Stopped.Press any key to exit ...");
            Console.ReadKey();
        }
Ejemplo n.º 3
0
 public static void LogException(Exception ex, Dictionary <string, string> properties = null, Dictionary <string, double> metrics = null)
 {
     if (TelemetryEnabled)
     {
         telemetry.TrackException(ex, properties, metrics);
         telemetry.Flush();
     }
 }
Ejemplo n.º 4
0
        protected void Application_Start()
        { 
            // Read instrumentation key from azure web app settings
            string ikeyValue = Environment.GetEnvironmentVariable("APPINSIGHTS_INSTRUMENTATIONKEY");

            if (!string.IsNullOrEmpty(ikeyValue))
            {
                TelemetryConfiguration.Active.InstrumentationKey = ikeyValue;
            }

            try
            {

                AreaRegistration.RegisterAllAreas();

                GlobalConfiguration.Configure(WebApiConfig.Register);
                FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
                RouteConfig.RegisterRoutes(RouteTable.Routes);
                BundleConfig.RegisterBundles(BundleTable.Bundles);
                BindingConfig.RegisterGlobalBindings(ModelBinders.Binders, GlobalConfiguration.Configuration);
                FormatterConfig.RegisterFormatters(GlobalConfiguration.Configuration);

                ReleaseSettings.Settings.Options.PackageListingPath = Server.MapPath("~/Content/packages.json");
                ReleaseSettings.Settings.Initialize();

                PackageSettings.Settings.NugetListingPath = Server.MapPath("~/Content/nuget.json");
                PackageSettings.Settings.Initialize();

                TwitterSettings.Settings.Initialize();

                BuildSettings.Settings.Initialize();

                BlogSettings.Settings.Initialize();

                ContributorSettings.Settings.Options.ContributorListingPath = Server.MapPath("~/Content/committers.json");
                ContributorSettings.Settings.Initialize();
            }
            catch (Exception ex)
            {
                TelemetryClient client = new TelemetryClient();
                ExceptionTelemetry excTelemetry = new ExceptionTelemetry(ex);
                excTelemetry.HandledAt = ExceptionHandledAt.Unhandled;
                client.TrackException(excTelemetry);

                // this exception will terminate the process. Let's wait till telemetry will be delivered
                client.Flush();
                Thread.Sleep(1000);

                throw;
            }
        }
Ejemplo n.º 5
0
        private void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
        {
            if (ChatterBox.Client.Common.Settings.SignalingSettings.AppInsightsEnabled)
            {
                ExceptionTelemetry excTelemetry = new ExceptionTelemetry((Exception)e.Exception);
                excTelemetry.SeverityLevel = SeverityLevel.Critical;
                excTelemetry.HandledAt = ExceptionHandledAt.Unhandled;
                excTelemetry.Timestamp = System.DateTimeOffset.UtcNow;
                var telemetry = new TelemetryClient();
                telemetry.TrackException(excTelemetry);

                telemetry.Flush();
            }
        }
Ejemplo n.º 6
0
        public async void SaveArea()
        {
            var json = await Request.Content.ReadAsStringAsync();

            var telemetry = new Microsoft.ApplicationInsights.TelemetryClient();

            telemetry.TrackEvent("STH", new Dictionary <string, string> {
                { "body", json.Replace(@"\", "").TrimStart('"').TrimEnd('"') }
            });
            telemetry.Flush();
            var dbGeo        = JsonConvert.DeserializeObject <Polygon>(json.Replace(@"\", "").TrimStart('"').TrimEnd('"')).ToDbGeography();
            var sqlGeography = MakePolygonValid(dbGeo);

            sqlGeography = sqlGeography.Reduce(1);
            var newPolygon = DbGeography.FromBinary(sqlGeography.STAsBinary().Value);

            using (var context = new PttContext())
            {
                var intersectingAreas = context.CoveredAreas.Where(x => x.Geo.Intersects(newPolygon)).ToList();


                var user = UserHelper.GetUser(context, RequestContext);

                if (newPolygon.Length != null)
                {
                    user.Statistic.DistanceWalked += (double)newPolygon.Length;
                }


                foreach (var intersectingArea in intersectingAreas)
                {
                    if (intersectingArea.User == user)
                    {
                        intersectingArea.Geo = intersectingArea.Geo.Difference(newPolygon);
                    }
                }



                context.CoveredAreas.Add(new CoveredArea()
                {
                    User = user,
                    Geo  = newPolygon
                });

                context.SaveChanges();
            }
        }
        public static void Start()
        {
            if (CoreApp.DoNotTrack())
              {
            return;
              }

              Log.Debug("Insights - starting");

              try
              {
            var configuration = TelemetryConfiguration.Active;
            Assert.IsNotNull(configuration, "configuration");

            configuration.TelemetryChannel = new PersistenceChannel("Sitecore Instance Manager");
            configuration.InstrumentationKey = "1447f72f-2d39-401b-91ac-4d5c502e3359";

            var client = new TelemetryClient(configuration)
            {
              InstrumentationKey = "1447f72f-2d39-401b-91ac-4d5c502e3359"
            };

            Analytics.telemetryClient = client;
            try
            {
              // ReSharper disable PossibleNullReferenceException
              client.Context.Component.Version = string.IsNullOrEmpty(ApplicationManager.AppVersion) ? "0.0.0.0" : ApplicationManager.AppVersion;
              client.Context.Session.Id = Guid.NewGuid().ToString();
              client.Context.User.Id = Environment.MachineName + "\\" + Environment.UserName;
              client.Context.User.AccountId = CoreApp.GetCookie();
              client.Context.Device.OperatingSystem = Environment.OSVersion.ToString();
              // ReSharper restore PossibleNullReferenceException
              client.TrackEvent("Start");
              client.Flush();
            }
            catch (Exception ex)
            {
              client.TrackException(ex);
              Log.Error(ex, "Error in app insights");
            }
              }
              catch (Exception ex)
              {
            Log.Error(ex, "Error in app insights");
              }

              Log.Debug("Insights - started");
        }
Ejemplo n.º 8
0
        public static void TrackPackageNotFound(string id, string version, string logFileName)
        {
            if (!_initialized)
            {
                return;
            }

            var telemetryClient = new TelemetryClient();
            var telemetry = new EventTelemetry("PackageNotFound");
            telemetry.Properties.Add("PackageId", id);
            telemetry.Properties.Add("PackageVersion", version);
            telemetry.Properties.Add("LogFile", logFileName);

            telemetryClient.TrackEvent(telemetry);
            telemetryClient.Flush();
        }
        private static void GenerateUnobservedException(TelemetryClient client)
        {
            Task.Factory.StartNew(() => { throw new Exception(); });

            HardWork(TimeSpan.FromSeconds(5));

            // This forces exception to become unobserved
            GC.Collect(2, GCCollectionMode.Forced);
            GC.WaitForPendingFinalizers();

            HardWork(TimeSpan.FromSeconds(5));

            client.Flush();

            HardWork(TimeSpan.FromSeconds(5));
        }
Ejemplo n.º 10
0
        /// <summary>
        /// Initializes the telemetry client.
        /// </summary>
        public static void Initialize(DTE2 dte, string version, string telemetryKey)
        {
            if (_telemetry != null)
                throw new NotSupportedException("The telemetry client is already initialized");

            _telemetry = new TelemetryClient();
            _telemetry.Context.Session.Id = Guid.NewGuid().ToString();
            _telemetry.Context.User.Id = (Environment.UserName + Environment.MachineName).GetHashCode().ToString();
            _telemetry.Context.Device.Model = dte.Edition;
            _telemetry.InstrumentationKey = telemetryKey;
            _telemetry.Context.Component.Version = version;

            _events = dte.Events.DTEEvents;
            _events.OnBeginShutdown += delegate { _telemetry.Flush(); };

            Enabled = true;
        }
Ejemplo n.º 11
0
        public static void TrackMetric(string metricName, double value, string logFileName)
        {
            if (!_initialized)
            {
                return;
            }

            var telemetryClient = new TelemetryClient();
            var telemetry = new MetricTelemetry(metricName, value);

            if (!string.IsNullOrWhiteSpace(logFileName))
            {
                telemetry.Properties.Add("LogFile", logFileName);
            }

            telemetryClient.TrackMetric(telemetry);
            telemetryClient.Flush();
        }
Ejemplo n.º 12
0
        public static void TrackException(Exception exception, string logFileName = null)
        {
            if (!_initialized)
            {
                return;
            }

            var telemetryClient = new TelemetryClient();
            var telemetry = new ExceptionTelemetry(exception);

            if (!string.IsNullOrWhiteSpace(logFileName))
            {
                telemetry.Properties.Add("LogFile", logFileName);
            }

            telemetryClient.TrackException(telemetry);
            telemetryClient.Flush();
        }
Ejemplo n.º 13
0
        public async Task <FeatureCollection> GetPolysInArea()
        {
            string json = await Request.Content.ReadAsStringAsync();

            var telemetry = new Microsoft.ApplicationInsights.TelemetryClient();

            telemetry.TrackEvent("STH", new Dictionary <string, string> {
                { "body", json.Replace(@"\", "").TrimStart('"').TrimEnd('"') }
            });
            telemetry.Flush();

            var currentPostion = JsonConvert.DeserializeObject <GeoJSON.Net.Geometry.Point>(json.Replace(@"\", "").TrimStart('"').TrimEnd('"'));

            var currentPositionDbGeography = currentPostion.ToDbGeography();

            var result = new FeatureCollection();

            using (var context = new PttContext())
            {
                foreach (var nearArea in context.CoveredAreas.Where(
                             x => x.Geo.Distance(currentPositionDbGeography) < 10000))
                {
                    result.Features.Add(new Feature(nearArea.Geo.ToGeoJSONGeometry()));
                }

                var firstGeo = context.CoveredAreas.First(x => x.Id == 3).Geo;


                var y = context.CoveredAreas.Where(x => x.Geo.Intersects(firstGeo)).ToList();

                foreach (var intersectingArea in y)
                {
                    intersectingArea.Geo = intersectingArea.Geo.Difference(firstGeo);
                }


                telemetry.TrackEvent("ResultCount", new Dictionary <string, string> {
                    { "xxxxx", result.Features.Count.ToString() }
                });
                return(result);
            }
        }
    public static void Start()
    {
      if (string.IsNullOrEmpty(ApplicationManager.AppVersion) || EnvironmentHelper.DoNotTrack())
      {
        return;
      }

      Log.Debug("Insights - starting");

      try
      {
        var tc = new TelemetryClient(new TelemetryConfiguration
        {
          InstrumentationKey = "1447f72f-2d39-401b-91ac-4d5c502e3359",
          TelemetryChannel = new PersistenceChannel()
        });

        client = tc;
        try
        {
          tc.Context.Session.Id = Guid.NewGuid().ToString();
          tc.Context.User.Id = Environment.MachineName + "\\" + Environment.UserName;
          tc.Context.User.AccountId = EnvironmentHelper.GetCookie();
          tc.Context.Device.OperatingSystem = Environment.OSVersion.ToString();
          tc.TrackEvent("Start");
          tc.Flush();
        }
        catch (Exception ex)
        {
          tc.TrackException(ex);
          Log.Error(ex, "Error in app insights");
        }
      }
      catch (Exception ex)
      {
        Log.Error(ex, "Error in app insights");
      }

      Log.Debug("Insights - started");
    }
        /// <summary>
        /// This is the entry point of the service host process.
        /// </summary>
        private static void Main()
        {
            try
            {
                TelemetryClient = new TelemetryClient();
            }
            catch (Exception)
            {
                // ignored
            }
            try
            {
                // Create default garbage collection settings for all the actor types
                var actorGarbageCollectionSettings = new ActorGarbageCollectionSettings(300, 60);

                // This line registers your actor class with the Fabric Runtime.
                // The contents of your ServiceManifest.xml and ApplicationManifest.xml files
                // are automatically populated when you build this project.
                // For more information, see http://aka.ms/servicefabricactorsplatform

                ActorRuntime.RegisterActorAsync<DeviceActor>(
                   (context, actorType) => new DeviceActorService(context, actorType, () => new DeviceActor(), null, new ActorServiceSettings
                   {
                       ActorGarbageCollectionSettings = actorGarbageCollectionSettings
                   })).GetAwaiter().GetResult();

                Thread.Sleep(Timeout.Infinite);
            }
            catch (Exception e)
            {
                TelemetryClient.TrackException(e);
                ActorEventSource.Current.ActorHostInitializationFailed(e);
                throw;
            }
            finally
            {
                TelemetryClient.Flush();
            }
        }
Ejemplo n.º 16
0
    static void Main()
    {
      Console.WriteLine("Hello, this is a trace");

      try
      {
        var eventHubString =
          ConfigurationManager.ConnectionStrings["EventHubConnection"];

        var eventHubName =
          ConfigurationManager.ConnectionStrings["EventHubName"];

        var appInsightsKey =
          ConfigurationManager.ConnectionStrings["AppInsightsKey"];

        var nsm = NamespaceManager.CreateFromConnectionString(eventHubString.ConnectionString);

        var hub = nsm.GetEventHub(eventHubName.ConnectionString);

        TelemetryClient appInsights = new TelemetryClient();
        appInsights.InstrumentationKey = appInsightsKey.ConnectionString;
        var telemetryData = new EventTelemetry()
        {
          Name = "Event Hub Heartbeat",
        };
        telemetryData.Properties.Add("Status", hub.Status.ToString());
        appInsights.TrackEvent(telemetryData);
        appInsights.Flush();

        Console.Write($"Service status is at {hub.Status}");
      }
      catch
      {
        Console.WriteLine("Catch handler");
      }

      Console.WriteLine("We're done");
    }
Ejemplo n.º 17
0
        private static void TrackTelemetryOnIndexReopened(object sender, SegmentInfoEventArgs e)
        {
            var telemetryClient = new TelemetryClient();

            // track the index reopened event
            var eventTelemetry = new EventTelemetry("Index Reopened");
            eventTelemetry.Metrics.Add("Segment Count", e.Segments.Count());
            eventTelemetry.Metrics.Add("Segment Size (Sum)", e.Segments.Sum(s => s.NumDocs));

            telemetryClient.TrackEvent(eventTelemetry);


            foreach (var segment in e.Segments)
            {
                var metricTelemetry = new MetricTelemetry("Segment Size", segment.NumDocs);
                metricTelemetry.Properties.Add("Segment Name", segment.Name);

                telemetryClient.TrackMetric(metricTelemetry);
            }

            telemetryClient.Flush();
        }
Ejemplo n.º 18
0
        // Create a CSV file and save to Blob storage with the Headers required for our Azure Function processing
        // A new request telemetry is created
        // The request is part of the parent request (since)
        public void CreateBlob(string fileName)
        {
            ///////////////////////////////////////////////////
            // Grab existing 
            ///////////////////////////////////////////////////
            Microsoft.ApplicationInsights.TelemetryClient telemetryClient = new Microsoft.ApplicationInsights.TelemetryClient();
            telemetryClient.Context.User.AuthenticatedUserId = "*****@*****.**";

            string traceoperation = null;
            string traceparent = null;
            System.Console.WriteLine("telemetryClient.Context.Operation.Id: " + telemetryClient.Context.Operation.Id);
            System.Console.WriteLine("telemetryClient.Context.Session.Id: " + telemetryClient.Context.Session.Id);
            System.Console.WriteLine("telemetryClient.Context.Operation.ParentId: " + telemetryClient.Context.Operation.ParentId);

            Microsoft.ApplicationInsights.DataContracts.RequestTelemetry requestTelemetry = new Microsoft.ApplicationInsights.DataContracts.RequestTelemetry();
            requestTelemetry.Name = "Create Blob: " + fileName;
            //requestTelemetry.Source = requestContext.Replace("appId=",string.Empty);
            requestTelemetry.Timestamp = System.DateTimeOffset.Now;
            requestTelemetry.Context.Operation.Id = traceoperation;
            requestTelemetry.Context.Operation.ParentId = traceparent;
            requestTelemetry.Context.User.AuthenticatedUserId = "*****@*****.**";

            using (var requestBlock = telemetryClient.StartOperation<Microsoft.ApplicationInsights.DataContracts.RequestTelemetry>(requestTelemetry))
            {
                ///////////////////////////////////////////////////
                // Request Telemetry
                ///////////////////////////////////////////////////
                requestBlock.Telemetry.Context.User.AuthenticatedUserId = "*****@*****.**";

                if (!string.IsNullOrWhiteSpace(traceoperation))
                {
                    // Use the existing common operation id
                    requestBlock.Telemetry.Context.Operation.Id = traceoperation;
                    System.Console.WriteLine("[Use existing] traceoperation: " + traceoperation);
                }
                else
                {
                    // Set the traceoperation (we did not know it until now)
                    traceoperation = requestBlock.Telemetry.Context.Operation.Id;
                    System.Console.WriteLine("[Set the] traceoperation = requestBlock.Telemetry.Context.Operation.Id: " + traceoperation);
                }

                if (!string.IsNullOrWhiteSpace(traceparent))
                {
                    // Use the existing traceparent
                    requestBlock.Telemetry.Context.Operation.ParentId = traceparent;
                    System.Console.WriteLine("[Use existing] traceparent: " + traceparent);
                }
                else
                {
                    traceparent = requestBlock.Telemetry.Id;
                    System.Console.WriteLine("[Set the] traceparent = requestBlock.Telemetry.Id: " + traceparent);
                }
                // Store future parent id
                traceparent = requestBlock.Telemetry.Id;
                System.Console.WriteLine("traceparent = requestBlock.Telemetry.Id: " + traceparent);



                ///////////////////////////////////////////////////
                // Create Dependency for future Azure Function processing
                // NOTE: I trick it by giving a Start Time Offset of Now.AddSeconds(1), so it sorts correctly in the Azure Portal UI
                ///////////////////////////////////////////////////
                string operationName = "Dependency: Blob Event";
                // Set the target so it points to the "dependent" app insights account app id
                // string target = "03-disttrace-func-blob | cid-v1:676560d0-81fb-4e5b-bfdd-7da1ad11c866"
                string target = "03-disttrace-func-blob | cid-v1:" + System.Environment.GetEnvironmentVariable("ai_03_disttrace_web_app_appkey");
                string dependencyName = "Dependency Name: Azure Function Blob Trigger";
                Microsoft.ApplicationInsights.DataContracts.DependencyTelemetry dependencyTelemetry =
                   new Microsoft.ApplicationInsights.DataContracts.DependencyTelemetry(
                    operationName, target, dependencyName,
                    "02-disttrace-web-app", System.DateTimeOffset.Now.AddSeconds(1), System.TimeSpan.FromSeconds(2), "200", true);
                dependencyTelemetry.Context.Operation.Id = traceoperation;
                dependencyTelemetry.Context.Operation.ParentId = requestBlock.Telemetry.Id;
                // Store future parent id
                traceparent = dependencyTelemetry.Id;
                System.Console.WriteLine("traceparent = dependencyTelemetry.Id: " + traceparent);
                telemetryClient.TrackDependency(dependencyTelemetry);



                ///////////////////////////////////////////////////
                // Blob code
                ///////////////////////////////////////////////////
                string containerName = "appinsightstest";
                string storageConnectionString = System.Environment.GetEnvironmentVariable("ai_storage_key");
                CloudStorageAccount storageAccount = null;
                System.Console.WriteLine("storageConnectionString: " + storageConnectionString);

                CloudStorageAccount.TryParse(storageConnectionString, out storageAccount);

                System.Collections.Generic.List<string> list = new System.Collections.Generic.List<string>();

                list.Add("id,date");

                for (int i = 1; i <= 50000; i++)
                {
                    list.Add(i.ToString() + "," + string.Format("{0:MM/dd/yyyy}", System.DateTime.Now));
                }

                var text = string.Join("\n", list.ToArray());

                Microsoft.WindowsAzure.Storage.Blob.CloudBlobClient blobStorage = storageAccount.CreateCloudBlobClient();
                blobStorage.DefaultRequestOptions.RetryPolicy = new Microsoft.WindowsAzure.Storage.RetryPolicies.LinearRetry(System.TimeSpan.FromSeconds(1), 10);
                Microsoft.WindowsAzure.Storage.Blob.CloudBlobContainer container = blobStorage.GetContainerReference(containerName);
                container.CreateIfNotExistsAsync().Wait();

                Microsoft.WindowsAzure.Storage.Blob.CloudBlockBlob blob = container.GetBlockBlobReference(fileName);

                ///////////////////////////////////////////////////
                // Set the blob's meta data
                // We need the values from the dependency
                ///////////////////////////////////////////////////
                // Request-Context: appId=cid-v1:{The App Id of the current App Insights Account}
                string requestContext = "appId=cid-v1:" + System.Environment.GetEnvironmentVariable("ai_02_disttrace_web_app_appkey");
                System.Console.WriteLine("Blob Metadata -> requestContext: " + requestContext);
                blob.Metadata.Add("RequestContext", requestContext);

                // Request-Id / traceparent: {parent request/operation id} (e.g. the Track Dependency)
                System.Console.WriteLine("Blob Metadata -> RequestId: " + traceparent);
                blob.Metadata.Add("RequestId", traceparent);
                System.Console.WriteLine("Blob Metadata -> traceparent: " + traceparent);
                blob.Metadata.Add("traceparent", traceparent);

                // Traceoperation {common operation id} (e.g. same operation id for all requests in this telemetry pipeline)
                System.Console.WriteLine("Blob Metadata -> traceoperation: " + traceoperation);
                blob.Metadata.Add("traceoperation", traceoperation);


                using (System.IO.MemoryStream memoryStream = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(text)))
                {
                    blob.UploadFromStreamAsync(memoryStream).Wait();
                }

                requestTelemetry.ResponseCode = "200";
                requestTelemetry.Success = true;
                telemetryClient.StopOperation(requestBlock);
            } // using

            ///////////////////////////////////////////////////
            // For Debugging
            ///////////////////////////////////////////////////
            telemetryClient.Flush();

        } // Create Blob
Ejemplo n.º 19
0
        public static void TrackReportProcessed(string reportName, string packageId = null)
        {
            if (!_initialized)
            {
                return;
            }

            var telemetryClient = new TelemetryClient();
            var telemetry = new MetricTelemetry(reportName, 1);

            if (!string.IsNullOrWhiteSpace(packageId))
            {
                telemetry.Properties.Add("Package Id", packageId);
            }

            telemetryClient.TrackMetric(telemetry);
            telemetryClient.Flush();
        }
Ejemplo n.º 20
0
        public static void TrackSqlException(string eventName, SqlException sqlException, string logFileName, string dimension)
        {
            if (!_initialized)
            {
                return;
            }

            var telemetryClient = new TelemetryClient();
            var telemetry = new EventTelemetry(eventName);
            telemetry.Properties.Add("Dimension", dimension);
            if (!string.IsNullOrWhiteSpace(logFileName))
            {
                telemetry.Properties.Add("LogFile", logFileName);
            }

            telemetryClient.TrackEvent(telemetry);
            telemetryClient.Flush();

            TrackException(sqlException, logFileName);
        }
Ejemplo n.º 21
0
        public static void TrackRetrieveDimensionDuration(string dimension, long value, string logFileName)
        {
            if (!_initialized)
            {
                return;
            }

            var telemetryClient = new TelemetryClient();
            var telemetry = new MetricTelemetry("Retrieve Dimension duration (ms)", value);
            telemetry.Properties.Add("Dimension", dimension);
            if (!string.IsNullOrWhiteSpace(logFileName))
            {
                telemetry.Properties.Add("LogFile", logFileName);
            }

            telemetryClient.TrackMetric(telemetry);
            telemetryClient.Flush();
        }
Ejemplo n.º 22
0
        private static void ConfigureApplication(string instrumentationKey,
            TelemetryClient client, TelemetryConfiguration config, TelemetryInitializer initializer)
        {
            config.InstrumentationKey = instrumentationKey;
            config.TelemetryInitializers.Add(initializer);

            Application.ThreadException += (s, e) =>
            {
                client.TrackException(new ExceptionTelemetry(e.Exception)
                {
                    HandledAt = ExceptionHandledAt.Unhandled,
                    SeverityLevel = SeverityLevel.Critical,
                });

                throw e.Exception;
            };

            Application.ApplicationExit += (s, e) =>
            {
                client.Flush();
            };
        }
Ejemplo n.º 23
0
        public async Task Initialize()
        {
            try
            {
                telemetryClient = new TelemetryClient();
                telemetryClient.InstrumentationKey = "23694f6c-53c2-42e2-9427-b7e02cda9c6f";
                telemetryClient.Context.Component.Version = Process.GetCurrentProcess().MainModule.FileVersionInfo.FileVersion;
                telemetryClient.Context.Session.Id = Guid.NewGuid().ToString();
                telemetryClient.Context.Device.OperatingSystem = Environment.OSVersion.ToString();
                telemetryClient.TrackPageView("Home");
                telemetryClient.Flush();
            }
            catch (Exception ex)
            {
                Trace.TraceError("Couldn't initialize telemetry: " + ex);
            }
            
            // Check for updates
            await CheckForUpdates();
            
            SelectedMirrorProvider = MirrorProviders.First();
            
            apps = (await applicationEnumerator.GetInstalledApplications()).ToList();

            if (!apps.Any())
            {
                Trace.TraceWarning("No BitTorrent applications found.");
                return;
            }

            foreach (var result in apps)
            {
                Trace.TraceInformation("Found app {0} version {1} at {2}", result.Description, result.Version, result.InstallLocation);
            }

        }