/// <summary>
/// Get the file details for the specified resource
/// </summary>
/// <param name="resource">A resource to load</param>
/// <returns>File datails</returns>
private IResourceDetails GetFileDetails(IResource resource)
{
RetryPolicy retryPolicy = RetryPolicy ?? RetryPolicy.None;
RetryCounter retryCounter = new RetryCounter(retryPolicy);
int iteration = 0;
Tuple <ResourceReadStatus, IResourceDetails> finalStatus = retryCounter.Run(
() =>
{
iteration++;
ULSLogging.LogTraceTag(0x238208cd /* tag_9669n */, Categories.ConfigurationDataSet, Levels.Verbose,
"Attempting data set load for resource '{0}' in iteration '{1}' of '{2}'.",
resource.Name, iteration, retryPolicy.RetryLimit);
Tuple <ResourceReadStatus, IResourceDetails> status = resource.Read();
return(Tuple.Create(status.Item1 == ResourceReadStatus.Success, status));
});
if (finalStatus.Item1 != ResourceReadStatus.Success)
{
ULSLogging.LogTraceTag(0x238208ce /* tag_9669o */, Categories.ConfigurationDataSet, Levels.Warning,
"Failed to read resource '{0}' as the file read status is '{1}'.",
resource.Name, finalStatus);
return(null);
}
return(finalStatus.Item2);
}
/// <summary>
/// Retrieves the XML reader settings.
/// </summary>
/// <param name="type">The object type to read.</param>
/// <param name="schema">The schema to use.</param>
/// <param name="schemaUri">The schema URI to use.</param>
/// <returns>The relevant XML reader settings.</returns>
public static XmlReaderSettings GetXmlReaderSettings(this Type type, string schema, string schemaUri)
{
if (type == null)
{
ULSLogging.LogTraceTag(0x23820889 /* tag_9668j */, Categories.Common, Levels.Error,
"Null type value passed to GetXmlReaderSettings.");
return(null);
}
if (string.IsNullOrEmpty(schema))
{
ULSLogging.LogTraceTag(0x2382088a /* tag_9668k */, Categories.Common, Levels.Error,
"Null or empty schema value passed to GetXmlReaderSettings.");
return(null);
}
XmlSchemaSet schemas = new XmlSchemaSet();
using (XmlReader reader = XmlReader.Create(type.Assembly.GetManifestResourceStream(schema)))
{
schemas.Add(schemaUri, reader);
}
XmlReaderSettings settings = new XmlReaderSettings();
settings.ValidationType = ValidationType.Schema;
settings.Schemas = schemas;
return(settings);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="file">File adaptor</param>
/// <param name="folder">Folder</param>
/// <param name="name">File Name including extension</param>
public FileResource(IFile file, string folder, string name)
{
File = Code.ExpectsArgument(file, nameof(file), TaggingUtilities.ReserveTag(0x238208d2 /* tag_9669s */));
Folder = Code.ExpectsNotNullOrWhiteSpaceArgument(folder, nameof(folder), TaggingUtilities.ReserveTag(0x238208d3 /* tag_9669t */));
Name = Code.ExpectsNotNullOrWhiteSpaceArgument(name, nameof(name), TaggingUtilities.ReserveTag(0x238208d4 /* tag_9669u */));
bool locationSet = false;
try
{
if (!HasInvalidPathChars(Folder) && !HasInvalidPathChars(Name))
{
Location = Path.Combine(Folder, Name);
locationSet = true;
}
else
{
ULSLogging.LogTraceTag(0x238208d5 /* tag_9669v */, Categories.ConfigurationDataSet, Levels.Error,
"Failed to combine FileResource.Location for folder: '{0}', name: '{1}'", Folder, Name);
}
}
catch (ArgumentException exception)
{
ULSLogging.ReportExceptionTag(0x238208d6 /* tag_9669w */, Categories.ConfigurationDataSet, exception,
"Exception constructing FileResource for folder: '{0}', name: '{1}'", Folder, Name);
}
if (!locationSet)
{
Location = Name;
}
}
/// <summary>
/// Is the gate applicable for the current context
/// </summary>
/// <param name="gate">gate to check</param>
/// <returns>true if applicable, false otherwise</returns>
private bool IsGateApplicableInternal(IGate gate)
{
bool grantAccess = gate.IsGateEnabled;
// If the gate is disabled but has been asked to be enabled through settings.
if (m_settings?.GatesToggleEnabled?.Contains(gate.Name) ?? false)
{
grantAccess = true;
ULSLogging.LogTraceTag(0x2382104e /* tag_967bo */, Categories.GateSelection, Levels.Verbose, "Enabling gate '{0}' through BRS that was disabled using gate toggle setting",
gate.Name);
}
grantAccess = grantAccess && DoesHostEnvironmentHaveAccess(gate);
grantAccess = grantAccess && DoesServiceHaveAccess(gate);
grantAccess = grantAccess && DoesIPAddressHaveAccess(gate);
grantAccess = grantAccess && DoesMarketHaveAccess(gate);
grantAccess = grantAccess && DoesEnvironmentHaveAccess(gate);
grantAccess = grantAccess && DoesBrowserHaveAccess(gate);
grantAccess = grantAccess && DoesClientHaveAccess(gate);
grantAccess = grantAccess && DoesUserHaveAccess(gate);
grantAccess = grantAccess && IsCurrentDateEnabled(gate);
grantAccess = grantAccess && DoQueryParametersHaveAccess(gate);
grantAccess = grantAccess && DoesCloudContextHaveAccess(gate);
if (gate.ExperimentInfo != null)
{
grantAccess = grantAccess && ExperimentContext.IsExperimentalGateApplicable(gate);
}
return(grantAccess);
}
/// <summary>
/// Attempts to load a new dataset and replaces the old one if load was successful
/// </summary>
/// <param name="arguments">The arguments for the update event.</param>
protected virtual void UpdateLoadedDataSet(ResourceUpdatedEventArgs arguments)
{
RunExclusiveAction action = AllowMultipleThreadsLoadingDataSet ? m_action : s_action;
action.Do(() =>
{
if (arguments.IsInitialLoad)
{
ULSLogging.LogTraceTag(0x23821004 /* tag_967ae */, Categories.ConfigurationDataSet, Levels.Verbose,
"Adding data set type '{0}' to cache.", typeof(T).Name);
if (Cache.GetOrAdd(typeof(IConfigurationDataSetLoader <T>),
() => CreateCachedConfigurationDataSet(new CachedConfigurationDataSet <T>(DataSetOverride), arguments),
out bool wasAdded) is CachedConfigurationDataSet <T> result && wasAdded)
{
OnLoad(result.LoadDetails);
}
}
else
{
ULSLogging.LogTraceTag(0x23850399 /* tag_97qoz */, Categories.ConfigurationDataSet, Levels.Verbose,
"Updating data set type '{0}' in cache.", typeof(T).Name);
CachedConfigurationDataSet <T> dataSets = DataSets;
IList <ConfigurationDataSetLoadDetails> loadDetails = dataSets.LoadDetails;
if (Cache.AddOrUpdate(typeof(IConfigurationDataSetLoader <T>),
() => CreateCachedConfigurationDataSet(dataSets, arguments),
out bool wasUpdated) is CachedConfigurationDataSet <T> result && wasUpdated)
{
OnReload(loadDetails, result.LoadDetails);
}
}
});
}
/// <summary>
/// Gets the experiment corresponding to the experimentName
/// </summary>
/// <param name="experimentName">The experiment name</param>
/// <returns>the experiment</returns>
public IExperiment GetExperiment(string experimentName)
{
if (!Code.ValidateNotNullOrWhiteSpaceArgument(experimentName, nameof(experimentName), TaggingUtilities.ReserveTag(0x23821085 /* tag_967cf */)))
{
return(null);
}
//This is to ensure threading
IDictionary <string, IExperiment> temporaryReadDictionary = ExperimentsDictionary;
if (temporaryReadDictionary == null)
{
ULSLogging.LogTraceTag(0x23821086 /* tag_967cg */, Categories.Experimentation, Levels.Error,
"Experiment dictionary is being returned null");
return(null);
}
if (!temporaryReadDictionary.ContainsKey(experimentName))
{
ULSLogging.LogTraceTag(0x23821087 /* tag_967ch */, Categories.Experimentation, Levels.Error,
"Trying to get gates for an unknown experiment '{0}'", experimentName);
return(null);
}
return(temporaryReadDictionary[experimentName]);
}
/// <summary>
/// Configure event replaying when a timed scope ends
/// </summary>
/// <param name="scope"></param>
public void ConfigureReplayEventsOnScopeEnd(TimedScope scope)
{
CorrelationData currentCorrelation = Correlation.CurrentCorrelation;
if (scope.IsSuccessful ?? false)
{
// assumption is that if any lower level scopes fail that should bubble up to the parent scope; if replay is enabled a previous scope has failed so
// log some telemetry to help us understand these mixed scenarios better / identify error handling bugs
if (currentCorrelation != null && currentCorrelation.ShouldReplayUls)
{
// ASSERTTAG_IGNORE_START
ULSLogging.LogTraceTag(0, Categories.TimingGeneral, Levels.Warning,
"Scope '{0}' succeeded even though a previous scope on this correlation failed.", scope.Name);
// ASSERTTAG_IGNORE_FINISH
}
}
else
{
// flip the replay switch on Scope failure for scenarios where its useful to get a verbose ULS trace in production
if (currentCorrelation != null &&
scope.Result.ShouldReplayEvents() &&
!scope.IsTransaction &&
!scope.ScopeDefinition.OnDemand &&
!scope.DisableVerboseUlsCapture &&
!DisabledTimedScopes.IsDisabled(scope.ScopeDefinition))
{
currentCorrelation.ShouldReplayUls = true;
currentCorrelation.ReplayPreviouslyCachedUlsEvents();
}
}
}
/// <summary>
/// Is the ip address of the request part of the gate criteria
/// </summary>
/// <param name="gate">gate</param>
/// <returns>true if the ip address of the request matches the gate criteria, false otherwise</returns>
private bool DoesIPAddressHaveAccess(IGate gate)
{
bool grantAccess = true;
HashSet <string> ipRanges = gate.KnownIPRanges;
if (ipRanges != null)
{
grantAccess = false;
foreach (string ipRange in ipRanges)
{
if (Request != null && Request.IsPartOfKnownIPRange(KnownIpAddresses, ipRange))
{
grantAccess = true;
break;
}
}
if (!grantAccess)
{
ULSLogging.LogTraceTag(0x23821058 /* tag_967by */, Categories.GateSelection, Levels.Verbose,
"Not allowing access to gate '{0}' as the ip address of the request is not in the set of allowed known ip ranges '{1}'.",
gate.Name ?? "<NULL>", string.Join(", ", ipRanges));
}
}
return(grantAccess);
}
/// <summary>
/// Are any of the current query parameters blocked by the gate critera?
/// </summary>
/// <param name="gate">gate</param>
/// <returns>true if no blocked query parameters match the requests query parmeters</returns>
private bool DoQueryParametersHaveAccess(IGate gate)
{
bool grantAccess = true;
IDictionary <string, HashSet <string> > blockedQueryParameters = gate.BlockedQueryParameters;
if (blockedQueryParameters != null && blockedQueryParameters.Count > 0)
{
IDictionary <string, HashSet <string> > requestsQueryParameters = Request?.QueryParameters;
//if no params exist on the request, then we grant access by default.
if (requestsQueryParameters == null || requestsQueryParameters.Count == 0)
{
ULSLogging.LogTraceTag(0x23821053 /* tag_967bt */, Categories.GateSelection, Levels.Verbose,
"Allowing access to gate '{0}' as the GatedRequest has no query parameters.",
gate.Name ?? "<NULL>");
return(grantAccess);
}
//if any request query param matches a blocked query param, we should not grant access.
foreach (string requestParameterName in requestsQueryParameters.Keys)
{
if (blockedQueryParameters.ContainsKey(requestParameterName))
{
//if the wild card '*' is specified as a value for a blocked param, then we restrict access
if (blockedQueryParameters[requestParameterName].Contains(Gate.BlockedQueryParameterValueWildCard))
{
grantAccess = false;
ULSLogging.LogTraceTag(0x23821054 /* tag_967bu */, Categories.GateSelection, Levels.Verbose,
"Not allowing access to gate '{0}' with the query parameter(s) '{1}'='{2}' as all parameters with name '{3}' are blocked by the wildcard '*'.",
gate.Name ?? "<NULL>",
requestParameterName,
requestsQueryParameters[requestParameterName],
requestParameterName);
break;
}
//if there's corresponding parameters in the request and the list of blocked, we do not grant access
IEnumerable <string> intersection = blockedQueryParameters[requestParameterName]
.Intersect(requestsQueryParameters[requestParameterName], StringComparer.OrdinalIgnoreCase);
if (intersection.Count() > 0)
{
grantAccess = false;
ULSLogging.LogTraceTag(0x23821055 /* tag_967bv */, Categories.GateSelection, Levels.Verbose,
"Not allowing access to gate '{0}' as the query parameter(s) '{1}'='{2}' is in the set of blocked query parameters '{3}'.",
gate.Name ?? "<NULL>",
requestParameterName,
string.Join(",", intersection),
string.Join(", ", blockedQueryParameters.Select(parameter => string.Format("'{0}={1}'", parameter.Key, parameter.Value))));
break;
}
}
}
}
return(grantAccess);
}
public void AddUlsLoggerAddapter_SubscribesToEvents()
{
Mock <ILogger> mockLogger = new Mock <ILogger>();
Mock <ILoggerFactory> mockFactory = new Mock <ILoggerFactory>();
mockFactory.Setup(f => f.CreateLogger(It.IsAny <string>())).Returns(mockLogger.Object);
new HostBuilder()
.ConfigureServices(collection =>
{
collection
.AddSingleton(mockFactory.Object)
.AddUlsLoggerAddapter();
})
.Build()
.Start();
uint eventId = 1;
Category category = new Category("Test");
Level logLevel = Levels.Error;
string logMessage = "TestLogMessage";
Exception exception = new Exception();
mockLogger.Invocations.Clear();
ULSLogging.LogTraceTag(eventId, category, logLevel, logMessage);
Assert.AreEqual(1, mockLogger.Invocations.Count, "ULSLogging.LogTraceTag not calling ILogger");
mockLogger.Invocations.Clear();
ULSLogging.ReportExceptionTag(eventId, category, exception, logMessage);
Assert.AreEqual(1, mockLogger.Invocations.Count, "ULSLogging.ReportExceptionTag not calling ILogger");
}
/// <summary>
/// Stop monitoring the resources.
/// </summary>
public void StopMonitoring(ResourceUpdatedHandler callback)
{
if (!m_resourceMonitoringData.TryRemove(callback, out ResourceMonitoringData monitoringInstance))
{
ULSLogging.LogTraceTag(0x238208cb /* tag_9669l */, Categories.ConfigurationDataSet, Levels.Verbose,
"An attempt to remove a non-existing handler");
}
}
/// <summary>
/// Log a code error. This raises a ShipAssert event
/// </summary>
/// <param name="tag">tag</param>
/// <param name="category">category</param>
/// <param name="skipLog">should the logging be skipped</param>
/// <param name="addToLoadingErrors">add to dataset loading errors</param>
/// <param name="message">message</param>
/// <param name="parameters">message format parameters</param>
public void LogCodeErrorTag(uint tag, Category category, bool skipLog, bool addToLoadingErrors, string message, params object[] parameters)
{
ULSLogging.LogTraceTag(tag, category, Levels.Error, message, parameters);
if (addToLoadingErrors)
{
LogError(message, parameters);
}
}
/// <summary>
/// Updates DataSet on resources change event
/// </summary>
/// <param name="arguments">event arguments</param>
/// <remarks>Since this may be called on a background thread without a current correlation,
/// start a new correlation if one does not already exist</remarks>
protected virtual void OnResourceUpdated(ResourceUpdatedEventArgs arguments)
{
ULSLogging.LogTraceTag(0x23821005 /* tag_967af */, Categories.ConfigurationDataSet, Levels.Verbose,
"'{0}' loader encountered an event for resources '{1}'.",
typeof(T).Name, string.Join(";", arguments.Details.Select(d => d.Key)));
UpdateLoadedDataSet(arguments);
DataSetLoaded?.Invoke(this, EventArgs.Empty);
}
/// <summary>
/// Merge two gated clients
/// </summary>
/// <param name="client1">first client</param>
/// <param name="client2">second client</param>
/// <returns>merged gated client</returns>
/// <remarks>The name must be the same on both clients. The Version returned is the
/// greatest version of the two clients. If one or no client has a product code, that
/// code is used, if both have a product code, the code from the client with the greatest
/// version is used.</remarks>
public static GatedClient MergeClient(GatedClient client1, GatedClient client2)
{
if (client1 == null)
{
return(client2);
}
if (client2 == null)
{
return(client1);
}
if (!string.Equals(client1.Name, client2.Name, StringComparison.OrdinalIgnoreCase))
{
ULSLogging.LogTraceTag(0x23821047 /* tag_967bh */, Categories.GateSelection, Levels.Error,
"The name of the clients must be the same. Client1 '{0}', Client2 '{1}'.",
client1.Name, client2.Name);
return(null);
}
GatedClient mergedClient = new GatedClient
{
Name = client1.Name
};
if (client1.Version == null)
{
mergedClient.Version = client2.Version;
mergedClient.ProductCode = client2.ProductCode ?? client1.ProductCode;
mergedClient.AppCode = client2.AppCode;
mergedClient.AudienceGroups = client2.AudienceGroups;
}
else if (client2.Version == null)
{
mergedClient.Version = client1.Version;
mergedClient.ProductCode = client1.ProductCode ?? client2.ProductCode;
mergedClient.AppCode = client1.AppCode;
mergedClient.AudienceGroups = client1.AudienceGroups;
}
else if (client1.Version > client2.Version)
{
mergedClient.Version = client1.Version;
mergedClient.ProductCode = client1.ProductCode ?? client2.ProductCode;
mergedClient.AppCode = client1.AppCode;
mergedClient.AudienceGroups = client1.AudienceGroups;
}
else
{
mergedClient.Version = client2.Version;
mergedClient.ProductCode = client2.ProductCode ?? client1.ProductCode;
mergedClient.AppCode = client2.AppCode;
mergedClient.AudienceGroups = client2.AudienceGroups;
}
return(mergedClient);
}
/// <summary>
/// Log trace tag. This raises a LogEvent of a specified level.
/// </summary>
/// <param name="tagid">tag</param>
/// <param name="category">category</param>
/// <param name="level">level to log at</param>
/// <param name="addToLoadingErrors">add to dataset loading errors</param>
/// <param name="message">message</param>
/// <param name="parameters">message format parameters</param>
public void LogTraceTag(uint tagid, Category category, Level level, bool addToLoadingErrors, string message,
params object[] parameters)
{
ULSLogging.LogTraceTag(tagid, category, level, message, parameters);
if (addToLoadingErrors)
{
LogError(message, parameters);
}
}
/// <summary>
/// End the timed scope
/// </summary>
public void End()
{
if (IsDisposed)
{
ULSLogging.LogTraceTag(0x238174df /* tag_96xt5 */, Categories.TimingGeneral, Levels.Error,
"Attempting to end scope '{0}' that has already been disposed.", Name);
return;
}
EndScope(MachineInformation);
}
/// <summary>
/// Logs document db response info to ULS.
/// </summary>
/// <param name="caller">Caller function name. No need to specify explicitly, will be set automatically on run time.</param>
/// <param name="activityId">Document db activity id.</param>
/// <param name="charge">Charge in RU s.</param>
/// <param name="statusCode">Status code or the response.</param>
/// <param name="contentLocation">Location of the documentdb resource.</param>
/// <param name="tagId">ULS tag.</param>
private static void LogInfo(
string caller, string activityId, double charge, int statusCode, string contentLocation, uint tagId)
{
ULSLogging.LogTraceTag(tagId, Categories.DocumentDb, Levels.Info,
"Operation: {0} Cost: {1} ContentLocation: {2} StatusCode: {3} ActivityId: {4}",
caller,
charge,
contentLocation,
statusCode,
activityId);
}
private static string SanitizeString(string mdmString, string name, string activityName, Category logCategory)
{
string validatedString = Convert.ToString(mdmString, CultureInfo.InvariantCulture) ?? string.Empty;
if (validatedString.Length > 1024)
{
ULSLogging.LogTraceTag(0x23857681 /* tag_97x0b */, logCategory, Levels.Warning, StringLimitMessage, 1024, name, activityName, validatedString.Length);
validatedString = validatedString.Substring(0, 1024);
}
return(validatedString);
}
/// <summary>
/// Does the service have access.
/// </summary>
/// <param name="gate">The gate.</param>
/// <returns>true if service has access, false otherwise.</returns>
private bool DoesServiceHaveAccess(IGate gate)
{
bool grantAccess = true;
IDictionary <string, GatedServiceTypes> services = gate.Services;
// If gate doesn't expect service based gating, grant access.
if (services != null)
{
GatedServiceTypes serviceFlag;
string serviceName = MachineInformation.ServiceName;
if (services.TryGetValue(serviceName, out serviceFlag))
{
switch (serviceFlag)
{
// GrantAccess if gate will be applicable for both Full & Canary Services.
case GatedServiceTypes.All:
break;
// GrantAccess only when its a full(non-canary service).
case GatedServiceTypes.FullService:
grantAccess = !MachineInformation.IsCanary;
break;
// GrantAccess only when its a canary service.
case GatedServiceTypes.CanaryService:
grantAccess = MachineInformation.IsCanary;
break;
// Deny Access if service flag is none.
case GatedServiceTypes.None:
grantAccess = false;
break;
}
}
else
{
// If gate expects a service but current machine is not running that service or there's no service
// either because no service was mentioned within service tag in gate or consolidation yielded zero service,
// deny access in all cases.
grantAccess = false;
}
if (!grantAccess)
{
ULSLogging.LogTraceTag(0x23821057 /* tag_967bx */, Categories.GateSelection, Levels.Verbose,
"Not allowing access to gate '{0}' as '{1}' did not match the required criteria.",
gate.Name ?? "<NULL>", serviceName ?? "<NULL>");
}
}
return(grantAccess);
}
/// <summary>
/// Checks the gate's applicability based on the user agent browser. This is a common method which checks gate's applicability for
/// both allowed browsers and blocked browsers.
/// </summary>
/// <param name="browsers">The browsers.</param>
/// <returns>true if gate's applicability based on constraints is confirmed, false otherwise.</returns>
private bool CheckGateApplicabilityForBrowser(IDictionary <string, HashSet <int> > browsers)
{
Tuple <string, int> browser = Request?.GetUserAgentBrowser();
if (browser == null)
{
ULSLogging.LogTraceTag(0x2382105c /* tag_967b2 */, Categories.GateSelection, Levels.Verbose,
"HttpRequest object doesn't have any browser, which means request not made from a browser.");
// Request not made from a browser.
return(false);
}
if (!browsers.TryGetValue(browser.Item1, out HashSet <int> browserVersion))
{
ULSLogging.LogTraceTag(0x2382105d /* tag_967b3 */, Categories.GateSelection, Levels.Verbose,
"Gate expects a different browser than the one from which the request was made.");
// Gate expects different browser, hence return false.
return(false);
}
if (browserVersion == null)
{
ULSLogging.LogTraceTag(0x2382105e /* tag_967b4 */, Categories.GateSelection, Levels.Verbose,
"Gate doesn't contain any browser version, which means all the versions apply.");
// No constraint set on the browser's version, hence return true.
return(true);
}
if (browserVersion.Count == 0)
{
ULSLogging.LogTraceTag(0x2382105f /* tag_967b5 */, Categories.GateSelection, Levels.Verbose,
"Gate doesn't contain any browser version, which means all the versions apply.");
// No constraint set on the browser's version, hence return true.
return(true);
}
if (!browserVersion.Contains(browser.Item2))
{
ULSLogging.LogTraceTag(0x23821060 /* tag_967b6 */, Categories.GateSelection, Levels.Verbose,
"Gate expects a different browser version than the one from which the request was made.");
// Browser versions not compatible, return false.
return(false);
}
return(true);
}
/// <summary>
/// Loads DataSet and starts resources monitoring
/// </summary>
/// <param name="resources">resources</param>
protected virtual void Initialize(IEnumerable <IResource> resources)
{
Resources = Code.ExpectsArgument(resources, nameof(resources), TaggingUtilities.ReserveTag(0x23821001 /* tag_967ab */));
if (!m_resourceMonitor.TryStartMonitoring(Resources, OnResourceUpdated))
{
ULSLogging.LogTraceTag(0x23821002 /* tag_967ac */, Categories.ConfigurationDataSet, Levels.Error,
"Failed to start resources monitoring for {0}", typeof(T).Name);
}
else
{
ULSLogging.LogTraceTag(0x23821003 /* tag_967ad */, Categories.ConfigurationDataSet, Levels.Verbose,
"Successfully started resource monitoring for {0}", typeof(T).Name);
}
}
public void AddOmexCompatibilityServices_RegisterTypes()
{
Mock <ILogger> mockLogger = new Mock <ILogger>();
Mock <ILoggerFactory> mockFactory = new Mock <ILoggerFactory>();
mockFactory.Setup(f => f.CreateLogger(It.IsAny <string>())).Returns(mockLogger.Object);
new HostBuilder()
.ConfigureServices(collection =>
{
collection
.AddTimedScopes()
.AddSingleton(mockFactory.Object)
.AddOmexCompatibilityServices();
})
.Build()
.Start();
EventId eventId = new EventId(1);
Category category = new Category("Test");
LogLevel logLevel = LogLevel.Error;
string logMessage = "TestLogMessage";
Exception exception = new Exception();
mockLogger.Invocations.Clear();
ULSLogging.LogTraceTag(eventId, category, logLevel, logMessage);
Assert.AreEqual(1, mockLogger.Invocations.Count, "ULSLogging.LogTraceTag not calling ILogger");
mockLogger.Invocations.Clear();
ULSLogging.ReportExceptionTag(eventId, category, exception, logMessage);
Assert.AreEqual(1, mockLogger.Invocations.Count, "ULSLogging.ReportExceptionTag not calling ILogger");
mockLogger.Invocations.Clear();
Code.Validate(false, logMessage, eventId);
Assert.AreEqual(1, mockLogger.Invocations.Count, "Code.Validate not calling ILogger");
using (TimedScope startedTimedScope = new TimedScopeDefinition("TestStartedTimedScope").Create(TimedScopeResult.SystemError))
{
AssertResult(ActivityResultStrings.SystemError);
}
using (TimedScope notStartedTimedScope = new TimedScopeDefinition("TestNotStartedTimedScope").Create(TimedScopeResult.ExpectedError, false))
{
notStartedTimedScope.Start();
AssertResult(ActivityResultStrings.ExpectedError);
}
}
/// <summary>
/// Retrieves currently loaded TestGroups DataSet
/// </summary>
/// <returns>Currently loaded TestGroups DataSet</returns>
private ITestGroupsDataSet GetTestGroupsDataSet()
{
ITestGroupsDataSet dataSet = m_testGroupsDataSetLoader.LoadedDataSet;
if (dataSet == null)
{
ULSLogging.LogTraceTag(0x238210c0 /* tag_967da */, Categories.TestGroupsDataSet, Levels.Error,
"TestGroupsDataSet is null, TestGroups authentication will fail.");
}
else if (!dataSet.IsHealthy)
{
ULSLogging.LogTraceTag(0x238210c1 /* tag_967db */, Categories.TestGroupsDataSet, Levels.Error,
"TestGroupsDataSet is not healthy.");
}
return(dataSet);
}
/// <summary>
/// Logs the scope end to ULS
/// </summary>
private void LogEnd(IMachineInformation machineInformation)
{
if (!IsSuccessful.HasValue)
{
ULSLogging.LogTraceTag(0x238174e3 /* tag_96xt9 */, Categories.TimingGeneral, Levels.Warning,
"Result not set for scope {0}. Considered as SystemError", Name);
Result = TimedScopeResult.SystemError;
FailureDescription = InternalFailureDescription.UnknownResultAsSystemError;
}
CorrelationData scopeData = ConstructCorrelationDataEntries(machineInformation);
ScopeLogger.LogScopeEnd(this, scopeData);
ReplayEventConfigurator.ConfigureReplayEventsOnScopeEnd(this);
}
/// <summary>
/// Is experiment valid
/// </summary>
/// <param name="experimentName">experiment name</param>
/// <returns>true if the list of experiment contains the experiment</returns>
public bool IsValidExperiment(string experimentName)
{
if (!Code.ValidateNotNullOrWhiteSpaceArgument(experimentName, nameof(experimentName), TaggingUtilities.ReserveTag(0x23821083 /* tag_967cd */)))
{
return(false);
}
IDictionary <string, IExperiment> temporaryReadDictionary = ExperimentsDictionary;
if (temporaryReadDictionary == null)
{
ULSLogging.LogTraceTag(0x23821084 /* tag_967ce */, Categories.Experimentation, Levels.Error,
"Experiment dictionary is being returned null");
return(false);
}
return(temporaryReadDictionary.ContainsKey(experimentName));
}
/// <summary>
/// Create a dictionary of resources details in the format in which handlers expect it
/// </summary>
/// <param name="allKnownDetails">Resource details</param>
/// <returns>Mapping of resource names to details</returns>
private IDictionary <string, IResourceDetails> CreateResourceSetDetails(IDictionary <IResource, IResourceDetails> allKnownDetails)
{
IDictionary <string, IResourceDetails> result = new Dictionary <string, IResourceDetails>();
foreach (IResource resource in m_trackedResources)
{
if (!allKnownDetails.ContainsKey(resource))
{
ULSLogging.LogTraceTag(0x238208c8 /* tag_9669i */, Categories.ConfigurationDataSet, Levels.Error,
"Resource details for '{0}' are not present although it should've been loaded at this stage", resource.Name);
continue;
}
result[resource.Name] = allKnownDetails[resource];
}
return(result);
}
/// <summary>
/// Loads embedded resource
/// </summary>
/// <param name="resourceName">Resource name</param>
/// <param name="type">Type to determine assembly</param>
/// <returns>Resource contents as string</returns>
public static string GetEmbeddedResourceAsString(string resourceName, Type type)
{
using (Stream stream = type.Assembly.GetManifestResourceStream(resourceName))
{
if (stream == null)
{
ULSLogging.LogTraceTag(0x23821040 /* tag_967ba */, Categories.Infrastructure,
Levels.Error, "Cannot find embedded resource '{0}' in assembly '{1}'.",
resourceName, type.Assembly);
return(null);
}
using (StreamReader reader = new StreamReader(stream))
{
return(reader.ReadToEnd());
}
}
}
/// <summary>
/// Loads an embedded resource and returns as a string
/// </summary>
/// <param name="assembly">The assembly to load from</param>
/// <param name="resourceName">Name of the embedded resource</param>
/// <returns>Resource as string, or null if not found</returns>
public static string LoadEmbeddedResourceAsString(this Assembly assembly, string resourceName)
{
if (!Code.ValidateArgument(assembly, nameof(assembly), TaggingUtilities.ReserveTag(0x23820895 /* tag_9668v */)) ||
!Code.ValidateNotNullOrWhiteSpaceArgument(resourceName, nameof(resourceName), TaggingUtilities.ReserveTag(0x23820896 /* tag_9668w */)))
{
return(null);
}
string[] resources = assembly.GetManifestResourceNames();
if (!Array.Exists(resources, name => string.Equals(name, resourceName, StringComparison.Ordinal)))
{
// try resolving partial name
string[] matches = Array.FindAll(resources, name => name.StartsWith(resourceName, StringComparison.Ordinal));
if (matches.Length == 1)
{
resourceName = matches[0];
}
else
{
ULSLogging.LogTraceTag(0x23820897 /* tag_9668x */, Categories.Infrastructure, Levels.Error,
"Embedded resource '{0}' was not found in '{1}'.", resourceName, assembly.FullName);
return(null);
}
}
using (Stream stream = assembly.GetManifestResourceStream(resourceName))
{
if (stream == null)
{
ULSLogging.LogTraceTag(0x23820898 /* tag_9668y */, Categories.Infrastructure, Levels.Error,
"Embedded resource '{0}' could not be loaded from '{1}'.", resourceName, assembly.FullName);
return(null);
}
using (StreamReader reader = new StreamReader(stream))
{
return(reader.ReadToEnd());
}
}
}
/// <summary>
/// Loads DataSet
/// </summary>
/// <param name="arguments">The arguments for the update event.</param>
/// <returns>Loaded DataSet</returns>
private TDataSet LoadDataSet(ResourceUpdatedEventArgs arguments)
{
ULSLogging.LogTraceTag(0x2382100c /* tag_967am */, Categories.ConfigurationDataSet, Levels.Verbose,
"Loading data set for '{0}'.", typeof(TDataSet).Name);
TDataSet dataSet = m_dataSetDefault ?? new TDataSet();
try
{
dataSet.Load(arguments.Details);
}
catch (Exception exception)
{
ULSLogging.ReportExceptionTag(0x2382100d /* tag_967an */, Categories.ConfigurationDataSet, exception,
"Exception encountered while loading '{0}'", typeof(TDataSet).Name);
}
return(dataSet);
}
/// <summary>
/// Decides whether the result is success
/// </summary>
/// <param name="result">The result</param>
/// <returns>Success flag (null if we don't know)</returns>
public static bool?IsSuccessful(this TimedScopeResult result)
{
switch (result)
{
case default(TimedScopeResult):
return(null);
case TimedScopeResult.Success:
return(true);
case TimedScopeResult.ExpectedError:
case TimedScopeResult.SystemError:
return(false);
default:
ULSLogging.LogTraceTag(0x23817701 /* tag_96x2b */, Categories.TimingGeneral, Levels.Error, "IsSuccessful status unknown for timed scope result {0}", result);
return(false);
}
}
