C# TelemetryClient.TrackTrace方法代码示例

        public ActionResult Index()
        {
            var tc = new TelemetryClient();
            tc.TrackTrace("I made it to the home page", SeverityLevel.Error);

            return View();
        }

        // GET api/values/5
        public string Get(int id)
        {
            var client = new TelemetryClient();
            client.TrackTrace("trace");

            return "value";
        }

        public ActionResult Index()
        {
            ViewBag.Title = "Home Page";

            var client = new TelemetryClient();
            client.TrackTrace("trace");

            return View();
        }

        public async Task UpdateSettings(string trainArguments = null, float? initialExplorationEpsilon = null, bool? isExplorationEnabled = null)
        {
            var token = Request.Headers["Authorization"];
            if (token != ConfigurationManager.AppSettings[ApplicationMetadataStore.AKPassword])
                throw new UnauthorizedAccessException();

            var telemetry = new TelemetryClient();
            try
            {
                telemetry.TrackTrace($"UpdateSettings(trainArguments={trainArguments}, initialExplorationEpsilon={initialExplorationEpsilon}, isExplorationEnabled={isExplorationEnabled})");

                string azureStorageConnectionString = ConfigurationManager.AppSettings[ApplicationMetadataStore.AKConnectionString];
                var storageAccount = CloudStorageAccount.Parse(azureStorageConnectionString);
                var blobClient = storageAccount.CreateCloudBlobClient();
                var settingsBlobContainer = blobClient.GetContainerReference(ApplicationBlobConstants.SettingsContainerName);

                var blob = settingsBlobContainer.GetBlockBlobReference(ApplicationBlobConstants.LatestClientSettingsBlobName);
                ApplicationClientMetadata clientMeta;
                if (await blob.ExistsAsync())
                    clientMeta = JsonConvert.DeserializeObject<ApplicationClientMetadata>(await blob.DownloadTextAsync());
                else
                    clientMeta = new ApplicationClientMetadata();

                if (trainArguments != null)
                    clientMeta.TrainArguments = trainArguments;

                if (initialExplorationEpsilon != null)
                    clientMeta.InitialExplorationEpsilon = (float)initialExplorationEpsilon;

                if (isExplorationEnabled != null)
                    clientMeta.IsExplorationEnabled = (bool)isExplorationEnabled;

                await blob.UploadTextAsync(JsonConvert.SerializeObject(clientMeta));
            }
            catch (Exception e)
            {
                telemetry.TrackException(e);
            }
        }

        static void Main(string[] args)
        {
            if (args.Length == 1)
            {
                TelemetryClient client = new TelemetryClient(TelemetryConfiguration.Active);
                client.TrackTrace("One trace is sent to make sure that SDK is initialized.");

                string param = args[0];

                switch (param)
                {
                    case "unhandled" :
                        GenerateUnhandledException();
                        break;
                    case "unobserved" :
                        GenerateUnobservedException(client);
                        break;
                }
            }
            else
                throw new ArgumentException("One parameter is required");
        }

 /// <summary>
 /// Reports a log event to telemetry.
 /// </summary>
 /// <param name="eventName"></param>
 /// <param name="metric"></param>
 public void ReportLog(object component, string message, SeverityLevel level = SeverityLevel.Information)
 {
     TelemetryClient client = new TelemetryClient();
     client.TrackTrace($"[{component.GetType().Name}] {message}", level);
 }

        public void TrackWhenChannelIsNullWillThrowInvalidOperationException()
        {
            var config = new TelemetryConfiguration();
            config.InstrumentationKey = "Foo";
            var client = new TelemetryClient(config);

            Assert.Throws<InvalidOperationException>(() => client.TrackTrace("test trace"));
        }

        public void TrackUsesInstrumentationKeyFromConfigurationWhenTheInstrumenationKeyIsEmpty()
        {
            ITelemetry sentTelemetry = null;
            var channel = new StubTelemetryChannel { OnSend = telemetry => sentTelemetry = telemetry };
            var configuration = new TelemetryConfiguration { TelemetryChannel = channel };
            var client = new TelemetryClient(configuration);
            var observe = client.Context.InstrumentationKey;

            string expectedKey = Guid.NewGuid().ToString();
            configuration.InstrumentationKey = expectedKey;
            Assert.DoesNotThrow(() => client.TrackTrace("Test Message"));

            Assert.Equal(expectedKey, sentTelemetry.Context.InstrumentationKey);
        }

        public void TrackDoesNotInitializeInstrumentationKeyWhenItWasSetExplicitly()
        {
            var configuration = new TelemetryConfiguration { TelemetryChannel = new StubTelemetryChannel(), InstrumentationKey = Guid.NewGuid().ToString() };
            var client = new TelemetryClient(configuration);

            var expectedKey = Guid.NewGuid().ToString();
            client.Context.InstrumentationKey = expectedKey;
            client.TrackTrace("Test Message");

            Assert.Equal(expectedKey, client.Context.InstrumentationKey);
        }