public void DotnetNugetCommandFirstArgumentShouldBeSentToTelemetry()
{
const string argumentToSend = "push";
string[] args = { "nuget", argumentToSend, "path" };
Cli.Program.ProcessArgs(args);
_fakeTelemetry
.LogEntries.Should()
.Contain(e => e.EventName == "sublevelparser/command" &&
e.Properties.ContainsKey("argument") &&
e.Properties["argument"] == Sha256Hasher.Hash(argumentToSend.ToUpper()) &&
e.Properties.ContainsKey("verb") &&
e.Properties["verb"] == Sha256Hasher.Hash("NUGET"));
}
public void DotnetBuildAndPublishCommandOpinionsShouldBeSentToTelemetry()
{
const string optionKey = "configuration";
const string optionValueToSend = "Debug";
string[] args = { "build", "--" + optionKey, optionValueToSend };
Cli.Program.ProcessArgs(args);
_fakeTelemetry
.LogEntries.Should()
.Contain(e => e.EventName == "sublevelparser/command" &&
e.Properties.ContainsKey(optionKey) &&
e.Properties[optionKey] == Sha256Hasher.Hash(optionValueToSend.ToUpper()) &&
e.Properties.ContainsKey("verb") &&
e.Properties["verb"] == Sha256Hasher.Hash("BUILD"));
}
public void DotnetPublishCommandRuntimeOpinionsShouldBeSentToTelemetry()
{
const string optionKey = "runtime";
const string optionValueToSend = "win10-x64";
string[] args = { "publish", "--" + optionKey, optionValueToSend };
Cli.Program.ProcessArgs(args);
_fakeTelemetry
.LogEntries.Should()
.Contain(e => e.EventName == "sublevelparser/command" &&
e.Properties.ContainsKey(optionKey) &&
e.Properties[optionKey] == Sha256Hasher.Hash(optionValueToSend.ToUpper()) &&
e.Properties.ContainsKey("verb") &&
e.Properties["verb"] == Sha256Hasher.Hash("PUBLISH"));
}
public void AnyDotnetCommandVerbosityOpinionShouldBeSentToTelemetry()
{
const string optionKey = "verbosity";
const string optionValueToSend = "minimal";
string[] args = { "restore", "--" + optionKey, optionValueToSend };
Cli.Program.ProcessArgs(args);
_fakeTelemetry
.LogEntries.Should()
.Contain(e => e.EventName == "sublevelparser/command" &&
e.Properties.ContainsKey(optionKey) &&
e.Properties[optionKey] == Sha256Hasher.Hash(optionValueToSend.ToUpper()) &&
e.Properties.ContainsKey("verb") &&
e.Properties["verb"] == Sha256Hasher.Hash("RESTORE"));
}
public void TopLevelCommandNameShouldBeSentToTelemetryWithZeroPerformanceData()
{
var parseResult = Parser.Instance.Parse(new List <string>()
{
"build"
});
TelemetryEventEntry.SendFiltered(Tuple.Create(parseResult, new Dictionary <string, double>()
{
{ "Startup Time", 0 }
}));
_fakeTelemetry.LogEntries.Should().Contain(e => e.EventName == "toplevelparser/command" &&
e.Properties.ContainsKey("verb") &&
e.Properties["verb"] == Sha256Hasher.Hash("BUILD") &&
e.Measurement == null);
}
public void SubLevelCommandNameShouldBeSentToTelemetryWithoutPerformanceData()
{
var parseResult = Parser.Instance.Parse(new List <string>()
{
"new", "console"
});
TelemetryEventEntry.SendFiltered(parseResult);
_fakeTelemetry
.LogEntries.Should()
.Contain(e => e.EventName == "sublevelparser/command" &&
e.Properties.ContainsKey("argument") &&
e.Properties["argument"] == Sha256Hasher.Hash("CONSOLE") &&
e.Properties.ContainsKey("verb") &&
e.Properties["verb"] == Sha256Hasher.Hash("NEW") &&
e.Measurement == null);
}
public void DotnetNewCommandFirstArgumentShouldBeSentToTelemetryWithPerformanceData()
{
const string argumentToSend = "console";
string[] args = { "new", argumentToSend };
Cli.Program.ProcessArgs(args, new TimeSpan(23456));
_fakeTelemetry
.LogEntries.Should()
.Contain(e => e.EventName == "sublevelparser/command" &&
e.Properties.ContainsKey("argument") &&
e.Properties["argument"] == Sha256Hasher.Hash(argumentToSend.ToUpper()) &&
e.Properties.ContainsKey("verb") &&
e.Properties["verb"] == Sha256Hasher.Hash("NEW") &&
e.Measurement.ContainsKey("Startup Time") &&
e.Measurement["Startup Time"] == 2.3456 &&
e.Measurement.ContainsKey("Parse Time") &&
e.Measurement["Parse Time"] > 0);
}
public void DotnetRunCleanTestCommandOpinionsShouldBeSentToTelemetryWhenThereIsMultipleOption()
{
string[] args = { "clean", "--configuration", "Debug", "--framework", "netcoreapp1.0" };
Cli.Program.ProcessArgs(args);
_fakeTelemetry
.LogEntries.Should()
.Contain(e => e.EventName == "sublevelparser/command" && e.Properties.ContainsKey("configuration") &&
e.Properties["configuration"] == Sha256Hasher.Hash("DEBUG") &&
e.Properties.ContainsKey("verb") &&
e.Properties["verb"] == Sha256Hasher.Hash("CLEAN"));
_fakeTelemetry
.LogEntries.Should()
.Contain(e => e.EventName == "sublevelparser/command" && e.Properties.ContainsKey("framework") &&
e.Properties["framework"] == Sha256Hasher.Hash("NETCOREAPP1.0") &&
e.Properties.ContainsKey("verb") &&
e.Properties["verb"] == Sha256Hasher.Hash("CLEAN"));
}
public async Task ExecuteAsync_WithUnknownHeader_SendsTelemetryWithHashedHeaderName()
{
ArrangeInputs(parseResultSections: "set header name value",
out MockedShellState shellState,
out HttpState httpState,
out ICoreParseResult parseResult);
TelemetryCollector telemetry = new TelemetryCollector();
SetHeaderCommand setHeaderCommand = new SetHeaderCommand(telemetry);
await setHeaderCommand.ExecuteAsync(shellState, httpState, parseResult, CancellationToken.None);
Assert.Single(telemetry.Telemetry);
TelemetryCollector.CollectedTelemetry collectedTelemetry = telemetry.Telemetry[0];
Assert.Equal("SetHeader", collectedTelemetry.EventName);
Assert.Equal(Sha256Hasher.Hash("name"), collectedTelemetry.Properties["HeaderName"]);
Assert.Equal("False", collectedTelemetry.Properties["IsValueEmpty"]);
}
public void DotnetBuildAndPublishCommandOpinionsShouldBeSentToTelemetryWhenThereIsMultipleOption()
{
string[] args = { "build", "--configuration", "Debug", "--runtime", "osx.10.11-x64" };
Cli.Program.ProcessArgs(args);
_fakeTelemetry
.LogEntries.Should()
.Contain(e => e.EventName == "sublevelparser/command" && e.Properties.ContainsKey("configuration") &&
e.Properties["configuration"] == Sha256Hasher.Hash("DEBUG") &&
e.Properties.ContainsKey("verb") &&
e.Properties["verb"] == Sha256Hasher.Hash("BUILD"));
_fakeTelemetry
.LogEntries.Should()
.Contain(e => e.EventName == "sublevelparser/command" && e.Properties.ContainsKey("runtime") &&
e.Properties["runtime"] == Sha256Hasher.Hash("OSX.10.11-X64") &&
e.Properties.ContainsKey("verb") &&
e.Properties["verb"] == Sha256Hasher.Hash("BUILD"));
}
public void AnyDotnetCommandVerbosityOpinionShouldBeSentToTelemetryWithPerformanceData()
{
const string optionKey = "verbosity";
const string optionValueToSend = "minimal";
string[] args = { "restore", "--" + optionKey, optionValueToSend };
Cli.Program.ProcessArgs(args, new TimeSpan(34567));
_fakeTelemetry
.LogEntries.Should()
.Contain(e => e.EventName == "sublevelparser/command" &&
e.Properties.ContainsKey(optionKey) &&
e.Properties[optionKey] == Sha256Hasher.Hash(optionValueToSend.ToUpper()) &&
e.Properties.ContainsKey("verb") &&
e.Properties["verb"] == Sha256Hasher.Hash("RESTORE") &&
e.Measurement.ContainsKey("Startup Time") &&
e.Measurement["Startup Time"] == 3.4567 &&
e.Measurement.ContainsKey("Parse Time") &&
e.Measurement["Parse Time"] > 0);
}
public void SubLevelCommandNameShouldBeSentToTelemetryWithPerformanceData()
{
var parseResult = Parser.Instance.Parse(new List <string>()
{
"new", "console"
});
TelemetryEventEntry.SendFiltered(Tuple.Create(parseResult, new Dictionary <string, double>()
{
{ "Startup Time", 34567 }
}));
_fakeTelemetry.LogEntries.Should().Contain(e => e.EventName == "sublevelparser/command" &&
e.Properties.ContainsKey("argument") &&
e.Properties["argument"] == Sha256Hasher.Hash("CONSOLE") &&
e.Properties.ContainsKey("verb") &&
e.Properties["verb"] == Sha256Hasher.Hash("NEW") &&
e.Measurement.ContainsKey("Startup Time") &&
e.Measurement["Startup Time"] == 34567);
}
public void WhenCalledWithMissingArgumentWorkloadSubLevelCommandNameAndArgumentShouldBeSentToTelemetry()
{
var parseResult =
Parser.Instance.Parse(new List <string>()
{
"-d", "workload", "install"
});
TelemetryEventEntry.SendFiltered(Tuple.Create(parseResult,
new Dictionary <string, double>()
{
{ "Startup Time", 0 }, { "Parse Time", 23456 }
}));
_fakeTelemetry.LogEntries.Should().Contain(e => e.EventName == "sublevelparser/command" &&
e.Properties.ContainsKey("verb") &&
e.Properties["verb"] == Sha256Hasher.Hash("WORKLOAD") &&
e.Properties["subcommand"] ==
Sha256Hasher.Hash("INSTALL"));
}
internal static void FormatAndSend(ITelemetry telemetry, TelemetryEventArgs args)
{
if (args.EventName == TargetFrameworkTelemetryEventName)
{
var newEventName = $"msbuild/{TargetFrameworkTelemetryEventName}";
Dictionary <string, string> maskedProperties = new Dictionary <string, string>();
if (args.Properties.TryGetValue(TargetFrameworkVersionTelemetryPropertyKey, out string targetFrameworkVersionValue))
{
maskedProperties.Add(TargetFrameworkVersionTelemetryPropertyKey, Sha256Hasher.HashWithNormalizedCasing(targetFrameworkVersionValue));
}
telemetry.TrackEvent(newEventName, maskedProperties, measurements: null);
}
if (args.EventName == SdkTaskBaseCatchExceptionTelemetryEventName)
{
telemetry.TrackEvent(args.EventName, args.Properties, measurements: null);
}
}
public async Task ExecuteAsync_WithGetAndUnknownName_SendsTelemetryWithHashedName()
{
Arrange("pref set preferenceName value",
out HttpState httpState,
out MockedShellState shellState,
out ICoreParseResult parseResult,
out UserFolderPreferences preferences);
TelemetryCollector telemetry = new TelemetryCollector();
PrefCommand command = new PrefCommand(preferences, telemetry);
await command.ExecuteAsync(shellState, httpState, parseResult, CancellationToken.None);
Assert.Single(telemetry.Telemetry);
TelemetryCollector.CollectedTelemetry collectedTelemetry = telemetry.Telemetry[0];
Assert.Equal("Preference", collectedTelemetry.EventName);
Assert.Equal("Set", collectedTelemetry.Properties["GetOrSet"]);
Assert.Equal(Sha256Hasher.Hash("preferenceName"), collectedTelemetry.Properties["PreferenceName"]);
}
public void ItMasksTargetFrameworkEventname()
{
var fakeTelemetry = new FakeTelemetry();
var telemetryEventArgs = new TelemetryEventArgs
{
EventName = "targetframeworkeval",
Properties = new Dictionary <string, string>
{
{ "TargetFrameworkVersion", ".NETStandard,Version=v2.0" },
}
};
MSBuildLogger.FormatAndSend(fakeTelemetry, telemetryEventArgs);
fakeTelemetry.LogEntry.EventName.Should().Be("msbuild/targetframeworkeval");
fakeTelemetry.LogEntry.Properties.Keys.Count.Should().Be(1);
var expectedKey = "TargetFrameworkVersion";
fakeTelemetry.LogEntry.Properties.Should().ContainKey(expectedKey);
fakeTelemetry.LogEntry.Properties[expectedKey].Should().Be(Sha256Hasher.Hash(".NETSTANDARD,VERSION=V2.0"));
}
public void ToolsSubLevelCommandNameAndArgumentShouldBeSentToTelemetry()
{
var parseResult =
Parser.Instance.Parse(new List <string>()
{
"tool", "install", "dotnet-format"
});
TelemetryEventEntry.SendFiltered(Tuple.Create(parseResult,
new Dictionary <string, double>()
{
{ "Startup Time", 0 }, { "Parse Time", 23456 }
}));
_fakeTelemetry.LogEntries.Should().Contain(e => e.EventName == "sublevelparser/command" &&
e.Properties.ContainsKey("verb") &&
e.Properties["verb"] == Sha256Hasher.Hash("TOOL") &&
e.Properties["subcommand"] ==
Sha256Hasher.Hash("INSTALL") &&
e.Properties["argument"] ==
Sha256Hasher.Hash("DOTNET-FORMAT"));
}
public async Task InvokeAsync(HttpContext context, IAnalyticsService analyticsService, IExtremeIpLookup ipLookup, ICookieStorage cookies, ILogger <AnalyticsMiddleware> logger)
{
var ip = context.Connection.RemoteIpAddress;
try
{
var deats = await ipLookup.GetIpDetailsAsync(ip);
await deats.Match(o =>
{
var thumb = GetThumbPrint(cookies, context.Request, context.Response);
return(analyticsService.Add(
new Domain.AnalyticsReport(Guid.NewGuid(), DateTime.UtcNow, o.City,
Sha256Hasher.Hash(thumb.ToString())), CancellationToken.None));
}, _ => Task.CompletedTask);
}
catch (Exception e)
{
logger.LogError(e, "Error running analytics");
}
await this.next(context);
}
public async Task Jupyter_ignore_connection_file_sends_telemetry()
{
var tmp = Path.GetTempFileName();
try
{
// Do not capture connection file
await _parser.InvokeAsync(String.Format("jupyter {0}", tmp), _console);
_fakeTelemetry.LogEntries.Should().Contain(
x => x.EventName == "command" &&
x.Properties.Count == 2 &&
x.Properties["verb"] == Sha256Hasher.Hash("JUPYTER") &&
x.Properties["default-kernel"] == Sha256Hasher.Hash("CSHARP"));
}
finally
{
try
{
File.Delete(tmp);
}
catch { }
}
}
internal static void FormatAndSend(ITelemetry telemetry, TelemetryEventArgs args)
{
if (args.EventName == TargetFrameworkTelemetryEventName)
{
var newEventName = $"msbuild/{TargetFrameworkTelemetryEventName}";
Dictionary <string, string> maskedProperties = new Dictionary <string, string>();
if (args.Properties.TryGetValue(TargetFrameworkVersionTelemetryPropertyKey, out string targetFrameworkVersionValue))
{
maskedProperties.Add(TargetFrameworkVersionTelemetryPropertyKey, Sha256Hasher.HashWithNormalizedCasing(targetFrameworkVersionValue));
}
if (args.Properties.TryGetValue(UseWindowsFormsTelemetryPropertyKey, out string useWindowsFormsValue))
{
maskedProperties.Add(UseWindowsFormsTelemetryPropertyKey, SanitizeToOnlyTrueFalseEmpty(useWindowsFormsValue));
}
if (args.Properties.TryGetValue(UseWPFTelemetryPropertyKey, out string useWPFValue))
{
maskedProperties.Add(UseWPFTelemetryPropertyKey, SanitizeToOnlyTrueFalseEmpty(useWPFValue));
}
telemetry.TrackEvent(newEventName, maskedProperties, measurements: null);
}
}
public void HmacHash_ReturnsCorrectHash()
{
String actual = new Sha256Hasher().HmacHash("secretKey", "hello world");
Assert.AreEqual("a31288ecf77d266463fc7e2a63799cb1ce6dcff156610373f722fa298e932340", actual);
}
public void ItMasksEventNameWithTargetframeworkevalOnTargetFrameworkVersionUseWindowsFormsOrWPF()
{
var fakeTelemetry = new FakeTelemetry();
var telemetryEventArgs = new TelemetryEventArgs
{
EventName = MSBuildLogger.TargetFrameworkTelemetryEventName,
Properties = new Dictionary <string, string>
{
{ MSBuildLogger.TargetFrameworkVersionTelemetryPropertyKey, ".NETStandard,Version=v2.0" },
{ MSBuildLogger.UseWindowsFormsTelemetryPropertyKey, "true" },
{ MSBuildLogger.UseWPFTelemetryPropertyKey, "AnyNonTrueValue" },
}
};
MSBuildLogger.FormatAndSend(fakeTelemetry, telemetryEventArgs);
fakeTelemetry.LogEntry.EventName.Should().Be($"msbuild/{MSBuildLogger.TargetFrameworkTelemetryEventName}");
fakeTelemetry.LogEntry.Properties.Keys.Count.Should().Be(3);
fakeTelemetry.LogEntry.Properties[MSBuildLogger.TargetFrameworkVersionTelemetryPropertyKey].Should().Be(Sha256Hasher.Hash(".NETSTANDARD,VERSION=V2.0"));
fakeTelemetry.LogEntry.Properties[MSBuildLogger.UseWindowsFormsTelemetryPropertyKey].Should().Be("True");
fakeTelemetry.LogEntry.Properties[MSBuildLogger.UseWPFTelemetryPropertyKey]
.Should().Be(
"False",
"sanitize to avoid user input, and since in SDK prop and target non 'true' is effectively false");
}
/// <summary>
/// Generate a pseudo-random pipe name using the specified process ID, hashed MAC address and process path.
/// </summary>
/// <param name="processId">The process ID to use for generating the pipe name.</param>
/// <param name="values">Additional values to incorporate into the generated name.</param>
/// <returns>A string containing the pipe name.</returns>
public static string CreatePipeName(int processId, params string[] values)
{
// Reinvoking the host can cause differences between the original path, e.g.,
// "C:\Program Files" and "c:\Program Files". This will generate different UUID values and cause
// deadlock when the client and server are trying to connect, so always use the lower invariant of the process.
return(Uuid.Create($"{processId};{Environment.ProcessPath.ToLowerInvariant()};{Sha256Hasher.Hash(MacAddressGetter.GetMacAddress())};{string.Join(";", values)}")
.ToString("B"));
}
public void HmacHash_ReturnsCorrectHash()
{
String actual = new Sha256Hasher().HmacHash("secretKey", "hello world");
Assert.AreEqual("a31288ecf77d266463fc7e2a63799cb1ce6dcff156610373f722fa298e932340", actual);
}
public virtual void CalcHashes(Hashes hashFlags, Validations validationFlags)
{
if (IssueModel.Data.HasFatal)
{
return;
}
bool hitCache = Data.fBuf != null && Data.FileSize < Int32.MaxValue;
if ((hashFlags & Hashes.FileMD5) != 0 && Data.fileMD5 == null)
{
var hasher = new Md5Hasher();
if (hitCache)
{
hasher.Append(Data.fBuf, 0, Data.fBuf.Length);
}
else
{
hasher.Append(Data.fbs);
}
Data.fileMD5 = hasher.GetHashAndReset();
}
if ((hashFlags & Hashes.FileSHA1) != 0 && Data.fileSHA1 == null)
{
var hasher = new Sha1Hasher();
if (hitCache)
{
hasher.Append(Data.fBuf, 0, Data.fBuf.Length);
}
else
{
hasher.Append(Data.fbs);
}
Data.fileSHA1 = hasher.GetHashAndReset();
}
if ((hashFlags & Hashes.FileSHA256) != 0 && Data.fileSHA256 == null)
{
var hasher = new Sha256Hasher();
if (hitCache)
{
hasher.Append(Data.fBuf, 0, Data.fBuf.Length);
}
else
{
hasher.Append(Data.fbs);
}
Data.fileSHA256 = hasher.GetHashAndReset();
}
if ((hashFlags & Hashes.MediaSHA1) != 0 && Data.mediaSHA1 == null)
{
if (Data.MediaCount == Data.FileSize && Data.fileSHA1 != null)
{
System.Diagnostics.Debug.Assert(Data.mediaPosition == 0);
Data.mediaSHA1 = Data.fileSHA1;
}
else
{
var hasher = new Sha1Hasher();
if (hitCache)
{
hasher.Append(Data.fBuf, (int)Data.mediaPosition, (int)Data.MediaCount);
}
else
{
hasher.Append(Data.fbs, Data.mediaPosition, Data.MediaCount);
}
Data.mediaSHA1 = hasher.GetHashAndReset();
}
}
if ((hashFlags & Hashes.MetaSHA1) != 0 && Data.metaSHA1 == null)
{
var hasher = new Sha1Hasher();
var suffixPos = Data.mediaPosition + Data.MediaCount;
if (hitCache)
{
hasher.Append(Data.fBuf, 0, (int)Data.mediaPosition, (int)suffixPos, (int)(Data.FileSize - suffixPos));
}
else
{
hasher.Append(Data.fbs, 0, Data.mediaPosition, suffixPos, Data.FileSize - suffixPos);
}
Data.metaSHA1 = hasher.GetHashAndReset();
}
}
/// <summary>
/// Generate a pseudo-random pipe name using the specified process ID, hashed MAC address and process path.
/// </summary>
/// <param name="processId">The process ID to use for generating the pipe name.</param>
/// <param name="values">Additional values to incorporate into the generated name.</param>
/// <returns>A string containing the pipe name.</returns>
public static string CreatePipeName(int processId, params string[] values)
{
return(Uuid.Create($"{processId};{Environment.ProcessPath};{Sha256Hasher.Hash(MacAddressGetter.GetMacAddress())};{string.Join(";", values)}")
.ToString("B"));
}
public Client(Guid sessionid, ClientAppHostEnvironment host, UpdaterService updater)
{
if (Interactive.Client.CommandLineTool.TestDriver.ShouldRun)
{
return;
}
PreferenceStore.Default.Subscribe(ObservePreferenceChange);
try {
if (!Prefs.Telemetry.Enabled.GetValue())
{
Log.Info(TAG, "Telemetry is disabled");
return;
}
// InMemoryChannel is the default channel, but we set it up manually here so we can tweak several
// default settings that are undesirable for desktop apps.
channel = new InMemoryChannel {
// Defaults to 30s, but since we are changing buffer.Capacity to 1, we can make this infinite and
// avoid pointlessly waking up InMemoryTransmitter's Runner.
SendingInterval = Timeout.InfiniteTimeSpan,
};
// There is no reasonable public API for changing the buffer capacity at this time.
// You can achieve it by turning on DeveloperMode, but that has other consequences.
// So we reflect.
//
// The default Capacity is 500, which is far too large for us (and perhaps most non-server apps).
// We want to avoid having to perform a blocking Flush call on the UI thread, and since our events
// are currently few and far between, we set Capacity to 1 to essentially get auto-flush.
var channelBuffer = typeof(InMemoryChannel)
.GetField("buffer", BindingFlags.NonPublic | BindingFlags.Instance)
.GetValue(channel);
channelBuffer
.GetType()
.GetProperty("Capacity", BindingFlags.Public | BindingFlags.Instance)
.SetValue(channelBuffer, 1);
var config = new TelemetryConfiguration("@TELEMETRY_INSTRUMENTATION_KEY@", channel);
appInsightsClient = new TelemetryClient(config);
appInsightsClient.Context.Session.Id = sessionid.ToString();
appInsightsClient.Context.Device.OperatingSystem = host.OSName.ToString();
// TODO: Make these GlobalProperties when we bump to 2.7.0-beta3 or later
var globalProperties = appInsightsClient.Context.Properties;
globalProperties.Add(
"Product Version",
BuildInfo.VersionString);
globalProperties.Add(
"Build Hash",
BuildInfo.Hash);
globalProperties.Add(
"OS Platform",
Runtime.CurrentProcessRuntime.OSPlatform.ToString());
globalProperties.Add(
"OS Architecture",
RuntimeInformation.OSArchitecture.ToString());
globalProperties.Add(
"Process Architecture",
Runtime.CurrentProcessRuntime.Architecture.ToString());
globalProperties.Add(
"Runtime Identifier",
Runtime.CurrentProcessRuntime.RuntimeIdentifier);
globalProperties.Add(
"OS Version",
host.OSVersion.ToString());
globalProperties.Add(
"Release Candidate Level",
((byte)BuildInfo.Version.CandidateLevel).ToString());
globalProperties.Add(
"Release Candidate Level Name",
BuildInfo.Version.CandidateLevel.ToString().ToLowerInvariant());
globalProperties.Add(
"Machine ID",
Sha256Hasher.Hash(MacAddressGetter.GetMacAddress()));
globalProperties.Add(
"Update Channel", updater.UpdateChannel);
enabled = true;
} catch (Exception e) {
LogErrorWithoutTelemetry(e, "Unable to create AppInsights client for telemetry");
}
}
