private void sendCustomEventData(IAnalyticsEvent evt)
{
foreach (var p in evt.dataAsDictionary)
{
processDesignEventData(evt.eventName, p);
}
}
public AppInsightsEventTelemetry(string userId, string instrumentationKey, IAnalyticsEvent analyticsEvent)
{
InstrumentationKey = instrumentationKey;
DataTypeName = $"Microsoft.ApplicationInsights.{InstrumentationKey}.Event";
EventDateTime = DateTime.UtcNow.ToString("O");
TelemetryTags = new Dictionary <string, string>()
{
{ "ai.user.id", userId },
{ "ai.user.accountId", userId }
};
TelemetryData = new TelemetryData
{
ItemTypeName = "EventData",
TelemetryDataItem = new TelemetryDataItem
{
EventName = analyticsEvent.EventName,
Properties = new Dictionary <string, string>(analyticsEvent.Properties)
{
{ "UserId", userId },
{ "Platform", GetOSPlatform() ?? DefaultValue },
{ "PlatformDescription", RuntimeInformation.OSDescription },
}
}
};
}
public void SendEvent(IAnalyticsEvent analyticsEvent)
{
_telemetryClient.TrackEvent(
analyticsEvent.EventType,
SeverityLevel.Warning,
analyticsEvent.ToDictionary());
_telemetryClient.Flush();
}
private static WriteClientPlayerEventRequest getPlayerEventRequest(IAnalyticsEvent data)
{
return(new WriteClientPlayerEventRequest()
{
Body = data.dataAsDictionary,
EventName = data.eventName
});
}
public async Task TransmitEventAsync(IAnalyticsEvent analyticsEvent)
{
var serializedEventTelemetry = _appInsightsEventSerializer.SerializeAnalyticsEvent(analyticsEvent);
using (var httpContent = new ByteArrayContent(serializedEventTelemetry))
{
await _httpClient.PostAsync(_appInsightsDataCollectionEndPoint, httpContent);
}
}
public void TransmitEvent(IAnalyticsEvent analyticsEvent)
{
if (!_enableAnalyticsChecker.IsEnabled())
{
throw new InvalidOperationException("This method should not be called because analytics transmission is disabled.");
}
Console.WriteLine(analyticsEvent.ToString());
}
public async Task TransmitEventAsync(IAnalyticsEvent analyticsEvent, string instrumentationKey)
{
var serializedEventTelemetry = _appInsightsEventSerializer.SerializeAnalyticsEvent(analyticsEvent, instrumentationKey);
using (var httpContent = new ByteArrayContent(serializedEventTelemetry))
{
await _httpClientWrapper.HttpClient.PostAsync(EndPoint, httpContent);
}
}
public Task <IResult> TransmitEvent(IAnalyticsEvent analyticsEvent)
{
if (!IsEnabled)
{
return(Task.FromResult(Result.Success()));
}
return(_analyticsTransmitterSink.TransmitEvent(analyticsEvent));
}
public void TransmitEvent(IAnalyticsEvent analyticsEvent)
{
if (!_enableAnalyticsChecker.IsEnabled())
{
throw new InvalidOperationException("This method may not be called when analytics transmission is disabled.");
}
Console.WriteLine(@"Simulating transmission of {0}", analyticsEvent);
}
public async Task <IResult> TransmitEvent(IAnalyticsEvent analyticsEvent)
{
if (!_environmentSpecFlowTelemetryChecker.IsSpecFlowTelemetryEnabled())
{
return(Result.Success());
}
return(await _analyticsTransmitterSink.TransmitEvent(analyticsEvent));
}
private void sendFacebookEvent(IAnalyticsEvent evt)
{
if (!FB.IsInitialized)
{
if (mPendingEvents.Count < 50)
{
mPendingEvents.Add(evt);
}
return;
}
FB.LogAppEvent(evt.eventName, parameters: evt.dataAsDictionary);
}
public async Task TransmitRuntimeEvent(IAnalyticsEvent runtimeEvent)
{
var ideVersion = _applicationHost.HostProductInfo.VersionMarketingString;
var specFlowId = _specFlowUserIdStore.GetUserId();
var currentPluginVersion = Assembly.GetExecutingAssembly().GetName().Version;
var properties = runtimeEvent.Properties;
properties.Add("Ide", "JetBrains Rider");
properties.Add("IdeVersion", ideVersion);
properties.Add("ExtensionVersion", currentPluginVersion.ToString());
await _analyticsTransmitterSink.TransmitEvent(runtimeEvent, specFlowId);
}
public void TransmitEvent(IAnalyticsEvent analyticsEvent)
{
if (!_enableAnalyticsChecker.IsEnabled())
{
throw new InvalidOperationException("This method should not be called because analytics transmission is disabled.");
}
var appInsightsEvent = _appInsightsEventConverter.ConvertToAppInsightsEvent(analyticsEvent);
var telemetryClient = _telemetryClientWrapper.TelemetryClient;
telemetryClient.TrackEvent(appInsightsEvent);
telemetryClient.Flush();
}
public void LogEvent(IAnalyticsEvent analyticsEvent)
{
foreach (IAnalyticsEngine analyticsEngine in _analyticsEnginesFactory.CreateAnalyticsEngines(_customConfigurationManager))
{
string analyticsEngineName = analyticsEngine.AnalyticsEngineName;
bool flag = _customConfigurationManager.GetFlag(analyticsEngineName);
if (flag)
{
analyticsEngine.SendEvent(analyticsEvent);
}
}
}
public void Initilize()
{
_dummyAnalyticsEvent = It.IsAny <IAnalyticsEvent>();
_mockCustomConfigurationManager = new Mock <ICustomConfigurationManager>();
_mockAnalyticsEnginesFactory = new Mock <IAnalyticsEnginesFactory>();
List <IAnalyticsEngine> analyticsEngines = new List <IAnalyticsEngine>();
_mockApplicationInsightsAnalyticsEngine = new Mock <IAnalyticsEngine>();
analyticsEngines.Add(_mockApplicationInsightsAnalyticsEngine.Object);
_mockAnalyticsEnginesFactory.Setup(e => e.CreateAnalyticsEngines(It.IsAny <ICustomConfigurationManager>())).Returns(analyticsEngines);
}
public async Task <IResult> TransmitEvent(IAnalyticsEvent analyticsEvent, string instrumentationKey)
{
try
{
await TransmitEventAsync(analyticsEvent, instrumentationKey);
return(Result.Success());
}
catch (Exception e)
{
// we swallow the exception to not break the build when just the analytics could not be transmitted
// but we still return it inside a Failure to tell the outside world that something has failed
return(Result.Failure(e));
}
}
public async Task TransmitEvent(IAnalyticsEvent analyticsEvent)
{
try
{
var serializedEventTelemetry = _appInsightsEventSerializer.SerializeAnalyticsEvent(analyticsEvent);
using (var httpContent = new ByteArrayContent(serializedEventTelemetry))
{
await _httpClient.PostAsync(_appInsightsDataCollectionEndPoint, httpContent);
}
}
catch (Exception)
{
//we don't care if we get any error during the sending
}
}
public async Task LogEventParallelAsync(IAnalyticsEvent analyticsEvent)
{
List <Task> tasks = new List <Task>();
foreach (IAnalyticsEngine analyticsEngine in _analyticEnginesFactory.CreateAnalyticsEngines(_customConfigurationManager))
{
string analyticsEngineName = analyticsEngine.GetAnalyticsEngineName;
bool flag = _customConfigurationManager.GetFlag(analyticsEngineName);
if (flag)
{
Task task = analyticsEngine.SendEventAsync(analyticsEvent);
tasks.Add(task);
}
}
await Task.WhenAll(tasks);
}
private void TransmitEvent(IAnalyticsEvent analyticsEvent)
{
try
{
if (!_environmentSpecFlowTelemetryChecker.IsSpecFlowTelemetryEnabled())
{
return;
}
_analyticsTransmitterSink.TransmitEvent(analyticsEvent);
}
catch (Exception)
{
//nope
}
}
public async Task TransmitEvent(IAnalyticsEvent analyticsEvent, string userId)
{
if (!_environmentSpecFlowTelemetryChecker.IsSpecFlowTelemetryEnabled())
{
return;
}
try
{
await TransmitEventAsync(analyticsEvent, userId);
}
catch (Exception e)
{
_logger.Verbose(e);
}
}
public EventTelemetry ConvertToAppInsightsEvent(IAnalyticsEvent analyticsEvent)
{
var eventTelemetry = new EventTelemetry(analyticsEvent.EventName)
{
Timestamp = analyticsEvent.UtcDate,
Properties =
{
{ "UserId", analyticsEvent.UserId },
{ "UtcDate", analyticsEvent.UtcDate.ToString("O") },
}
};
if (analyticsEvent is ExceptionAnalyticsEvent exceptionAnalyticsEvent)
{
eventTelemetry.Properties.Remove("UserId");
eventTelemetry.Properties.Add("ExceptionType", exceptionAnalyticsEvent.ExceptionType);
return(eventTelemetry);
}
if (analyticsEvent is ExtensionInstalledAnalyticsEvent extensionInstalledAnalyticsEvent)
{
eventTelemetry.Properties.Add("ExtensionVersion", extensionInstalledAnalyticsEvent.ExtensionVersion);
eventTelemetry.Properties.Add("IdeVersion", extensionInstalledAnalyticsEvent.IdeVersion);
}
if (analyticsEvent is ExtensionLoadedAnalyticsEvent extensionLoadedAnalyticsEvent)
{
eventTelemetry.Properties.Add("ExtensionVersion", extensionLoadedAnalyticsEvent.ExtensionVersion);
eventTelemetry.Properties.Add("IdeVersion", extensionLoadedAnalyticsEvent.IdeVersion);
eventTelemetry.Properties.Add("Ide", extensionLoadedAnalyticsEvent.Ide);
eventTelemetry.Properties.Add("ProjectTargetFramework", string.Join(";", extensionLoadedAnalyticsEvent.ProjectTargetFrameworks));
}
if (analyticsEvent is ExtensionUpgradedAnalyticsEvent extensionUpgradeAnalyticsEvent)
{
eventTelemetry.Properties.Add("ExtensionVersion", extensionUpgradeAnalyticsEvent.ExtensionVersion);
eventTelemetry.Properties.Add("OldExtensionVersion", extensionUpgradeAnalyticsEvent.OldExtensionVersion);
}
if (analyticsEvent is ProjectTemplateWizardCompletedAnalyticsEvent projectTemplateWizardCompleted)
{
eventTelemetry.Properties.Add("SelectedDotNetFramework", projectTemplateWizardCompleted.SelectedDotNetFramework);
eventTelemetry.Properties.Add("SelectedUnitTestFramework", projectTemplateWizardCompleted.SelectedUnitTestFramework);
}
return(eventTelemetry);
}
public AppInsightsEventTelemetry(IAnalyticsEvent analyticsEvent, string instrumentationKey)
{
InstrumentationKey = instrumentationKey;
DataTypeName = $"Microsoft.ApplicationInsights.{InstrumentationKey}.Event";
EventDateTime = analyticsEvent.UtcDate.ToString("O");
TelemetryTags = new Dictionary <string, string>()
{
{ "ai.user.id", analyticsEvent.UserId },
{ "ai.user.accountId", analyticsEvent.UserId }
};
TelemetryData = new TelemetryData
{
ItemTypeName = "EventData",
TelemetryDataItem = new TelemetryDataItem
{
EventName = analyticsEvent.EventName,
Properties = new Dictionary <string, string>()
{
{ "UtcDate", analyticsEvent.UtcDate.ToString("O") },
{ "UserId", analyticsEvent.UserId },
{ "Platform", analyticsEvent.Platform },
{ "PlatformDescription", analyticsEvent.PlatformDescription },
{ "SpecFlowVersion", analyticsEvent.SpecFlowVersion },
{ "UnitTestProvider", analyticsEvent.UnitTestProvider ?? DefaultValue },
{ "IsBuildServer", analyticsEvent.IsBuildServer.ToString() },
{ "BuildServerName", analyticsEvent.BuildServerName ?? DefaultValue },
{ "IsDockerContainer", analyticsEvent.IsDockerContainer.ToString() },
{ "HashedAssemblyName", analyticsEvent.HashedAssemblyName ?? DefaultValue },
{ "TargetFrameworks", analyticsEvent.TargetFrameworks },
{ "TargetFramework", analyticsEvent.TargetFramework },
}
}
};
if (analyticsEvent is SpecFlowProjectCompilingEvent specFlowProjectCompiledEvent)
{
TelemetryData.TelemetryDataItem.Properties.Add("MSBuildVersion", specFlowProjectCompiledEvent.MSBuildVersion);
TelemetryData.TelemetryDataItem.Properties.Add("ProjectGuid", specFlowProjectCompiledEvent.ProjectGuid ?? DefaultValue);
}
}
public CreatePlaceholdersState(
IDataSource <TThreadSafe, TDatabase> dataSource,
ILastTimeUsageStorage lastTimeUsageStorage,
ITimeService timeService,
IAnalyticsEvent <int> analyticsEvent,
Func <ITimeEntry, long[]> dependencyIdsSelector,
Func <long, long, TThreadSafe> buildDependencyPlaceholder)
{
Ensure.Argument.IsNotNull(dataSource, nameof(dataSource));
Ensure.Argument.IsNotNull(lastTimeUsageStorage, nameof(lastTimeUsageStorage));
Ensure.Argument.IsNotNull(timeService, nameof(timeService));
Ensure.Argument.IsNotNull(analyticsEvent, nameof(analyticsEvent));
Ensure.Argument.IsNotNull(dependencyIdsSelector, nameof(dependencyIdsSelector));
Ensure.Argument.IsNotNull(buildDependencyPlaceholder, nameof(buildDependencyPlaceholder));
this.dataSource = dataSource;
this.lastTimeUsageStorage = lastTimeUsageStorage;
this.timeService = timeService;
this.analyticsEvent = analyticsEvent;
this.dependencyIdsSelector = dependencyIdsSelector;
this.buildDependencyPlaceholder = buildDependencyPlaceholder;
}
public static IObservable <T> Track <T, T1, TException>(this IObservable <T> observable, IAnalyticsEvent <T1> analyticsEvent, T1 parameter)
where TException : Exception
=> observable.Catch <T, TException>(exception =>
{
analyticsEvent.Track(parameter);
return(Observable.Throw <T>(exception));
});
public static IObservable <T> Track <T, T1, T2>(this IObservable <T> observable, IAnalyticsEvent <T1, T2> analyticsEvent, T1 param1, T2 param2) => observable.Do(_ => analyticsEvent.Track(param1, param2));
public static IObservable <T> Track <T, T1>(this IObservable <T> observable, IAnalyticsEvent <T1> analyticsEvent, T1 parameter) => observable.Do(_ => analyticsEvent.Track(parameter));
public static IObservable <T> Track <T>(this IObservable <T> observable, IAnalyticsEvent <T> analyticsEvent) => observable.Do(analyticsEvent.Track);
private void trackStepOutcome(RatingViewOutcome outcome, IAnalyticsEvent specificEvent)
{
onboardingStorage.SetRatingViewOutcome(outcome, timeService.CurrentDateTime);
specificEvent.Track();
}
private void trackSecondStepOutcome(RatingViewOutcome outcome, RatingViewSecondStepOutcome genericEventParameter, IAnalyticsEvent specificEvent)
{
trackStepOutcome(outcome, specificEvent);
analyticsService.UserFinishedRatingViewSecondStep.Track(genericEventParameter);
}
public byte[] SerializeAnalyticsEvent(IAnalyticsEvent analyticsEvent, string instrumentationKey)
{
var eventTelemetry = new AppInsightsEventTelemetry(analyticsEvent, instrumentationKey);
return(Encoding.UTF8.GetBytes(eventTelemetry.ToJson()));
}
