/// <summary>
/// Internal constructor for unit testing
/// </summary>
/// <param name="textWriterFactory"></param>
/// <param name="logFilePath"></param>
internal LocalFileLogger(ITextWriterFactory textWriterFactory, string logFilePath)
{
CodeContract.RequiresArgumentNotNullAndNotEmpty(logFilePath, "logFilePath");
CodeContract.RequiresArgumentNotNull <ITextWriterFactory>(textWriterFactory, "textWriterFactory");
FullLogPath = logFilePath;
this.textWriterFactory = textWriterFactory;
}
public void SetValue <T>(string key, T value)
{
CodeContract.RequiresArgumentNotNullAndNotEmpty(key, "key");
Tuple <string, string> pathComponents = GetPathComponents(key);
SetValueInternal(pathComponents.Item1, pathComponents.Item2, value);
}
private bool IsCachedFlightEnabledInternal(string flight, bool sendTriggeredEvent)
{
CodeContract.RequiresArgumentNotNullAndNotEmpty(flight, "flight");
RequiresNotDisposed();
flight = flight.ToLowerInvariant();
return(flightStatus.AddOrUpdate(flight, delegate(string key)
{
bool isEnabled = flightsProvider.Flights.Contains(key);
if (sendTriggeredEvent)
{
PostFlightRequestTelemetry(flight, isEnabled);
}
return new FlightStatus
{
IsEnabled = isEnabled,
WasTriggered = sendTriggeredEvent
};
}, delegate(string key, FlightStatus existingValue)
{
if (sendTriggeredEvent && !existingValue.WasTriggered)
{
PostFlightRequestTelemetry(flight, existingValue.IsEnabled);
existingValue.WasTriggered = true;
}
return existingValue;
}).IsEnabled);
}
public bool TryGetValue <T>(string collectionPath, string key, out T value)
{
CodeContract.RequiresArgumentNotNullAndNotEmpty(collectionPath, "collectionPath");
collectionPath = collectionPath.NormalizePath();
CodeContract.RequiresArgumentNotNullAndNotEmpty(key, "key");
return(GetValueInternal(collectionPath, key, default(T), out value));
}
/// <summary>
/// Get internal settings for the channel specified by its ID.
/// There are 3 states could be:
/// - explicitly enabled
/// - explicitly disabled
/// - undefined (no settings available)
/// </summary>
/// <param name="channelId"></param>
/// <returns></returns>
public virtual ChannelInternalSetting GetChannelSettings(string channelId)
{
CodeContract.RequiresArgumentNotNullAndNotEmpty(channelId, "channelId");
if (!TypeTools.TryConvertToInt(registryTools.GetRegistryValueFromCurrentUserRoot("Software\\Coding4Fun\\VisualStudio\\Telemetry\\Channels", channelId, (object)(-1)), out int result))
{
result = -1;
}
ChannelInternalSetting channelInternalSetting = ChannelInternalSetting.Undefined;
switch (result)
{
case 1:
channelInternalSetting = ChannelInternalSetting.ExplicitlyEnabled;
break;
case 0:
channelInternalSetting = ChannelInternalSetting.ExplicitlyDisabled;
break;
}
if (channelInternalSetting != ChannelInternalSetting.Undefined)
{
diagnosticTelemetry.LogRegistrySettings(string.Format(CultureInfo.InvariantCulture, "Channel.{0}", new object[1]
{
channelId
}), channelInternalSetting.ToString());
}
return(channelInternalSetting);
}
public bool PropertyExists(string collectionPath, string key)
{
CodeContract.RequiresArgumentNotNullAndNotEmpty(collectionPath, "collectionPath");
collectionPath = collectionPath.NormalizePath();
CodeContract.RequiresArgumentNotNullAndNotEmpty(key, "key");
return(((IRegistryTools)registryTools).GetRegistryValueFromCurrentUserRoot(collectionPath, key, (object)null) != null);
}
public void SetValue <T>(string collectionPath, string key, T value)
{
CodeContract.RequiresArgumentNotNullAndNotEmpty(collectionPath, "collectionPath");
collectionPath = collectionPath.NormalizePath();
CodeContract.RequiresArgumentNotNullAndNotEmpty(key, "key");
SetValueInternal(collectionPath, key, value);
}
public LocalFlightsProvider(IKeyValueStorage keyValueStorage, string flightsKey)
{
CodeContract.RequiresArgumentNotNull <IKeyValueStorage>(keyValueStorage, "keyValueStorage");
CodeContract.RequiresArgumentNotNullAndNotEmpty(flightsKey, "flightsKey");
this.keyValueStorage = keyValueStorage;
pathToSettings = PathToSettingsPrefix + flightsKey;
}
/// <summary>
/// Move property from the excluded property list to the event properties list
/// </summary>
/// <param name="propertyName"></param>
public void IncludePropertyToEvent(string propertyName)
{
CodeContract.RequiresArgumentNotNullAndNotEmpty(propertyName, "propertyName");
if (excludedProperties != null && TelemetryEvent != null && excludedProperties.TryGetValue(propertyName, out object value))
{
TelemetryEvent.Properties[propertyName] = value;
}
}
public RemoteFlightsProvider(IKeyValueStorage keyValueStorage, string flightsKey, IRemoteFileReaderFactory remoteFileFactory, IFlightsStreamParser flightsStreamParser)
: base(keyValueStorage, flightsStreamParser, 1800000)
{
CodeContract.RequiresArgumentNotNull <IRemoteFileReaderFactory>(remoteFileFactory, "remoteFileFactory");
CodeContract.RequiresArgumentNotNullAndNotEmpty(flightsKey, "flightsKey");
remoteFileReader = new Lazy <IRemoteFileReader>(() => remoteFileFactory.Instance());
this.flightsKey = flightsKey;
}
private async Task <bool> IsFlightEnabledInternalAsync(string flight, CancellationToken token, bool sendTriggeredEvent)
{
CodeContract.RequiresArgumentNotNullAndNotEmpty(flight, "flight");
RequiresNotDisposed();
await flightsProvider.WaitForReady(token).ConfigureAwait(false);
return(IsCachedFlightEnabledInternal(flight, sendTriggeredEvent));
}
public T GetValue <T>(string key, T defaultValue)
{
CodeContract.RequiresArgumentNotNullAndNotEmpty(key, "key");
Tuple <string, string> pathComponents = GetPathComponents(key);
GetValueInternal(pathComponents.Item1, pathComponents.Item2, defaultValue, out T value);
return(value);
}
public AFDFlightsProvider(IKeyValueStorage keyValueStorage, string flightsKey, IFlightsStreamParser flightsStreamParser, IExperimentationFilterProvider filterProvider, IHttpWebRequestFactory httpWebRequestFactory)
: base(keyValueStorage, flightsStreamParser, 1800000)
{
CodeContract.RequiresArgumentNotNullAndNotEmpty(flightsKey, "flightsKey");
CodeContract.RequiresArgumentNotNull <IExperimentationFilterProvider>(filterProvider, "filterProvider");
CodeContract.RequiresArgumentNotNull <IHttpWebRequestFactory>(httpWebRequestFactory, "httpWebRequestFactory");
this.filterProvider = filterProvider;
this.flightsKey = flightsKey;
this.httpWebRequestFactory = httpWebRequestFactory;
}
/// <summary>
/// Remove property from the property list of the event and move it to the
/// excluded properties list
/// </summary>
/// <param name="propertyName"></param>
public void ExcludePropertyFromEvent(string propertyName)
{
CodeContract.RequiresArgumentNotNullAndNotEmpty(propertyName, "propertyName");
if (TelemetryEvent != null && TelemetryEvent.Properties.ContainsKey(propertyName))
{
if (excludedProperties == null)
{
excludedProperties = new Dictionary <string, object>();
}
excludedProperties[propertyName] = TelemetryEvent.Properties[propertyName];
TelemetryEvent.Properties.Remove(propertyName);
}
}
public bool ReadIsOptedInStatus(string productVersion)
{
CodeContract.RequiresArgumentNotNullAndNotEmpty(productVersion, "productVersion");
bool result = false;
if (TryGlobalPolicyOptedInStatus(out bool optedIn))
{
result = optedIn;
}
else
{
int?registryIntValueFromLocalMachineRoot = ((IRegistryTools)registryTools).GetRegistryIntValueFromLocalMachineRoot(string.Format(CultureInfo.InvariantCulture, "Software\\Microsoft\\VSCommon\\{0}\\SQM", new object[1]
{
productVersion
}), "OptIn", (int?)null);
if (registryIntValueFromLocalMachineRoot.HasValue)
{
result = (registryIntValueFromLocalMachineRoot.Value == 1);
}
}
return(result);
}
public override ChannelInternalSetting GetChannelSettings(string channelId)
{
CodeContract.RequiresArgumentNotNullAndNotEmpty(channelId, "channelId");
int num = -1;
try
{
JToken val = default(JToken);
if (channelSettingsJson != null && channelSettingsJson.TryGetValue(channelId, StringComparison.OrdinalIgnoreCase, out val))
{
string a = ((object)val).ToString();
if (a == "enabled")
{
num = 1;
}
if (a == "disabled")
{
num = 0;
}
}
}
catch
{
num = -1;
}
switch (num)
{
case 1:
return(ChannelInternalSetting.ExplicitlyEnabled);
case 0:
return(ChannelInternalSetting.ExplicitlyDisabled);
default:
return(base.GetChannelSettings(channelId));
}
}
public bool TryGetValueKind(string collectionPath, string key, out ValueKind kind)
{
CodeContract.RequiresArgumentNotNullAndNotEmpty(collectionPath, "collectionPath");
collectionPath = collectionPath.NormalizePath();
CodeContract.RequiresArgumentNotNullAndNotEmpty(key, "key");
kind = ValueKind.Unknown;
RegistryValueKind registryValueKind = default(RegistryValueKind);
if (registryTools.TryGetRegistryValueKindFromCurrentUserRoot(collectionPath, key, out registryValueKind))
{
switch (registryValueKind)
{
case RegistryValueKind.DWord:
kind = ValueKind.DWord;
break;
case RegistryValueKind.QWord:
kind = ValueKind.QWord;
break;
case RegistryValueKind.MultiString:
kind = ValueKind.MultiString;
break;
case RegistryValueKind.String:
kind = ValueKind.String;
break;
default:
kind = ValueKind.Unknown;
break;
}
return(true);
}
return(false);
}
public bool DeleteProperty(string collectionPath, string propertyName)
{
CodeContract.RequiresArgumentNotNullAndNotEmpty(collectionPath, "collectionPath");
CodeContract.RequiresArgumentNotNullAndNotEmpty(propertyName, "propertyName");
return(((IRegistryTools2)registryTools).DeleteRegistryValueFromCurrentUserRoot(collectionPath, propertyName));
}
public IEnumerable <string> GetPropertyNames(string collectionPath)
{
CodeContract.RequiresArgumentNotNullAndNotEmpty(collectionPath, "collectionPath");
collectionPath = collectionPath.NormalizePath();
return(((IRegistryTools2)registryTools).GetRegistryValueNamesFromCurrentUserRoot(collectionPath));
}
public void AddPassthroughEventName(string eventName)
{
CodeContract.RequiresArgumentNotNullAndNotEmpty(eventName, "eventName");
passthroughEvents.Add(eventName);
}
public SetFlightsProvider(IKeyValueStorage keyValueStorage, string flightsKey)
{
CodeContract.RequiresArgumentNotNull <IKeyValueStorage>(keyValueStorage, "keyValueStorage");
CodeContract.RequiresArgumentNotNullAndNotEmpty(flightsKey, "flightsKey");
cachedFlightsProvider = new Lazy <LocalFlightsProvider>(() => new LocalFlightsProvider(keyValueStorage, flightsKey));
}
/// <summary>
/// Log registry settings using key/value pair.
/// settingsName - suffix for the settings property.
/// </summary>
/// <param name="settingsName"></param>
/// <param name="value"></param>
public void LogRegistrySettings(string settingsName, string value)
{
CodeContract.RequiresArgumentNotNullAndNotEmpty(settingsName, "settingsName");
CodeContract.RequiresArgumentNotNullAndNotEmpty(value, "value");
registrySettings["VS.TelemetryApi.RegistrySettings." + settingsName] = value;
}
/// <summary>
/// Reads and set VS OptIn status.
/// </summary>
/// <param name="productVersion">VS product version so it is possible to build settings path</param>
public void UseVsIsOptedIn(string productVersion)
{
CodeContract.RequiresArgumentNotNullAndNotEmpty(productVersion, "productVersion");
IsOptedIn = optinStatusReader.ReadIsOptedInStatus(productVersion);
}
public bool CollectionExists(string collectionPath)
{
CodeContract.RequiresArgumentNotNullAndNotEmpty(collectionPath, "collectionPath");
collectionPath = collectionPath.NormalizePath();
return(((IRegistryTools2)registryTools).DoesRegistryKeyExistInCurrentUserRoot(collectionPath));
}
