public void Record()
{
if (Process.GetProcessesByName("rfactor").Length == 0)
{
Assert.Ignore();
}
var rFactorProcess = Process.GetProcessesByName("rfactor")[0];
IntPtr alloc = Marshal.AllocHGlobal(512 * 1024 * 1024);
using (var host = new Plugins())
{
host.PluginDirectory = TestConstants.SimulatorsBinFolder;
host.Load();
// Simulators are now loaded
var testPlugin = host.Simulators.Where(x => x.Name == "Test simulator").FirstOrDefault();
testPlugin.SimulatorStart(rFactorProcess);
var telSource = new Domain.Aggregates.Telemetry(testPlugin.TelemetryProvider, rFactorProcess);
var telLogger = new TelemetryLogger("testSim", new TelemetryLoggerConfiguration(true, false, true, false));
telLogger.SetAnnotater(new TelemetryArchive());
telSource.SetLogger(telLogger);
Thread.Sleep(60000);
telLogger.Close();
telSource = null;
}
Marshal.FreeHGlobal(alloc);
}
public static int Run(string[] args)
{
var sessionId =
Environment.GetEnvironmentVariable(MSBuildForwardingApp.TelemetrySessionIdEnvironmentVariableName);
// senderCount: 0 to disable sender.
// When senders in different process running at the same
// time they will read from the same global queue and cause
// sending duplicated events. Disable sender to reduce it.
var telemetry = new Telemetry(new FirstTimeUseNoticeSentinel(),
sessionId,
senderCount: 0);
var logger = new TelemetryLogger(null);
if (telemetry.Enabled)
{
logger = new TelemetryLogger((name, props, measures) =>
{
if (telemetry.Enabled)
{
telemetry.TrackEvent($"template/{name}", props, measures);
}
});
}
return(New3Command.Run(CommandName, CreateHost(), logger, FirstRun, args));
}
public SeedLogic(TelemetryLogger logger, Settings settings, IRepositoryClient repositoryClient, MasterTenantDocumentsSeedLogic masterTenantDocumentsSeedLogic, IHttpContextAccessor httpContextAccessor) : base(httpContextAccessor)
{
this.logger = logger;
this.settings = settings;
this.repositoryClient = repositoryClient;
this.masterTenantDocumentsSeedLogic = masterTenantDocumentsSeedLogic;
}
void OnDie()
{
// spawn a particle system when dying
var vfx = Instantiate(deathVFX, deathVFXSpawnPoint.position, Quaternion.identity);
Destroy(vfx, 5f);
// tells the game flow manager to handle the enemy destuction
m_EnemyManager.UnregisterEnemy(this);
// loot an object
if (TryDropItem())
{
Instantiate(lootPrefab, transform.position, Quaternion.identity);
}
var source = m_Health.LastDamageSource;
if (source != null)
{
var player = source.GetComponent <PlayerWeaponsManager>();
TelemetryLogger.LogEnemyKill(name, transform.position, player.GetActiveWeapon().weaponName, source.transform.position);
}
// this will call the OnDestroy function
Destroy(gameObject, deathDuration);
}
protected override ILogger CreateLogger(TelemetrySession telemetrySession)
=> AggregateLogger.Create(
CodeMarkerLogger.Instance,
new EtwLogger(FunctionIdOptions.CreateFunctionIsEnabledPredicate(_globalOptions)),
TelemetryLogger.Create(telemetrySession, _globalOptions),
new FileLogger(_globalOptions),
Logger.GetLogger());
public void Add(string name, RouteBase item)
{
if (item == null)
{
throw new ArgumentNullException("item");
}
if (!String.IsNullOrEmpty(name))
{
if (_namedMap.ContainsKey(name))
{
throw new ArgumentException(
String.Format(
CultureInfo.CurrentUICulture,
SR.GetString(SR.RouteCollection_DuplicateName),
name),
"name");
}
}
Add(item);
if (!String.IsNullOrEmpty(name))
{
_namedMap[name] = item;
}
// RouteBase doesn't have handler info, so we only log Route.RouteHandler
var route = item as Route;
if (route != null && route.RouteHandler != null)
{
TelemetryLogger.LogHttpHandler(route.RouteHandler.GetType());
}
}
/// <summary>
/// Optional override to create listeners (like tcp, http) for this service instance.
/// </summary>
/// <returns>The collection of listeners.</returns>
protected override IEnumerable <ServiceInstanceListener> CreateServiceInstanceListeners()
{
ITelemetryLogger logger = new TelemetryLogger(new List <ILogAppender>()
{
new AppInsightsLogAppender(new AppInsightsAppenderConfig(), this.context)
});
//FabricTelemetryInitializerExtension.SetServiceCallContext(this.Context);
return(new ServiceInstanceListener[]
{
new ServiceInstanceListener(serviceContext =>
new KestrelCommunicationListener(serviceContext, "ServiceEndpoint", (url, listener) =>
{
return new WebHostBuilder()
.UseKestrel()
.ConfigureServices(
services => services
.AddSingleton <StatelessServiceContext>(serviceContext))
.UseContentRoot(Directory.GetCurrentDirectory())
.UseStartup <Startup>()
.UseServiceFabricIntegration(listener, ServiceFabricIntegrationOptions.None)
.UseUrls(url)
.Build();
}))
});
}
public MasterTenantDocumentsSeedLogic(TelemetryLogger logger, Settings settings, ITenantRepository tenantRepository, MasterTenantLogic masterTenantLogic, IHttpContextAccessor httpContextAccessor) : base(httpContextAccessor)
{
this.logger = logger;
this.settings = settings;
this.tenantRepository = tenantRepository;
this.masterTenantLogic = masterTenantLogic;
}
void SetPauseMenuActivation(bool active)
{
menuRoot.SetActive(active);
if (menuRoot.activeSelf)
{
Cursor.lockState = CursorLockMode.None;
Cursor.visible = true;
Time.timeScale = 0f;
AudioUtility.SetMasterVolume(volumeWhenMenuOpen);
EventSystem.current.SetSelectedGameObject(null);
TelemetryLogger.LogMenuChange("Play", "Pause", m_PlayerInputsHandler.transform.position);
}
else
{
Cursor.lockState = CursorLockMode.Locked;
Cursor.visible = false;
Time.timeScale = 1f;
AudioUtility.SetMasterVolume(1);
TelemetryLogger.LogMenuChange("Pause", "Play", m_PlayerInputsHandler.transform.position);
}
}
void Update()
{
if (gameIsEnding)
{
float timeRatio = 1 - (m_TimeLoadEndGameScene - Time.time) / endSceneLoadDelay;
endGameFadeCanvasGroup.alpha = timeRatio;
AudioUtility.SetMasterVolume(1 - timeRatio);
// See if it's time to load the end scene (after the delay)
if (Time.time >= m_TimeLoadEndGameScene)
{
SceneManager.LoadScene(m_SceneToLoad);
gameIsEnding = false;
}
}
else
{
if (m_ObjectiveManager.AreAllObjectivesCompleted())
{
EndGame(true);
TelemetryLogger.LogVictory("Objectives", m_Player.transform.position, m_ObjectiveManager.ObjectivesCompleted);
}
// Test if player died
if (m_Player.isDead)
{
EndGame(false);
}
}
}
/// <summary>
/// Check Is Valid Email
/// </summary>
/// <returns></returns>
public JsonResult CheckIsValidEmail(string email)
{
bool isduplicate = false;
try
{
using (var client = new DatamantraAPIClient())
{
string requestUri = "User/CheckIsValidEmail?email=" + email;
var _UserResponse = client.GetAsync(requestUri).Result;
TelemetryLogger.TrackTrace("Got User Res");
if (_UserResponse != null && _UserResponse.IsSuccessStatusCode)
{
var userRes = _UserResponse.Content.ReadAsAsync <string>().Result;
if (userRes != null && userRes == "True")
{
isduplicate = true;
}
}
}
}
catch (Exception ex)
{
TelemetryLogger.TrackException(ex, "CheckIsValidEmail");
}
return(Json(isduplicate, JsonRequestBehavior.AllowGet));
}
public TelemetryService(
ILogger <TelemetryService> logger,
IEventService eventService)
{
var config = Program.Configuration;
Logger = logger;
Logger.LogInformation("Starting Telemetry.");
Logger.LogDebug($"DeviceId: {GetDeviceId()}.");
TelemetryLogger = CreateLogManager(config);
InitTelemetryLogger(TelemetryLogger, config);
TelemetryLogger.LogEvent(
"TelemetryStarted".AsTelemetryEvent().WithTimeSinceStart()
);
eventService.OnKernelStarted().On += (kernelApp) =>
{
TelemetryLogger.LogEvent(
"KernelStarted".AsTelemetryEvent().WithTimeSinceStart()
);
};
eventService.OnKernelStopped().On += (kernelApp) =>
{
TelemetryLogger.LogEvent("KernelStopped".AsTelemetryEvent());
LogManager.UploadNow();
LogManager.Teardown();
};
eventService.OnServiceInitialized <IMetadataController>().On += (metadataController) =>
metadataController.MetadataChanged += (metadataController, propertyChanged) =>
SetSharedContextIfChanged(metadataController, propertyChanged,
nameof(metadataController.ClientId),
nameof(metadataController.UserAgent),
nameof(metadataController.ClientCountry),
nameof(metadataController.ClientLanguage),
nameof(metadataController.ClientHost),
nameof(metadataController.ClientOrigin),
nameof(metadataController.ClientFirstOrigin),
nameof(metadataController.ClientIsNew));
eventService.OnServiceInitialized <ISnippets>().On += (snippets) =>
snippets.SnippetCompiled += (_, info) => TelemetryLogger.LogEvent(info.AsTelemetryEvent());
eventService.OnServiceInitialized <IWorkspace>().On += (workspace) =>
workspace.Reloaded += (_, info) => TelemetryLogger.LogEvent(info.AsTelemetryEvent());
eventService.OnServiceInitialized <IReferences>().On += (references) =>
references.PackageLoaded += (_, info) => TelemetryLogger.LogEvent(info.AsTelemetryEvent());
eventService.OnServiceInitialized <IExecutionEngine>().On += (executionEngine) =>
{
TelemetryLogger.LogEvent(
"ExecutionEngineInitialized".AsTelemetryEvent().WithTimeSinceStart()
);
if (executionEngine is BaseEngine engine)
{
engine.MagicExecuted += (_, info) => TelemetryLogger.LogEvent(info.AsTelemetryEvent());
engine.HelpExecuted += (_, info) => TelemetryLogger.LogEvent(info.AsTelemetryEvent());
}
};
}
private void OnServiceInitialized <T>()
{
EventService.OnServiceInitialized <T>().On += (service) =>
{
var evt = "ServiceInitialized".AsTelemetryEvent();
evt.SetProperty("Service", $"{typeof(T).Namespace}.{typeof(T).Name}");
TelemetryLogger.LogEvent(evt);
};
}
public RepositoryCosmosClient(Settings settings, TelemetryLogger logger)
{
this.logger = logger;
CosmosClient = new CosmosClient(settings.CosmosDb.EndpointUri, settings.CosmosDb.PrimaryKey, new CosmosClientOptions()
{
AllowBulkExecution = true
});
Container = CosmosClient.GetContainer(settings.CosmosDb.DatabaseId, settings.CosmosDb.CollectionId);
}
public MasterRepository(TelemetryLogger logger, IRepositoryClient repositoryClient)
{
client = repositoryClient.Client;
databaseId = repositoryClient.DatabaseId;
collectionId = repositoryClient.CollectionId;
collectionUri = repositoryClient.CollectionUri;
//documentCollection = repositoryClient.DocumentCollection;
this.logger = logger;
}
public void QualifyTest()
{
var dummyDataSource = new MockDataSource();
var archive = new TelemetryArchive();
var loggerFromZero = new TelemetryLogger("test", new TelemetryLoggerConfiguration(true, true, true, true));
loggerFromZero.SetDatasource(dummyDataSource);
GlobalEvents.Fire(new SessionStarted(), true);
Assert.False(archive.QualifiesForStorage(loggerFromZero));
loggerFromZero.Update(0);
Assert.False(archive.QualifiesForStorage(loggerFromZero));
loggerFromZero.Update(1000);
Assert.False(archive.QualifiesForStorage(loggerFromZero));
loggerFromZero.Update(5000);
Assert.False(archive.QualifiesForStorage(loggerFromZero));
loggerFromZero.Update(10000);
Assert.True(archive.QualifiesForStorage(loggerFromZero));
loggerFromZero.Close();
var loggerFromElse = new TelemetryLogger("test", new TelemetryLoggerConfiguration(true, true, true, true));
loggerFromElse.SetDatasource(dummyDataSource);
GlobalEvents.Fire(new SessionStarted(), true);
Assert.False(archive.QualifiesForStorage(loggerFromElse));
loggerFromElse.Update(10000);
Assert.False(archive.QualifiesForStorage(loggerFromElse));
loggerFromElse.Update(13000);
Assert.False(archive.QualifiesForStorage(loggerFromElse));
loggerFromElse.Update(0);
Assert.False(archive.QualifiesForStorage(loggerFromElse));
loggerFromElse.Update(20000);
Assert.True(archive.QualifiesForStorage(loggerFromElse));
loggerFromElse.Update(24 * 3600 * 1000);
Assert.True(archive.QualifiesForStorage(loggerFromElse));
}
public static TelemetryScopedLogger ScopedLoggerObject(IHttpContextAccessor httpContextAccessor)
{
var telemetryClient = new TelemetryClient(new TelemetryConfiguration("xxx"));
var telemetryLogger = new TelemetryLogger(telemetryClient);
var tenantTrackLogger = new TenantTrackLogger(httpContextAccessor);
var telemetryScopedProperties = new TelemetryScopedProperties();
var telemetryScopedLogger = new TelemetryScopedLogger(telemetryLogger, telemetryScopedProperties, tenantTrackLogger);
return(telemetryScopedLogger);
}
public RepositoryClientBase(Settings settings, TelemetryLogger logger, bool withTtlContainer, bool withBulkExecution)
{
this.settings = settings;
this.logger = logger;
this.withTtlContainer = withTtlContainer;
this.withBulkExecution = withBulkExecution;
CreateClient();
LoadContainers();
}
public void NupkgReinstallDoesntRemoveTemplates()
{
const string nupkgToInstallName = "TestNupkgInstallTemplate.0.0.1.nupkg";
const string checkTemplateName = "nupkginstall"; // this is the short name of the template in the nupkg that gets installed.
ITemplateEngineHost host = CreateHostWithVirtualizedHive(HostIdentifier, HostVersion);
Assert.NotNull(host);
ITelemetryLogger telemetryLogger = new TelemetryLogger(null, false);
int initializeResult = New3Command.Run(CommandName, host, telemetryLogger, null, new string[] { });
Assert.Equal(0, initializeResult);
string codebase = typeof(NupkgInstallTests).GetTypeInfo().Assembly.CodeBase;
Uri cb = new Uri(codebase);
string asmPath = cb.LocalPath;
string dir = Path.GetDirectoryName(asmPath);
string pathToInstall = Path.Combine(dir, "TemplateInstallTests", "TestTemplates", nupkgToInstallName);
Assert.True(File.Exists(pathToInstall), $"directory didnt exist: {pathToInstall}");
string[] installArgs = new[]
{
"--install",
pathToInstall
};
// install the test pack
int firstInstallResult = New3Command.Run(CommandName, host, telemetryLogger, null, installArgs);
Assert.Equal(0, firstInstallResult);
EngineEnvironmentSettings environemnt = new EngineEnvironmentSettings(host, x => new SettingsLoader(x));
SettingsLoader settingsLoader = (SettingsLoader)environemnt.SettingsLoader;
IHostSpecificDataLoader hostDataLoader = new MockHostSpecificDataLoader();
// check that the template was installed from the first install.
IReadOnlyCollection <ITemplateMatchInfo> allTemplates = TemplateListResolver.PerformAllTemplatesQuery(settingsLoader.UserTemplateCache.TemplateInfo, hostDataLoader);
Assert.Contains(checkTemplateName, allTemplates.Select(t => t.Info.ShortName));
// install the same test pack again
int secondInstallResult = New3Command.Run(CommandName, host, telemetryLogger, null, installArgs);
Assert.Equal(0, secondInstallResult);
settingsLoader.Reload();
// check that the template is still installed after the second install.
IReadOnlyCollection <ITemplateMatchInfo> allTemplatesAfterSecondInstall = TemplateListResolver.PerformAllTemplatesQuery(settingsLoader.UserTemplateCache.TemplateInfo, hostDataLoader);
Assert.Contains(checkTemplateName, allTemplatesAfterSecondInstall.Select(t => t.Info.ShortName));
}
public RepositoryClient(Settings settings, TelemetryLogger logger, IWebHostEnvironment environment)
{
this.settings = settings;
this.logger = logger;
this.environment = environment;
DatabaseId = this.settings.CosmosDb.DatabaseId;
CollectionId = this.settings.CosmosDb.CollectionId;
TtlCollectionId = this.settings.CosmosDb.TtlCollectionId;
serviceEndpont = new Uri(this.settings.CosmosDb.EndpointUri);
databaseUri = UriFactory.CreateDatabaseUri(DatabaseId);
CreateDocumentClient().GetAwaiter().GetResult();
}
public RepositoryClient(Settings settings, TelemetryLogger logger, IServiceProvider serviceProvider)
{
this.settings = settings;
this.logger = logger;
this.serviceProvider = serviceProvider;
DatabaseId = this.settings.CosmosDb.DatabaseId;
CollectionId = this.settings.CosmosDb.CollectionId;
TtlCollectionId = this.settings.CosmosDb.TtlCollectionId;
serviceEndpont = new Uri(this.settings.CosmosDb.EndpointUri);
DatabaseUri = UriFactory.CreateDatabaseUri(DatabaseId);
CreateDocumentClient();
}
public TelemetryClientTestData VerifyDefaultConstructorResident()
{
var logger = new TelemetryLogger();
return(new TelemetryClientTestData
{
SessionId = logger.Client.Context.Session.Id,
UserId = logger.Client.Context.User.Id,
OperatingSystem = logger.Client.Context.Device.OperatingSystem,
AcVersion = logger.Client.Context.GlobalProperties["AcVersion"],
CoreVersion = logger.Client.Context.GlobalProperties["CoreVersion"]
});
}
public static int Run(string[] args)
{
var sessionId = Environment.GetEnvironmentVariable(MSBuildForwardingApp.TelemetrySessionIdEnvironmentVariableName);
var telemetry = new Telemetry(new NuGetCacheSentinel(new CliFallbackFolderPathCalculator()), sessionId);
var logger = new TelemetryLogger((name, props, measures) =>
{
if (telemetry.Enabled)
{
telemetry.TrackEvent(name, props, measures);
}
});
return(New3Command.Run(CommandName, CreateHost(), logger, FirstRun, args));
}
void OnPicked(PlayerCharacterController player)
{
Health playerHealth = player.GetComponent <Health>();
if (playerHealth && playerHealth.canPickup())
{
float healing = playerHealth.Heal(healAmount);
TelemetryLogger.LogCollect("Healing", transform.position, name, healing);
m_Pickup.PlayPickupFeedback();
Destroy(gameObject);
}
}
public void TestInit()
{
this.serviceProvider = new ConfigurableServiceProvider();
this.dte = new DTEMock();
this.serviceProvider.RegisterService(typeof(EnvDTE.DTE), this.dte);
var outputWindow = new ConfigurableVsOutputWindow();
this.outputPane = outputWindow.GetOrCreateSonarLintPane();
this.serviceProvider.RegisterService(typeof(SVsOutputWindow), outputWindow);
this.testSubject = new TelemetryLogger(this.serviceProvider);
}
private void IntellisenseOptionsPageAnalysisLevelChanged(object sender, EventArgs e)
{
if (_analyzer != null)
{
var analyzer = CreateLooseVsProjectAnalyzer();
analyzer.SwitchAnalyzers(_analyzer);
if (_analyzer.RemoveUser())
{
_analyzer.Dispose();
}
_analyzer = analyzer;
LogLooseFileAnalysisLevel();
}
TelemetryLogger.LogAnalysisLevelChanged(IntellisenseOptionsPage.AnalysisLevel);
}
private void Awake()
{
if (_instance != null)
{
Debug.LogWarning("You have two TelemetryLoggers active at the same time. Please ensure you have only one at a time.");
Destroy(this);
return;
}
_instance = this;
if (_serverAwake == false)
{
StartCoroutine(WakeServer());
}
}
public int VerifyLogEventResident()
{
var mockChannel = new MockTelemetryChannel();
var config = new TelemetryConfiguration
{
TelemetryChannel = mockChannel,
InstrumentationKey = Guid.NewGuid().ToString(),
};
var client = new TelemetryClient(config);
var logger = new TelemetryLogger {
Client = client
};
logger.LogEvent(Event.Command, "parameters");
return(mockChannel.SentEvents.Count());
}
public int VerifyLogExceptionResident()
{
var mockChannel = new MockTelemetryChannel();
var config = new TelemetryConfiguration
{
TelemetryChannel = mockChannel,
InstrumentationKey = Guid.NewGuid().ToString(),
};
var client = new TelemetryClient(config);
var logger = new TelemetryLogger {
Client = client
};
logger.LogException(new Exception("exception"));
return(mockChannel.SentExceptions.Count());
}
public int VerifyLogEntryWithSeverityInformationResident()
{
var mockChannel = new MockTelemetryChannel();
var config = new TelemetryConfiguration
{
TelemetryChannel = mockChannel,
InstrumentationKey = Guid.NewGuid().ToString(),
};
var client = new TelemetryClient(config);
var logger = new TelemetryLogger {
Client = client
};
logger.Entry("message", Severity.Information);
return(mockChannel.SentTraces.Count());
}
