public void TagCollections_IndexerGet_CaseInsensitive()
{
using (var scope = TagScopeManager.CreateScope())
{
scope.Tags.Add("TaG", "VaLuE");
Assert.AreEqual("VaLuE", scope.Tags["tAg"]);
Assert.AreEqual("VaLuE", scope.Tags["TaG"]);
Assert.AreEqual("VaLuE", scope.Tags["tag"]);
Assert.AreEqual("VaLuE", scope.Tags["TAG"]);
TestWithNestedScope();
scope.Tags.Clear();
scope.AssertOnTagCollectionCounts(0, 0, 0);
scope.Tags["TaG"] = "VaLuE";
Assert.AreEqual("VaLuE", scope.Tags["tAg"]);
Assert.AreEqual("VaLuE", scope.Tags["TaG"]);
Assert.AreEqual("VaLuE", scope.Tags["tag"]);
Assert.AreEqual("VaLuE", scope.Tags["TAG"]);
TestWithNestedScope();
}
}
public void TagCollections_TagValueInParentScopeMaskedWithNewTagValue()
{
const string tagKey = "tag";
using (var scope1 = TagScopeManager.CreateScope())
{
scope1.Tags.Add(tagKey, "1");
Assert.AreEqual("1", scope1.Tags[tagKey]);
Assert.AreEqual("1", scope1.EffectiveTags[tagKey]);
using (var scope2 = TagScopeManager.CreateScope())
{
scope2.Tags.Add(tagKey, "2");
Assert.AreEqual("2", scope2.Tags[tagKey]);
Assert.AreEqual("1", scope2.InheritedTags[tagKey]);
Assert.AreEqual("2", scope2.EffectiveTags[tagKey]);
using (var scope3 = TagScopeManager.CreateScope())
{
scope3.Tags.Add(tagKey, "3");
Assert.AreEqual("3", scope3.Tags[tagKey]);
Assert.AreEqual("2", scope3.InheritedTags[tagKey]);
Assert.AreEqual("3", scope3.EffectiveTags[tagKey]);
}
}
}
}
public void TagologExplicitOperationOnThreadCorrelationId()
{
using (var context = TagScopeManager.CreateScope())
{
ExplicitOperations(context);
}
}
/// <summary>
/// This fragment implemented as a separate method
/// to isolate nested scope from parent scope
/// and prevent some really annoying problems with
/// mess with acident "scope" and "nestedScope" calls
/// while they are in one method.
/// </summary>
static void TestWithNestedScope()
{
// ReSharper disable AccessToDisposedClosure
using (var nestedScope = TagScopeManager.CreateScope())
{
// Access to tag that does not exist.
// Expected result: ArgumentException( "The given tag key was not present in the tag collection." )
Assert.IsTrue(ExceptionTest.IsThrown <ArgumentException>(() =>
{
Assert.IsNull(nestedScope.Tags["not_a_tag"]);
}));
Assert.IsTrue(ExceptionTest.IsThrown <ArgumentException>(() =>
{
Assert.IsNull(nestedScope.InheritedTags["not_a_tag"]);
}));
Assert.IsTrue(ExceptionTest.IsThrown <ArgumentException>(() =>
{
Assert.IsNull(nestedScope.EffectiveTags["not_a_tag"]);
}));
}
// ReSharper restore AccessToDisposedClosure
}
/// <summary>
/// This fragment implemented as a separate method
/// to isolate nested scope from parent scope
/// and prevent some really annoying problems with
/// mess with acident "scope" and "nestedScope" calls
/// while they are in one method.
/// </summary>
static void TestWithNestedScope()
{
using ( var nestedScope = TagScopeManager.CreateScope() )
{
nestedScope.Tags.Add( "tag3", "value3" );
nestedScope.Tags.Add( "tag4", "value4" );
// Tags collection.
var keys = nestedScope.Tags.Keys;
Assert.AreEqual( 2, keys.Count );
Assert.IsTrue( keys.Contains( "tag3" ) );
Assert.IsTrue( keys.Contains( "tag4" ) );
// Inherited collection.
keys = nestedScope.InheritedTags.Keys;
Assert.AreEqual( 2, keys.Count );
Assert.IsTrue( keys.Contains( "tag1" ) );
Assert.IsTrue( keys.Contains( "tag2" ) );
// Effective collection.
keys = nestedScope.EffectiveTags.Keys;
Assert.AreEqual( 4, keys.Count );
Assert.IsTrue( keys.Contains( "tag1" ) );
Assert.IsTrue( keys.Contains( "tag2" ) );
Assert.IsTrue( keys.Contains( "tag3" ) );
Assert.IsTrue( keys.Contains( "tag4" ) );
}
}
public void TagCollections_KeysCollection()
{
using ( var scope = TagScopeManager.CreateScope() )
{
var keys = scope.Tags.Keys;
Assert.AreEqual( 0, keys.Count );
scope.Tags.Add( "tag1", "value1" );
scope.Tags.Add( "tag2", "value2" );
// Tags collection.
keys = scope.Tags.Keys;
Assert.AreEqual( 2, keys.Count );
Assert.IsTrue( keys.Contains( "tag1" ) );
Assert.IsTrue( keys.Contains( "tag2" ) );
// Inherited collection.
keys = scope.InheritedTags.Keys;
Assert.AreEqual( 0, keys.Count );
// Effective collection.
keys = scope.EffectiveTags.Keys;
Assert.AreEqual( 2, keys.Count );
Assert.IsTrue( keys.Contains( "tag1" ) );
Assert.IsTrue( keys.Contains( "tag2" ) );
TestWithNestedScope();
}
}
public void LogAdapter_EmptyScopeNoTagsInLogAdapter()
{
using (TagScopeManager.CreateScope())
{
Assert.AreEqual(0, LogAdapter.Tags.Count);
}
}
void OnTimerElapsed(object sender, ElapsedEventArgs e)
{
using (var scope = TagScopeManager.CreateScope())
{
try
{
scope.Tags[AppTag.Application] = DataCenter.ApplicationName;
scope.Tags[AppTag.VirtualMachine] = Name;
var random = RandomHelper.GenerateInt(0, 100);
if (random < 30)
{
_logger.Info("Low memory and CPU usage.");
}
if (random < 60)
{
_logger.Warn("Medium memory and CPU usage.");
}
else
{
throw new InvalidOperationException("High memory and CPU usage.");
}
}
catch (InvalidOperationException ex)
{
_logger.Error(ex.Message, ex);
}
}
}
public void TagCollections_IndexerGet_ThrowsOnTagKeyThatDoesNotExistTest()
{
// ReSharper disable AccessToDisposedClosure
using (var scope = TagScopeManager.CreateScope())
{
scope.Tags.Add("tag", "value");
// Access to existing tag. Expected result: success.
Assert.AreEqual("value", scope.Tags["tag"]);
// Access to tag that does not exist.
// Expected result: ArgumentException( "The given tag key was not present in the tag collection." )
Assert.IsTrue(ExceptionTest.IsThrown <ArgumentException>(() =>
{
Assert.IsNull(scope.Tags["not_a_tag"]);
}));
Assert.IsTrue(ExceptionTest.IsThrown <ArgumentException>(() =>
{
Assert.IsNull(scope.InheritedTags["not_a_tag"]);
}));
Assert.IsTrue(ExceptionTest.IsThrown <ArgumentException>(() =>
{
Assert.IsNull(scope.EffectiveTags["not_a_tag"]);
}));
TestWithNestedScope();
}
// ReSharper restore AccessToDisposedClosure
}
public void TagCollections_IndexerGet_ThrowsOnTagKeyThatIsNull()
{
using (var scope = TagScopeManager.CreateScope())
{
scope.Tags.Add("tag", "value");
// Access to existing tag. Expected result: success.
Assert.AreEqual("value", scope.Tags["tag"]);
// Access to tag that does not exist.
// Expected result: ArgumentNullException( "Tag key cannot be null." )
Assert.IsTrue(ExceptionTest.IsThrown <ArgumentNullException>(() =>
{
Assert.IsNull(scope.Tags[null]);
}));
Assert.IsTrue(ExceptionTest.IsThrown <ArgumentNullException>(() =>
{
Assert.IsNull(scope.InheritedTags[null]);
}));
Assert.IsTrue(ExceptionTest.IsThrown <ArgumentNullException>(() =>
{
Assert.IsNull(scope.EffectiveTags[null]);
}));
TestWithNestedScope();
}
}
public void TagCollections_InheritedTagsContainsTagValueFromParentScope()
{
const string tagKey = "tag";
using (var scope1 = TagScopeManager.CreateScope())
{
scope1.Tags.Add(tagKey, "1");
// No tags inherited yet.
Assert.AreEqual(0, scope1.InheritedTags.Count);
using (var scope2 = TagScopeManager.CreateScope())
{
scope2.Tags.Add(tagKey, "2");
Assert.AreEqual(1, scope2.InheritedTags.Count);
using (var scope3 = TagScopeManager.CreateScope())
{
scope3.Tags.Add(tagKey, "3");
Assert.AreEqual(1, scope3.InheritedTags.Count);
using (var scope4 = TagScopeManager.CreateScope())
{
scope4.Tags.Add(tagKey, "4");
Assert.AreEqual(1, scope4.InheritedTags.Count);
// Inherited collection contains value from parent scope.
Assert.AreEqual("1", scope2.InheritedTags[tagKey]);
Assert.AreEqual("2", scope3.InheritedTags[tagKey]);
Assert.AreEqual("3", scope4.InheritedTags[tagKey]);
}
}
}
}
}
/// <summary>
/// This fragment implemented as a separate method
/// to isolate nested scope from parent scope
/// and prevent some really annoying problems with
/// mess with acident "scope" and "nestedScope" calls
/// while they are in one method.
/// </summary>
static void TestWithNestedScope()
{
using (var nestedScope = TagScopeManager.CreateScope(new Dictionary <string, string>
{
{ "tag5", "value5" },
{ "tag6", "value6" }
}))
{
// Use IEnumerable on InheritedTags collection.
var dictionary = nestedScope.InheritedTags.ToDictionary(_ => _.Key, _ => _.Value);
Assert.AreEqual(4, dictionary.Count);
// Check if all tags were converted to dictionary through IEnumerable.
Assert.AreEqual("value1", dictionary["tag1"]);
Assert.AreEqual("value2", dictionary["tag2"]);
Assert.AreEqual("value3", dictionary["tag3"]);
Assert.AreEqual("value4", dictionary["tag4"]);
// Use IEnumerable on EffectiveTags collection.
dictionary = nestedScope.EffectiveTags.ToDictionary(_ => _.Key, _ => _.Value);
Assert.AreEqual(6, dictionary.Count);
// Check if all tags were converted to dictionary through IEnumerable.
Assert.AreEqual("value1", dictionary["tag1"]);
Assert.AreEqual("value2", dictionary["tag2"]);
Assert.AreEqual("value3", dictionary["tag3"]);
Assert.AreEqual("value4", dictionary["tag4"]);
Assert.AreEqual("value5", dictionary["tag5"]);
Assert.AreEqual("value6", dictionary["tag6"]);
}
}
static ITagScope CreateTagScope(string operation)
{
return(TagScopeManager.CreateScope(new Dictionary <string, string>
{
{ AppTag.Application, "WebInterface" },
{ AppTag.Operation, operation }
}));
}
public void TagCollections_RemoveCaseInsensitive()
{
using (var scope = TagScopeManager.CreateScope())
{
scope.Tags.Add("TaG", "value");
scope.AssertOnTagCollectionCounts(1, 0, 1);
scope.Tags.Remove("tAg");
scope.AssertOnTagCollectionCounts(0, 0, 0);
}
}
static void CreateEmptyScope()
{
using (var scope = TagScopeManager.CreateScope())
{
scope.AssertOnTagCollectionCounts(0, 0, 0);
using (var nestedScope = TagScopeManager.CreateScope())
{
nestedScope.AssertOnTagCollectionCounts(0, 0, 0);
}
}
}
public void TagCollections_IndexerAsAdd()
{
using (var scope = TagScopeManager.CreateScope())
{
Assert.AreEqual(0, scope.Tags.Count);
scope.Tags["tag"] = "value";
Assert.AreEqual(1, scope.Tags.Count);
Assert.AreEqual("value", scope.Tags["tag"]);
}
}
public void TagCollections_GetOriginalCaseSensitiveTagKey()
{
using (var scope = TagScopeManager.CreateScope())
{
scope.Tags.Add("TaG", "VaLuE");
var pair = scope.Tags.First();
Assert.AreEqual("TaG", pair.Key);
TestWithNestedScope();
}
}
static void CreateEmptyScope()
{
using (var scope = TagScopeManager.CreateScope())
{
Assert.AreEqual(0, scope.Tags.Count);
scope.Tags.Add("tag1", "value1");
Assert.AreEqual(1, scope.Tags.Count);
scope.Tags.Add("tag2", "value2");
Assert.AreEqual(2, scope.Tags.Count);
}
}
public void TagCollections_Clear()
{
using (var scope = TagScopeManager.CreateScope())
{
scope.Tags.Add("tag1", "value1");
scope.Tags.Add("tag2", "value2");
scope.AssertOnTagCollectionCounts(2, 0, 2);
scope.Tags.Clear();
scope.AssertOnTagCollectionCounts(0, 0, 0);
}
}
/// <summary>
/// This fragment implemented as a separate method
/// to isolate nested scope from parent scope
/// and prevent some really annoying problems with
/// mess with acident "scope" and "nestedScope" calls
/// while they are in one method.
/// </summary>
static void TestWithNestedScope()
{
using (var nestedScope = TagScopeManager.CreateScope())
{
var keys = nestedScope.Tags.Keys;
keys.AssertIsCollectionReadonly();
keys = nestedScope.InheritedTags.Keys;
keys.AssertIsCollectionReadonly();
keys = nestedScope.EffectiveTags.Keys;
keys.AssertIsCollectionReadonly();
}
}
/// <summary>
/// This fragment implemented as a separate method
/// to isolate nested scope from parent scope
/// and prevent some really annoying problems with
/// mess with acident "scope" and "nestedScope" calls
/// while they are in one method.
/// </summary>
void TestWithNestedScope()
{
using (var nestedScope = TagScopeManager.CreateScope())
{
nestedScope.Tags["tag3"] = "value3";
nestedScope.Tags["tag4"] = "value4";
Assert.AreEqual(4, LogAdapter.Tags.Count);
Assert.AreEqual("value1", LogAdapter.Tags["tag1"]);
Assert.AreEqual("value2", LogAdapter.Tags["tag2"]);
Assert.AreEqual("value3", LogAdapter.Tags["tag3"]);
Assert.AreEqual("value4", LogAdapter.Tags["tag4"]);
}
}
public void TagCollections_ContainsKeyCaseInsensitive()
{
using (var scope = TagScopeManager.CreateScope())
{
scope.Tags.Add("TaG", "VaLuE");
Assert.IsTrue(scope.Tags.ContainsKey("tAg"));
Assert.IsTrue(scope.Tags.ContainsKey("TaG"));
Assert.IsTrue(scope.Tags.ContainsKey("tag"));
Assert.IsTrue(scope.Tags.ContainsKey("TAG"));
TestWithNestedScope();
}
}
public void TagScopeManager_CreateScope_AsEmpty()
{
using (var scope = TagScopeManager.CreateScope())
{
scope.AssertOnTagCollectionCounts(0, 0, 0);
using (var nestedScope = TagScopeManager.CreateScope())
{
nestedScope.AssertOnTagCollectionCounts(0, 0, 0);
}
scope.AssertOnTagCollectionCounts(0, 0, 0);
}
}
/// <summary>
/// This fragment implemented as a separate method
/// to isolate nested scope from parent scope
/// and prevent some really annoying problems with
/// mess with acident "scope" and "nestedScope" calls
/// while they are in one method.
/// </summary>
static void TestWithNestedScope()
{
using (var nestedScope = TagScopeManager.CreateScope())
{
// Inherited collection.
var keys = nestedScope.InheritedTags.Keys;
Assert.IsTrue(keys.Contains("TaG"));
Assert.IsFalse(keys.Contains("tAg"));
// Effective collection.
keys = nestedScope.EffectiveTags.Keys;
Assert.IsTrue(keys.Contains("TaG"));
Assert.IsFalse(keys.Contains("tAg"));
}
}
/// <summary>
/// This fragment implemented as a separate method
/// to isolate nested scope from parent scope
/// and prevent some really annoying problems with
/// mess with acident "scope" and "nestedScope" calls
/// while they are in one method.
/// </summary>
static void TestWithNestedScope()
{
using (var nestedScope = TagScopeManager.CreateScope())
{
// Test on Inherited and Effective collections also.
// Inherited collection.
var pair = nestedScope.InheritedTags.First();
Assert.AreEqual("TaG", pair.Key);
// Effective collection.
pair = nestedScope.EffectiveTags.First();
Assert.AreEqual("TaG", pair.Key);
}
}
/// <summary>
/// This fragment implemented as a separate method
/// to isolate nested scope from parent scope
/// and prevent some really annoying problems with
/// mess with acident "scope" and "nestedScope" calls
/// while they are in one method.
/// </summary>
void CreateScopeInvalidatesLogAdapter_TestWithNestedScope()
{
using (TagScopeManager.CreateScope(new Dictionary <string, string>
{
{ "tag3", "value3" },
{ "tag4", "value4" }
}))
{
Assert.AreEqual(4, LogAdapter.Tags.Count);
Assert.AreEqual("value1", LogAdapter.Tags["tag1"]);
Assert.AreEqual("value2", LogAdapter.Tags["tag2"]);
Assert.AreEqual("value3", LogAdapter.Tags["tag3"]);
Assert.AreEqual("value4", LogAdapter.Tags["tag4"]);
}
}
protected static void Run(string loggerName, Action <string> runAction, bool checkTagValues = true)
{
var logger = LogManager.GetLogger(loggerName);
Assert.That(LogManager.Configuration.AllTargets.Count, Is.GreaterThan(0),
"NLog targets were NOT found in the configuration.");
var target = LogManager.Configuration.FindTargetByName(loggerName);
Assert.True(null != target, "NLog MemoryTarget was not found by name '{0}'.", loggerName);
Assert.True(target is MemoryTarget, "NLog target is not of type MemoryTarget.");
var memoryTarget = ( MemoryTarget )target;
using (var tagScope = TagScopeManager.CreateScope())
{
tagScope.Tags["Tag1"] = "Value1";
tagScope.Tags["Tag2"] = "Value2";
logger.Debug("Log message.");
Assert.That(memoryTarget.Logs.Count, Is.EqualTo(1),
"The only row should be logged in the MemoryTarget.");
var jsonString = memoryTarget.Logs[0];
try
{
runAction.Invoke(jsonString);
dynamic json = JToken.Parse(jsonString);
if (checkTagValues)
{
var value1 = ( string )json.Tag1;
var value2 = ( string )json.Tag2;
Assert.That(value1, Is.EqualTo("Value1"), "Tag1 value was not found.");
Assert.That(value2, Is.EqualTo("Value2"), "Tag2 value was not found.");
}
}
catch (JsonReaderException ex)
{
var message = string.Format("Wrong Json string: {0}", jsonString);
throw new ArgumentException(message, ex);
}
}
}
static void NestedScopesWithTags()
{
using (var scope1 = TagScopeManager.CreateScope(new Dictionary <string, string>
{
{ "scope1_tag1", "scope1_tag1_value" },
{ "scope1_tag2", "scope1_tag2_value" }
}))
{
// Expected counts: tags, inherited, effective.
scope1.AssertOnTagCollectionCounts(2, 0, 2);
using (var scope2 = TagScopeManager.CreateScope(new Dictionary <string, string>
{
{ "scope1_scope2_tag1", "scope1_scope2_tag1_value" },
{ "scope1_scope2_tag2", "scope1_scope2_tag2_value" }
}))
{
// Expected counts: tags, inherited, effective.
scope2.AssertOnTagCollectionCounts(2, 2, 4);
using (var scope3 = TagScopeManager.CreateScope(new Dictionary <string, string>
{
{ "scope1_scope2_scope3_tag1", "scope1_scope2_scope3_tag1_value" },
{ "scope1_scope2_scope3_tag2", "scope1_scope2_scope3_tag1_value" }
}))
{
// Expected counts: tags, inherited, effective.
scope3.AssertOnTagCollectionCounts(2, 4, 6);
scope3.Tags.Add("scope1_scope2_scope3_tag3", "scope1_scope2_scope3_tag3_value");
scope3.AssertOnTagCollectionCounts(3, 4, 7);
scope3.Tags.Add("scope1_scope2_scope3_tag4", "scope1_scope2_scope3_tag4_value");
scope3.AssertOnTagCollectionCounts(4, 4, 8);
// Modify tags in upper scopes.
scope2.Tags.Add("scope1_scope2_tag3", "scope1_scope2_tag3_value");
scope3.AssertOnTagCollectionCounts(4, 5, 9);
scope1.Tags.Add("scope1_tag3", "scope1_tag3_value");
scope3.AssertOnTagCollectionCounts(4, 6, 10);
}
// Expected counts: tags, inherited, effective.
scope2.AssertOnTagCollectionCounts(3, 3, 6);
}
}
}
public void TagCollections_Remove()
{
using (var scope = TagScopeManager.CreateScope())
{
scope.Tags.Add("tag1", "value1");
scope.Tags.Add("tag2", "value2");
scope.AssertOnTagCollectionCounts(2, 0, 2);
scope.Tags.Remove("tag2");
scope.AssertOnTagCollectionCounts(1, 0, 1);
Assert.IsTrue(scope.Tags.ContainsKey("tag1"));
scope.Tags.Remove("tag1");
scope.AssertOnTagCollectionCounts(0, 0, 0);
}
}
static void CreateScopeWithTags()
{
using (var scope = TagScopeManager.CreateScope(new Dictionary <string, string>
{
{ "tag1", "value1" },
{ "tag2", "value2" }
}))
{
Assert.AreEqual(2, scope.Tags.Count);
scope.Tags.Add("tag3", "value3");
Assert.AreEqual(3, scope.Tags.Count);
scope.Tags.Add("tag4", "value4");
Assert.AreEqual(4, scope.Tags.Count);
}
}
