public void UsesGetOrCreateSiteId() { var version = CreateUmbracoVersion(9, 3, 1); var siteIdentifierServiceMock = new Mock <ISiteIdentifierService>(); var usageInformationServiceMock = new Mock <IUsageInformationService>(); var sut = new TelemetryService( Mock.Of <IManifestParser>(), version, siteIdentifierServiceMock.Object, usageInformationServiceMock.Object, Mock.Of <IMetricsConsentService>()); Guid guid; sut.TryGetTelemetryReportData(out _); siteIdentifierServiceMock.Verify(x => x.TryGetOrCreateSiteIdentifier(out guid), Times.Once); }
public async Task DeletesUserAndAndCanRespsectEmailAllowedSetting(bool emailAllowed, bool deleteSuccess) { Config.RespectEmailContactSetting = true; User.EmailAllowed = emailAllowed; AccountManager.Setup(x => x.DeleteAccount(It.IsAny <User>(), It.IsAny <string>())).ReturnsAsync(deleteSuccess); var processed = await Target.HandleAsync(Message); Assert.True(processed); TelemetryService.Verify(x => x.TrackDeleteResult(Message.Source, deleteSuccess), Times.Once); MessageService.Verify( x => x.SendMessageAsync(It.IsAny <IEmailBuilder>(), It.IsAny <bool>(), It.IsAny <bool>()), Times.Exactly(emailAllowed ? 1 : 0)); TelemetryService.Verify(x => x.TrackEmailSent(It.IsAny <string>(), It.IsAny <bool>()), Times.Exactly(emailAllowed ? 1 : 0)); TelemetryService.Verify(x => x.TrackEmailBlocked(It.IsAny <string>()), Times.Exactly(emailAllowed ? 0 : 1)); }
public override d0 GetResponse() { try { // checks if (_telemetryRequest == null || _telemetryRequest.Token == null) { return(new d0 { Success = false, }); } var result = false; if (TokenService.IsValidToken(_telemetryRequest.Token)) { TelemetryService.UpdateData(_telemetryRequest); result = true; } // create response packet d0 responsePacket; using (var stream = new MemoryStream()) { var dataContractSerializer = new DataContractSerializer(typeof(TelemetryResponse)); dataContractSerializer.WriteObject(stream, new TelemetryResponse()); responsePacket = new d0 { Success = result }; } return(responsePacket); } catch (Exception e) { ConsoleLogger.Write(e.ToString(), ConsoleColor.Red); } return(new d0 { Success = false }); }
public void ReturnsSemanticVersionWithoutBuild() { var version = CreateUmbracoVersion(9, 1, 1, "-rc", "-ad2f4k2d"); var metricsConsentService = new Mock <IMetricsConsentService>(); metricsConsentService.Setup(x => x.GetConsentLevel()).Returns(TelemetryLevel.Detailed); var sut = new TelemetryService( Mock.Of <IManifestParser>(), version, CreateSiteIdentifierService(), Mock.Of <IUsageInformationService>(), metricsConsentService.Object); var result = sut.TryGetTelemetryReportData(out var telemetry); Assert.IsTrue(result); Assert.AreEqual("9.1.1-rc", telemetry.Version); }
public string RecordErrorForSubscriber(Subscription subscriber, Event @event, Exception exception) { var errorMessage = ConstructErrorMessage(subscriber, @event.Message, exception.InnerException?.Message ?? exception.Message); Console.WriteLine(errorMessage); var telemetryService = new TelemetryService(); telemetryService.LogTelemetry("0", "business-event", "subscription-error", new { Subscriber = subscriber, MessageHeader = @event.Message.Header, EventHeader = @event.Header, Exception = exception, Message = errorMessage }); return(errorMessage); }
public void OnlyParsesIfValidId(string guidString, bool shouldSucceed) { var globalSettings = CreateGlobalSettings(guidString); var version = CreateUmbracoVersion(9, 1, 1); var sut = new TelemetryService(globalSettings, Mock.Of <IManifestParser>(), version); var result = sut.TryGetTelemetryReportData(out var telemetry); Assert.AreEqual(shouldSucceed, result); if (shouldSucceed) { // When toString is called on a GUID it will to lower, so do the same to our guidString Assert.AreEqual(guidString.ToLower(), telemetry.Id.ToString()); } else { Assert.IsNull(telemetry); } }
public async Task AllowsEmptyObject() { var json = JsonConvert.SerializeObject(new Dictionary <string, string[]>()); CloudBlob .Setup(x => x.OpenReadAsync(It.IsAny <AccessCondition>())) .ReturnsAsync(() => new MemoryStream(Encoding.UTF8.GetBytes(json))); var output = await Target.ReadLatestIndexedAsync(); Assert.Empty(output.Result); Assert.Equal(ETag, output.AccessCondition.IfMatchETag); TelemetryService.Verify( x => x.TrackReadLatestIndexedOwners( /* packageIdCount: */ 0, It.IsAny <TimeSpan>()), Times.Once); }
public async Task AllowsEmptyObject() { var json = JsonConvert.SerializeObject(new Dictionary <string, string[]>()); CloudBlob .Setup(x => x.OpenReadAsync(It.IsAny <AccessCondition>())) .ReturnsAsync(() => new MemoryStream(Encoding.UTF8.GetBytes(json))); var output = await Target.ReadLatestIndexedAsync(AccessCondition.Object, StringCache); Assert.Empty(output.Data); Assert.Equal(ETag, output.Metadata.ETag); TelemetryService.Verify( x => x.TrackReadLatestIndexedPopularityTransfers( /*outgoingTransfers: */ 0, /*modified: */ true, It.IsAny <TimeSpan>()), Times.Once); }
public string RecordErrorForSubscriber(Subscription subscriber, Event @event, InvokeResponse response) { var errorMessage = ConstructErrorMessage(subscriber, @event.Message, $"{response.StatusCode + " " + response.FunctionError + " " + response.Payload }"); Console.WriteLine(errorMessage); var telemetryService = new TelemetryService(); telemetryService.LogTelemetry("0", "business-event", "subscription-error", new { Subscriber = subscriber, MessageHeader = @event.Message.Header, EventHeader = @event.Header, Response = response, Message = errorMessage }); return(errorMessage); }
public string RecordErrorForSubscriber(Subscription subscriber, Event @event, HttpResponseMessage response) { var errorMessage = ConstructErrorMessage(subscriber, @event.Message, $"{response.StatusCode + " " + response.ReasonPhrase + " " + response.Content.ReadAsStringAsync().Result }"); Console.WriteLine(errorMessage); var telemetryService = new TelemetryService(); telemetryService.LogTelemetry("0", "business-event", "subscription-error", new { Subscriber = subscriber, MessageHeader = @event.Message.Header, EventHeader = @event.Header, Response = response, Message = errorMessage }); return(errorMessage); }
public void FindsRemovedOwner() { var oldData = OwnersData("NuGet.Core: NuGet, Microsoft"); var newData = OwnersData("NuGet.Core: NuGet"); var changes = Target.CompareOwners(oldData, newData); var pair = Assert.Single(changes); Assert.Equal("NuGet.Core", pair.Key); Assert.Equal(new[] { "NuGet" }, pair.Value); TelemetryService.Verify( x => x.TrackOwnerSetComparison( /*oldCount: */ 1, /*newCount: */ 1, /*changeCount: */ 1, It.IsAny <TimeSpan>()), Times.Once); }
public void IgnoresCaseChanges() { OldData.AddTransfer("PackageA", "packageb"); OldData.AddTransfer("PackageA", "PackageC"); NewData.AddTransfer("packagea", "PACKAGEB"); NewData.AddTransfer("PackageA", "packageC"); var changes = Target.ComparePopularityTransfers(OldData, NewData); Assert.Empty(changes); TelemetryService.Verify( x => x.TrackPopularityTransfersSetComparison( /*oldCount: */ 1, /*newCount: */ 1, /*changeCount: */ 0, It.IsAny <TimeSpan>()), Times.Once); }
private void InitializeServices() { // register our configuration service and initialize it SimpleIoc.Default.Register <ConfigurationService>(); ConfigurationService configurationService = (ConfigurationService)SimpleIoc.Default.GetInstance <ConfigurationService>(); if (null != configurationService) { // run this synchronously AsyncHelper.RunSync(() => configurationService.Initialize()); } // register our localization service and initialize it SimpleIoc.Default.Register <LocalizationService>(); LocalizationService localizationService = (LocalizationService)SimpleIoc.Default.GetInstance <LocalizationService>(); if (null != localizationService) { // async here might lead to a race condition, but no signs so far //localizationService.Initialize(); AsyncHelper.RunSync(() => localizationService.Initialize()); } // initialize the telemetry service SimpleIoc.Default.Register <TelemetryService>(); TelemetryService telemetryService = (TelemetryService)SimpleIoc.Default.GetInstance <TelemetryService>(); if (null != telemetryService) { if (null != configurationService) { // DO NOT try to run this asynchronously; MetroLog hangs when invoked async //AsyncHelper.RunSync(() => telemetryService.Initialize(configurationService.Configuration.TelemetryKey)); telemetryService.Initialize(configurationService.Configuration.IsTelemetryEnabled, configurationService.Configuration.TelemetryKey); // log app start TelemetryService.Current?.LogTelemetryEvent(TelemetryEvents.StartApplication); } } }
public void FindsNoChanges() { var oldData = OwnersData( "NuGet.Core: NuGet, Microsoft", "NuGet.Versioning: NuGet, Microsoft"); var newData = OwnersData( "NuGet.Core: NuGet, Microsoft", "NuGet.Versioning: NuGet, Microsoft"); var changes = Target.CompareOwners(oldData, newData); Assert.Empty(changes); TelemetryService.Verify( x => x.TrackOwnerSetComparison( /*oldCount: */ 2, /*newCount: */ 2, /*changeCount: */ 0, It.IsAny <TimeSpan>()), Times.Once); }
public async Task SerializesVersionsSortedOrder() { var newData = new PopularityTransferData(); newData.AddTransfer("PackageB", "PackageA"); newData.AddTransfer("PackageB", "PackageB"); newData.AddTransfer("PackageA", "PackageC"); newData.AddTransfer("PackageA", "packagec"); newData.AddTransfer("PackageA", "packageC"); newData.AddTransfer("PackageA", "PackageB"); newData.AddTransfer("PackageC", "PackageZ"); await Target.ReplaceLatestIndexedAsync(newData, AccessCondition.Object); // Pretty-ify the JSON to make the assertion clearer. var json = Assert.Single(SavedStrings); json = JsonConvert.DeserializeObject <JObject>(json).ToString(); Assert.Equal(@"{ ""PackageA"": [ ""PackageB"", ""PackageC"" ], ""PackageB"": [ ""PackageA"", ""PackageB"" ], ""PackageC"": [ ""PackageZ"" ] }", json); TelemetryService.Verify( x => x.TrackReplaceLatestIndexedPopularityTransfers( /*outgoingTransfers: */ 3), Times.Once); ReplaceLatestIndexedPopularityTransfersDurationMetric.Verify(x => x.Dispose(), Times.Once); }
public void FindsRemovedToPackage() { OldData.AddTransfer("PackageA", "PackageB"); OldData.AddTransfer("PackageA", "PackageC"); NewData.AddTransfer("PackageA", "PackageB"); var changes = Target.ComparePopularityTransfers(OldData, NewData); var pair = Assert.Single(changes); Assert.Equal("PackageA", pair.Key); Assert.Equal(new[] { "PackageB" }, pair.Value); TelemetryService.Verify( x => x.TrackPopularityTransfersSetComparison( /*oldCount: */ 1, /*newCount: */ 1, /*changeCount: */ 1, It.IsAny <TimeSpan>()), Times.Once); }
public async Task ReadsPopularityTransfers() { var json = JsonConvert.SerializeObject(new Dictionary <string, string[]> { { "windowsazure.servicebus", new[] { "Azure.Messaging.ServiceBus" } }, { "WindowsAzure.Storage", new[] { "Azure.Storage.Blobs", "Azure.Storage.Queues" } }, { "ZDuplicate", new[] { "packageA", "packagea", "PACKAGEA", "packageB" } }, }); CloudBlob .Setup(x => x.OpenReadAsync(It.IsAny <AccessCondition>())) .ReturnsAsync(() => new MemoryStream(Encoding.UTF8.GetBytes(json))); var output = await Target.ReadLatestIndexedAsync(AccessCondition.Object, StringCache); Assert.Equal(3, output.Data.Count); Assert.Equal(new[] { "windowsazure.servicebus", "WindowsAzure.Storage", "ZDuplicate" }, output.Data.Keys.ToArray()); Assert.Equal(new[] { "Azure.Messaging.ServiceBus" }, output.Data["windowsazure.servicebus"].ToArray()); Assert.Equal(new[] { "Azure.Storage.Blobs", "Azure.Storage.Queues" }, output.Data["WindowsAzure.Storage"].ToArray()); Assert.Equal(new[] { "packageA", "packageB" }, output.Data["ZDuplicate"].ToArray()); Assert.Equal(ETag, output.Metadata.ETag); CloudBlobContainer.Verify(x => x.GetBlobReference("popularity-transfers/popularity-transfers.v1.json"), Times.Once); TelemetryService.Verify( x => x.TrackReadLatestIndexedPopularityTransfers( /*outgoingTransfers: */ 3, /*modified: */ true, It.IsAny <TimeSpan>()), Times.Once); }
public void RespectsAllowPackageTelemetry() { var globalSettings = CreateGlobalSettings(); var version = CreateUmbracoVersion(9, 1, 1); PackageManifest[] manifests = { new () { PackageName = "DoNotTrack", AllowPackageTelemetry = false }, new () { PackageName = "TrackingAllowed", AllowPackageTelemetry = true } }; var manifestParser = CreateManifestParser(manifests); var sut = new TelemetryService(globalSettings, manifestParser, version); var success = sut.TryGetTelemetryReportData(out var telemetry); Assert.IsTrue(success); Assert.Multiple(() => { Assert.AreEqual(1, telemetry.Packages.Count()); Assert.AreEqual("TrackingAllowed", telemetry.Packages.First().Name); }); }
public void DetectsDecreaseDueToMissingId() { var oldData = new DownloadData(); oldData.SetDownloadCount(IdA, V1, 7); oldData.SetDownloadCount(IdA, V2, 1); oldData.SetDownloadCount(IdB, V1, 1); var newData = new DownloadData(); newData.SetDownloadCount(IdB, V1, 1); var delta = Target.Compare(oldData, newData); Assert.Equal(KeyValuePair.Create(IdA, 0L), Assert.Single(delta)); VerifyDecreaseTelemetry(Times.Exactly(2)); TelemetryService.Verify( x => x.TrackDownloadCountDecrease( IdA, V1, true, true, 7, false, false, 0), Times.Once); TelemetryService.Verify( x => x.TrackDownloadCountDecrease( IdA, V2, true, true, 1, false, false, 0), Times.Once); }
private async void RefreshUI() { switch (MusicPlayerState) { case MediaPlaybackState.Playing: TelemetryService.WriteEvent("MusicPlaying"); MusicPlayerStatusText = MusicPlayerStatusPlayingText; break; case MediaPlaybackState.Paused: MusicPlayerStatusText = MusicPlayerStatusPausedText; break; case MediaPlaybackState.Opening: MusicPlayerStatusText = MusicPlayerStatusLoadingText; break; case MediaPlaybackState.Buffering: MusicPlayerStatusText = MusicPlayerStatusLoadingText; break; default: MusicPlayerStatusText = MusicPlayerStatusDefaultText; break; } if (SelectedMediaIndex >= 0 && SelectedMediaIndex < MediaFileCollection.Count) { _currentFile = MediaFileCollection.ElementAt(SelectedMediaIndex); await RefreshMediaInfoAsync(_currentFile); } else { SongTitleText = string.Empty; SongArtistText = string.Empty; SongThumbnailSource = DefaultPicture; } }
public TelemetryServiceTest() { _dateTimeServiceStub = new DateTimeServiceStub { Now = DateTime.Now }; _httpContext = new DefaultHttpContext { Request = { Method = "GET", Protocol = "http", Host = new HostString("localhost", 80), Path = PathString.FromUriComponent("/budgets/06/2016") } }; _exceptionRepository = new InMemoryRepository <TelemetryException>(); _eventRepository = new InMemoryRepository <TelemetryEvent>(); _timingRepository = new InMemoryRepository <TelemetryTiming>(); _telemetryService = new TelemetryService(_exceptionRepository, _eventRepository, _timingRepository, _dateTimeServiceStub); }
public async Task AllowsMissingBlob() { CloudBlob .Setup(x => x.OpenReadAsync(It.IsAny <AccessCondition>())) .ThrowsAsync(new StorageException( new RequestResult { HttpStatusCode = (int)HttpStatusCode.NotFound, }, message: "Not found.", inner: null)); var output = await Target.ReadLatestIndexedAsync(); Assert.Empty(output.Result); Assert.Equal("*", output.AccessCondition.IfNoneMatchETag); TelemetryService.Verify( x => x.TrackReadLatestIndexedOwners( /* packageIdCount: */ 0, It.IsAny <TimeSpan>()), Times.Once); }
private void UpdateManager_OnUpdateOperationError(object sender, StorePackageUpdateStateEventArgs e) { switch (e.State) { case StorePackageUpdateState.ErrorLowBattery: AppService.DisplayDialog(AppUpdateDialogHeaderText, BatteryLowErrorText); TelemetryService.WriteEvent("AppUpdateError", new { StorePackageUpdateState = StorePackageUpdateState.ErrorLowBattery }); break; case StorePackageUpdateState.ErrorWiFiRecommended: AppService.DisplayDialog(AppUpdateDialogHeaderText, ConnectionErrorText); TelemetryService.WriteEvent("AppUpdateError", new { StorePackageUpdateState = StorePackageUpdateState.ErrorWiFiRecommended }); break; case StorePackageUpdateState.ErrorWiFiRequired: AppService.DisplayDialog(AppUpdateDialogHeaderText, ConnectionErrorText); TelemetryService.WriteEvent("AppUpdateError", new { StorePackageUpdateState = StorePackageUpdateState.ErrorWiFiRequired }); break; case StorePackageUpdateState.OtherError: AppService.DisplayDialog(AppUpdateDialogHeaderText, UnknownErrorText); TelemetryService.WriteEvent("AppUpdateError", new { StorePackageUpdateState = StorePackageUpdateState.OtherError }); break; } }
public void FindsNoChanges() { OldData.AddTransfer("PackageA", "PackageB"); OldData.AddTransfer("PackageA", "PackageC"); OldData.AddTransfer("Package1", "Package3"); OldData.AddTransfer("Package1", "Package2"); NewData.AddTransfer("PackageA", "PackageC"); NewData.AddTransfer("PackageA", "PackageB"); NewData.AddTransfer("Package1", "Package2"); NewData.AddTransfer("Package1", "Package3"); var changes = Target.ComparePopularityTransfers(OldData, NewData); Assert.Empty(changes); TelemetryService.Verify( x => x.TrackPopularityTransfersSetComparison( /*oldCount: */ 2, /*newCount: */ 2, /*changeCount: */ 0, It.IsAny <TimeSpan>()), Times.Once); }
protected override async Task RunInternalAsync(CancellationToken cancellationToken) { using (Logger.BeginScope($"Logging for {{{TelemetryConstants.Destination}}}", Destination.AbsoluteUri)) using (TelemetryService.TrackDuration(TelemetryConstants.JobLoopSeconds)) using (var client = CreateHttpClient()) { uint packagesDeleted; uint packagesCreated; uint packagesEdited; client.Timeout = Timeout; var packageCatalogItemCreator = PackageCatalogItemCreator.Create( client, TelemetryService, Logger, PreferredPackageSourceStorage); do { packagesDeleted = 0; packagesCreated = 0; packagesEdited = 0; // baseline timestamps var catalogProperties = await CatalogProperties.ReadAsync(CatalogStorage, TelemetryService, cancellationToken); var lastCreated = catalogProperties.LastCreated ?? (StartDate ?? Constants.DateTimeMinValueUtc); var lastEdited = catalogProperties.LastEdited ?? lastCreated; var lastDeleted = catalogProperties.LastDeleted ?? lastCreated; if (lastDeleted == Constants.DateTimeMinValueUtc) { lastDeleted = SkipCreatedPackagesProcessing ? lastEdited : lastCreated; } try { if (lastDeleted > Constants.DateTimeMinValueUtc) { using (TelemetryService.TrackDuration(TelemetryConstants.DeletedPackagesSeconds)) { Logger.LogInformation("CATALOG LastDeleted: {CatalogDeletedTime}", lastDeleted.ToString("O")); var deletedPackages = await GetDeletedPackages(AuditingStorage, lastDeleted); packagesDeleted = (uint)deletedPackages.SelectMany(x => x.Value).Count(); Logger.LogInformation("FEED DeletedPackages: {DeletedPackagesCount}", packagesDeleted); // We want to ensure a commit only contains each package once at most. // Therefore we segment by package id + version. var deletedPackagesSegments = SegmentPackageDeletes(deletedPackages); foreach (var deletedPackagesSegment in deletedPackagesSegments) { lastDeleted = await Deletes2Catalog( deletedPackagesSegment, CatalogStorage, lastCreated, lastEdited, lastDeleted, cancellationToken); // Wait for one second to ensure the next catalog commit gets a new timestamp Thread.Sleep(TimeSpan.FromSeconds(1)); } } } if (!SkipCreatedPackagesProcessing) { using (TelemetryService.TrackDuration(TelemetryConstants.CreatedPackagesSeconds)) { Logger.LogInformation("CATALOG LastCreated: {CatalogLastCreatedTime}", lastCreated.ToString("O")); var createdPackages = await GalleryDatabaseQueryService.GetPackagesCreatedSince(lastCreated, Top); packagesCreated = (uint)createdPackages.SelectMany(x => x.Value).Count(); Logger.LogInformation("DATABASE CreatedPackages: {CreatedPackagesCount}", packagesCreated); lastCreated = await CatalogWriterHelper.WritePackageDetailsToCatalogAsync( packageCatalogItemCreator, createdPackages, CatalogStorage, lastCreated, lastEdited, lastDeleted, MaxDegreeOfParallelism, createdPackages : true, updateCreatedFromEdited : false, cancellationToken : cancellationToken, telemetryService : TelemetryService, logger : Logger); } } using (TelemetryService.TrackDuration(TelemetryConstants.EditedPackagesSeconds)) { Logger.LogInformation("CATALOG LastEdited: {CatalogLastEditedTime}", lastEdited.ToString("O")); var editedPackages = await GalleryDatabaseQueryService.GetPackagesEditedSince(lastEdited, Top); packagesEdited = (uint)editedPackages.SelectMany(x => x.Value).Count(); Logger.LogInformation("DATABASE EditedPackages: {EditedPackagesCount}", packagesEdited); lastEdited = await CatalogWriterHelper.WritePackageDetailsToCatalogAsync( packageCatalogItemCreator, editedPackages, CatalogStorage, lastCreated, lastEdited, lastDeleted, MaxDegreeOfParallelism, createdPackages : false, updateCreatedFromEdited : SkipCreatedPackagesProcessing, cancellationToken : cancellationToken, telemetryService : TelemetryService, logger : Logger); } } finally { TelemetryService.TrackMetric(TelemetryConstants.DeletedPackagesCount, packagesDeleted); if (!SkipCreatedPackagesProcessing) { TelemetryService.TrackMetric(TelemetryConstants.CreatedPackagesCount, packagesCreated); } TelemetryService.TrackMetric(TelemetryConstants.EditedPackagesCount, packagesEdited); } } while (packagesDeleted > 0 || packagesCreated > 0 || packagesEdited > 0); } }
public App() { // save a pointer to ourself App.Current = this; InitializeComponent(); // app lifecycle event handlers EnteredBackground += OnEnteredBackground; Suspending += OnSuspending; Resuming += OnResuming; UnhandledException += OnUnhandledException; // we want full screen, but leave this off during dev ApplicationView.PreferredLaunchWindowingMode = ApplicationViewWindowingMode.FullScreen; //ApplicationView.PreferredLaunchWindowingMode = ApplicationViewWindowingMode.Auto; // we want landscape only DisplayOrientations orientations = DisplayOrientations.Landscape; DisplayInformation.AutoRotationPreferences = orientations; // Deferred execution until used. Check https://msdn.microsoft.com/library/dd642331(v=vs.110).aspx for further info on Lazy<T> class. _activationService = new Lazy <ActivationService>(CreateActivationService); // register our configuration service and initialize it SimpleIoc.Default.Register <ConfigurationService>(); ConfigurationService configurationService = (ConfigurationService)SimpleIoc.Default.GetInstance <ConfigurationService>(); if (null != configurationService) { // run this synchronously AsyncHelper.RunSync(() => configurationService.Initialize()); } // register our localization service and initialize it SimpleIoc.Default.Register <LocalizationService>(); LocalizationService localizationService = (LocalizationService)SimpleIoc.Default.GetInstance <LocalizationService>(); if (null != localizationService) { // async here might lead to a race condition, but no signs so far //localizationService.Initialize(); AsyncHelper.RunSync(() => localizationService.Initialize()); } // initialize the telemetry service SimpleIoc.Default.Register <TelemetryService>(); TelemetryService telemetryService = (TelemetryService)SimpleIoc.Default.GetInstance <TelemetryService>(); if (null != telemetryService) { if (null != configurationService) { // DO NOT try to run this asynchronously; MetroLog hangs when invoked async //AsyncHelper.RunSync(() => telemetryService.Initialize(configurationService.Configuration.TelemetryKey)); telemetryService.Initialize(configurationService.Configuration.IsTelemetryEnabled, configurationService.Configuration.TelemetryKey); // log app start TelemetryService.Current?.LogTelemetryEvent(TelemetryEvents.StartApplication); } } }
public static async Task MainAsync(string[] args) { if (args.Length > 0 && string.Equals("dbg", args[0], StringComparison.OrdinalIgnoreCase)) { args = args.Skip(1).ToArray(); Debugger.Launch(); } NgJob job = null; try { // Get arguments var arguments = CommandHelpers.GetArguments(args, 1); // Ensure that SSLv3 is disabled and that Tls v1.2 is enabled. ServicePointManager.SecurityProtocol &= ~SecurityProtocolType.Ssl3; ServicePointManager.SecurityProtocol |= SecurityProtocolType.Tls12; // Determine the job name if (args.Length == 0) { throw new ArgumentException("Missing job name argument."); } var jobName = args[0]; TelemetryConfiguration.Active.TelemetryInitializers.Add(new JobNameTelemetryInitializer(jobName)); // Configure ApplicationInsights ApplicationInsights.Initialize(arguments.GetOrDefault <string>(Arguments.InstrumentationKey)); // Create an ILoggerFactory var loggerConfiguration = LoggingSetup.CreateDefaultLoggerConfiguration(withConsoleLogger: true); loggerConfiguration.WriteTo.File("Log.txt", retainedFileCountLimit: 3, fileSizeLimitBytes: 1000000, rollOnFileSizeLimit: true); var loggerFactory = LoggingSetup.CreateLoggerFactory(loggerConfiguration, LogEventLevel.Debug); // Create a logger that is scoped to this class (only) _logger = loggerFactory.CreateLogger <Program>(); var cancellationTokenSource = new CancellationTokenSource(); // Create an ITelemetryService var telemetryService = new TelemetryService(new TelemetryClient()); // Allow jobs to set global custom dimensions TelemetryConfiguration.Active.TelemetryInitializers.Add(new JobPropertiesTelemetryInitializer(telemetryService)); job = NgJobFactory.GetJob(jobName, telemetryService, loggerFactory); await job.RunAsync(arguments, cancellationTokenSource.Token); } catch (ArgumentException ae) { _logger?.LogError("A required argument was not found or was malformed/invalid: {Exception}", ae); Console.WriteLine(job != null ? job.GetUsage() : NgJob.GetUsageBase()); } catch (Exception e) { _logger?.LogCritical("A critical exception occured in ng.exe! {Exception}", e); } Trace.Close(); TelemetryConfiguration.Active.TelemetryChannel.Flush(); }
private async Task MessageReceivedAsync(IDialogContext context, IAwaitable <object> result) { if (_people == null) { _people = await PeopleService.GetPeopleLisAtAsync(); } var mess = await result as IMessageActivity; if (context.ConversationData.ContainsKey(Constants.LAST_PERSON_KEY)) { var lastPerson = context.ConversationData.GetValue <Person>(Constants.LAST_PERSON_KEY); var guessResult = _people.FindByName(mess.Text); if (guessResult.Count > 3 && guessResult.Contains(lastPerson, new PersonComparer())) { await context.PostAsync("That is too generic. Try again."); context.Wait(MessageReceivedAsync); } else if (guessResult.Contains(lastPerson, new PersonComparer())) { // správná odpověď TelemetryService.SendTelemetry(new TelemetryModel("correct", lastPerson.Name)); await context.PostAsync("✔️ Correct!"); // zvednout skóre if (context.ConversationData.ContainsKey(Constants.SECOND_CHANCE)) { await context.PostAsync("That's **0.5** points for you."); await Utils.ChangeScoreAsync(context, 0.5); context.ConversationData.RemoveValue(Constants.SECOND_CHANCE); } else { await context.PostAsync("That's **2** points for you."); await Utils.ChangeScoreAsync(context, 2); } // DEBUG //context.Done(1.0); //return; // zobrazit další await GoNext(context); } else { // špatná odpověď - dáme nápovědu, pokud už nejsme v nápovědě :) TelemetryService.SendTelemetry(new TelemetryModel("incorrect", lastPerson.Name)); if (context.ConversationData.ContainsKey(Constants.SECOND_CHANCE)) { await context.PostAsync($"❌ That is not correct. Let's try another speaker."); context.ConversationData.RemoveValue(Constants.SECOND_CHANCE); await GoNext(context); } else { await context.PostAsync("Not correct. I'll give you a hint. But it will be for less points. This person's name is one of those:"); var msg = context.MakeMessage(); msg.Attachments.Add(PrepareButtonsCard(_people.GetRandomPeople(lastPerson, 5).Select(p => p.Name).ToArray()).ToAttachment()); await context.PostAsync(msg); context.ConversationData.SetValue(Constants.SECOND_CHANCE, "true"); context.Wait(MessageReceivedAsync); } } } else { await GoNext(context); } }
/// <summary> /// Is called, when the TelemetryToggleSwitch is clicked. Calls SetUseTelemetry of TelemetryService. /// </summary> private void TelemetryToggleSwitch_Toggled(object sender, RoutedEventArgs e) { TelemetryService.SetUseTelemetry(((ToggleSwitch)sender).IsOn); }
public TelemetryController(TelemetryService telemetryService) { _telemetryService = telemetryService; }