public async Task SubscribeAll_EventFilterSystem()
{
var typeEventFilter = new SubscriptionFilterOptions(EventTypeFilter.ExcludeSystemEvents(),
checkpointInterval: 5, checkpointReached: SubscribeFilterReturn);
await _client.SubscribeToAllAsync(SubscribeReturn,
filterOptions : typeEventFilter);
}
static void Main(string[] args)
{
// Issue an error and a warning message. Only the error message
// should be logged.
Activity1();
// Save the original settings from the configuration file.
EventTypeFilter configFilter =
(EventTypeFilter)mySource.Listeners["console"].Filter;
// Create a new event type filter that ensures
// warning messages will be written.
mySource.Listeners["console"].Filter =
new EventTypeFilter(SourceLevels.Warning);
// Allow the trace source to send messages to listeners
// for all event types. This statement will override
// any settings in the configuration file.
// If you do not change the switch level, the event filter
// changes have no effect.
mySource.Switch.Level = SourceLevels.All;
// Issue a warning and a critical message. Both should be logged.
Activity2();
// Restore the original filter settings.
mySource.Listeners["console"].Filter = configFilter;
Activity3();
mySource.Close();
return;
}
private void TraceFilterTestHelper(
Action <ApplicationInsightsTraceListener, TraceEventCache> callTraceEent,
bool shouldTrace,
SourceLevels filterLevel = SourceLevels.Warning)
{
TraceEventCache shimTraceEventCache = new TraceEventCache();
using (var traceListener = new ApplicationInsightsTraceListener(this.adapterHelper.InstrumentationKey))
{
var telemetryConfiguration = new TelemetryConfiguration
{
InstrumentationKey = Guid.NewGuid().ToString(),
TelemetryChannel = this.adapterHelper.Channel
};
traceListener.TelemetryClient = new TelemetryClient(telemetryConfiguration);
var traceFilter = new EventTypeFilter(filterLevel);
traceListener.Filter = traceFilter;
callTraceEent(traceListener, shimTraceEventCache);
Assert.AreEqual(shouldTrace, this.adapterHelper.Channel.SentItems.Length == 1);
}
}
public void EventType()
{
var filter = new EventTypeFilter(SourceLevels.Error);
Assert.Equal(SourceLevels.Error, filter.EventType);
filter.EventType = SourceLevels.Off;
Assert.Equal(SourceLevels.Off, filter.EventType);
}
public void ShouldTrace()
{
var cache = new TraceEventCache();
var filter = new EventTypeFilter(SourceLevels.Error);
Assert.True(filter.ShouldTrace(cache, null, TraceEventType.Critical, 0, null, null, null, null));
Assert.False(filter.ShouldTrace(cache, null, TraceEventType.Warning, 0, null, null, null, null));
}
public async Task <ISubscription> Subscribe(IEventHandlerFactory factory, object[] args = null)
{
Subscription s = new Subscription(true);
var lastPosition = (StreamPosition)await _stream.LastPosition();
string[] prefixes = _events.Select(x => x.Name).ToArray();
FilterOptions filters = new FilterOptions(EventTypeFilter.Prefix(prefixes));
// be very careful. We need to subscribe after the global position.
await _eventStore.SubscribeToAllAsync(lastPosition.GlobalPosition,
async (s, r, c) =>
{
var type = _schema.EventByName(r.Event.EventType);
if (type != null && _events.Contains(type))
{
using (var scope = factory.Scope())
{
var handler = scope.CreateHandler(type);
var(m, e) = _eventConverter.Convert(type, r);
await handler.Execute(m, e);
}
}
}, true, null, filters);
return(s);
}
public void AfterCreationTest()
{
LicenseTraceSource _tracer = LicenseTraceSource.This;
Assert.IsNotNull(_tracer);
//Listeners
Assert.AreEqual(1, _tracer.Listeners.Count);
Dictionary <string, TraceListener> _listeners = _tracer.Listeners.Cast <TraceListener>().ToDictionary <TraceListener, string>(x => x.Name);
Assert.IsTrue(_listeners.ContainsKey("LogFile"));
TraceListener _listener = _listeners["LogFile"];
Assert.IsNotNull(_listener);
Assert.IsInstanceOfType(_listener, typeof(AdvancedDelimitedListTraceListener));
AdvancedDelimitedListTraceListener _advancedListener = _listener as AdvancedDelimitedListTraceListener;
Assert.AreEqual <string>(ExpectedFileName, _advancedListener.GetFileName());
//Filter
Assert.IsNotNull(_advancedListener.Filter);
Assert.IsInstanceOfType(_advancedListener.Filter, typeof(EventTypeFilter));
EventTypeFilter _eventTypeFilter = _advancedListener.Filter as EventTypeFilter;
Assert.AreEqual(SourceLevels.All, _eventTypeFilter.EventType);
//Test Switch
Assert.IsNotNull(_tracer.Switch);
Assert.AreEqual <string>("CAS.CodeProtect.TraceSource.Switch", _tracer.Switch.DisplayName);
Assert.AreEqual <SourceLevels>(SourceLevels.All, _tracer.Switch.Level);
//Trace
Assert.IsFalse(Trace.Listeners.Cast <TraceListener>().Where <TraceListener>(x => x.Name == "LogFile").Any <TraceListener>());
}
/// <summary>檢查此訊息是否需要寫入記錄檔，依照 <see cref="TraceListener.Filter"/> 設定為準</summary>
/// <param name="source"><see cref="SourceFilter.Source"/></param>
/// <param name="eventType"><see cref="EventTypeFilter.EventType"/></param>
/// <returns>(True)需要寫入記錄檔 (False)不須寫入</returns>
private bool IsNecessary(string source, TraceEventType eventType)
{
bool necessary = false;
/* 判斷 Filter 是否為 EventTypeFilter */
EventTypeFilter evnFilter = Filter as EventTypeFilter;
if (evnFilter != null)
{
/* 因 SourceLevels 與 TraceEventType 兩個 Enum 數值不同，故用單一比較 */
SourceLevels srcLv = evnFilter.EventType;
necessary = srcLv.HasFlag(SourceLevels.All) ||
(srcLv.HasFlag(SourceLevels.Error) && eventType.HasFlag(TraceEventType.Error)) ||
(srcLv.HasFlag(SourceLevels.Information) && eventType.HasFlag(TraceEventType.Information)) ||
(srcLv.HasFlag(SourceLevels.Warning) && eventType.HasFlag(TraceEventType.Warning)) ||
(srcLv.HasFlag(SourceLevels.Critical) && eventType.HasFlag(TraceEventType.Critical)) ||
(srcLv.HasFlag(SourceLevels.Verbose) && eventType.HasFlag(TraceEventType.Verbose));
}
else
{
/* 檢查是否為 SourceFilter */
SourceFilter srcFilter = Filter as SourceFilter;
if (srcFilter != null)
{
necessary = srcFilter.Source == source;
}
}
return(necessary);
}
public async Task use_type_filters()
{
NumberOfStreams = 10;
await PublishSingleThreaded();
using var fetcher1 = new EventFetcher(theStore, theStore.Tenancy.Default.Database, new ISqlFragment[0]);
var shardName = new ShardName("name");
var range1 = new EventRange(shardName, 0, NumberOfEvents);
await fetcher1.Load(range1, CancellationToken.None);
var uniqueTypeCount = range1.Events.Select(x => x.EventType).Distinct()
.Count();
uniqueTypeCount.ShouldBe(5);
var filter = new EventTypeFilter(theStore.Events, new Type[] { typeof(Travel), typeof(Arrival) });
using var fetcher2 = new EventFetcher(theStore, theStore.Tenancy.Default.Database, new ISqlFragment[] { filter });
var range2 = new EventRange(shardName, 0, NumberOfEvents);
await fetcher2.Load(range2, CancellationToken.None);
range2.Events
.Select(x => x.EventType)
.OrderBy(x => x.Name).Distinct()
.ShouldHaveTheSameElementsAs(typeof(Arrival), typeof(Travel));
}
protected override async Task <EventSubscription> Subscribe(
Checkpoint checkpoint,
CancellationToken cancellationToken)
{
var filterOptions = new SubscriptionFilterOptions(
EventTypeFilter.ExcludeSystemEvents(),
10,
(_, p, ct) =>
StoreCheckpoint(
new EventPosition(p.CommitPosition, DateTime.UtcNow),
ct));
var(_, position) = checkpoint;
var subscribeTask = position != null
? EventStoreClient.SubscribeToAllAsync(
new Position(
position.Value,
position.Value),
TransactionalHandler,
false,
HandleDrop,
filterOptions,
cancellationToken : cancellationToken)
: EventStoreClient.SubscribeToAllAsync(
TransactionalHandler,
false,
HandleDrop,
filterOptions,
cancellationToken: cancellationToken);
var sub = await subscribeTask.NoContext();
return(new EventSubscription(SubscriptionId,
new Stoppable(() => sub.Dispose())));
}
public void AssemblyTraceEventTestMethod()
{
TraceSource _tracer = AssemblyTraceEvent.Tracer;
Assert.IsNotNull(_tracer);
Assert.AreEqual <string>("TPA.Logging.Consumer", _tracer.Name, $"Actual tracer name: {_tracer.Name}");
Assert.AreEqual(1, _tracer.Listeners.Count);
Dictionary <string, TraceListener> _listeners = _tracer.Listeners.Cast <TraceListener>().ToDictionary <TraceListener, string>(x => x.Name);
Assert.IsTrue(_listeners.ContainsKey("LogFile"));
TraceListener _listener = _listeners["LogFile"];
Assert.IsNotNull(_listener);
Assert.IsInstanceOfType(_listener, typeof(DelimitedListTraceListener));
DelimitedListTraceListener _advancedListener = _listener as DelimitedListTraceListener;
Assert.IsNotNull(_advancedListener.Filter);
Assert.IsInstanceOfType(_advancedListener.Filter, typeof(EventTypeFilter));
EventTypeFilter _eventTypeFilter = _advancedListener.Filter as EventTypeFilter;
Assert.AreEqual(SourceLevels.All, _eventTypeFilter.EventType);
string _testPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
Assert.AreEqual <string>(Path.Combine(_testPath, @"TPA.Logging.Consumer.log"), _advancedListener.GetFileName());
}
public void ReturnsEventWithGivenHandlerType()
{
Assert.Same(selected, members.Event(handlerType));
EventTypeFilter filter = VerifyFilter(selection, handlerType);
Assert.Same(events, filter.Source);
}
public void TracerTestMethod()
{
AssemblyTraceEvent _tracerWrapper = AssemblyTraceEvent.Tracer;
Assert.IsNotNull(_tracerWrapper);
Assert.AreEqual <string>("DataProvider.TextReader", _tracerWrapper.Name);
TraceSource _tracer = _tracerWrapper.TraceSource;
Assert.IsNotNull(_tracer);
Assert.AreEqual(2, _tracer.Listeners.Count, $"Available listeners: {string.Join(", ", _tracer.Listeners.Cast<TraceListener>().Select<TraceListener, string>(x => x.Name).ToArray<String>())}");
Dictionary <string, TraceListener> _listeners = _tracer.Listeners.Cast <TraceListener>().ToDictionary <TraceListener, string>(x => x.Name);
Assert.IsTrue(_listeners.ContainsKey("LogFile"));
TraceListener _listener = _listeners["LogFile"];
Assert.IsNotNull(_listener);
Assert.IsInstanceOfType(_listener, typeof(DelimitedListTraceListener));
DelimitedListTraceListener _advancedListener = _listener as DelimitedListTraceListener;
Assert.IsNotNull(_advancedListener.Filter);
Assert.IsInstanceOfType(_advancedListener.Filter, typeof(EventTypeFilter));
EventTypeFilter _eventTypeFilter = _advancedListener.Filter as EventTypeFilter;
Assert.AreEqual(SourceLevels.All, _eventTypeFilter.EventType);
string _testPath = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
Assert.AreEqual <string>(Path.Combine(_testPath, @"log\CAS.CommServer.ProtocolHub.Communication.log"), GetFileName(_advancedListener));
}
public static Event Event(this IMembers members, Type handlerType, string eventName)
{
var typed = new EventTypeFilter(members.Events(), handlerType);
var named = new MemberNameFilter <Event, EventInfo>(typed, eventName);
return(named.Single());
}
public void ReturnsEventWithGivenHandlerType()
{
Assert.Same(selected, testType.Event(handlerType));
EventTypeFilter typed = VerifyFilter(selection, handlerType);
VerifyStaticEvents(typed.Source, testType);
}
public void ReturnsEventWithGivenHandlerType()
{
Assert.Same(selected, instance.Event(handlerType));
EventTypeFilter named = VerifyFilter(selection, handlerType);
VerifyInstanceEvents(named.Source, instance);
}
public void ReturnsEventWithGivenHandlerTypeAndName()
{
Assert.Same(selected, members.Event(handlerType, eventName));
MemberNameFilter <Event, EventInfo> named = VerifyFilter(selection, eventName);
EventTypeFilter typed = VerifyFilter(named.Source, handlerType);
Assert.Same(events, typed.Source);
}
protected override async Task Given()
{
await Client.CreateToAllAsync(
Group,
EventTypeFilter.Prefix("prefix-filter-"),
new PersistentSubscriptionSettings(),
TestCredentials.Root);
}
public void EventType()
{
var filter = new EventTypeFilter(SourceLevels.Error);
Assert.Equal(SourceLevels.Error, filter.EventType);
filter.EventType = SourceLevels.Off;
Assert.Equal(SourceLevels.Off, filter.EventType);
}
public void ShouldTrace()
{
var cache = new TraceEventCache();
var filter = new EventTypeFilter(SourceLevels.Error);
Assert.True(filter.ShouldTrace(cache, null, TraceEventType.Critical, 0, null, null, null, null));
Assert.False(filter.ShouldTrace(cache, null, TraceEventType.Warning, 0, null, null, null, null));
}
public void RuntimeFilterChange()
{
CreateAndLoadConfigFile("testhost_ConfigWithRuntime.config");
TraceSource mySource = new TraceSource("TraceSourceApp");
StringTraceListener origListener = (StringTraceListener)mySource.Listeners["origListener"];
StringTraceListener secondListener = (StringTraceListener)mySource.Listeners["secondListener"];
// Issue an error and a warning message. Only the error message should be logged.
mySource.TraceEvent(TraceEventType.Error, 1, "Error message.");
mySource.TraceEvent(TraceEventType.Warning, 2, "Warning message.");
Assert.Equal($"TraceSourceApp Error: 1 : Error message.{Environment.NewLine}", origListener.Output);
Assert.Equal($"TraceSourceApp Error: 1 : Error message.{Environment.NewLine}", secondListener.Output);
// Save the original settings from the configuration file.
EventTypeFilter configFilter = (EventTypeFilter)mySource.Listeners["origListener"].Filter;
Assert.NotNull(configFilter);
// Create a new filter that logs warnings.
origListener.Filter = new EventTypeFilter(SourceLevels.Warning);
// Allow the trace source to send messages to listeners for all event types.
// This overrides settings in the configuration file.
// If the switch level is not changed, the event filter changes have no effect.
mySource.Switch.Level = SourceLevels.All;
// Issue a critical and warning message.
origListener.Clear();
secondListener.Clear();
mySource.TraceEvent(TraceEventType.Critical, 3, "Critical message.");
mySource.TraceEvent(TraceEventType.Warning, 4, "Warning message.");
// Both should be logged for origListener.
Assert.Equal(
$"TraceSourceApp Critical: 3 : Critical message.{Environment.NewLine}" +
$"TraceSourceApp Warning: 4 : Warning message.{Environment.NewLine}", origListener.Output);
// secondListener is unchanged and doesn't log warnings.
Assert.Equal($"TraceSourceApp Critical: 3 : Critical message.{Environment.NewLine}", secondListener.Output);
// Restore the original filter settings.
origListener.Clear();
secondListener.Clear();
origListener.Filter = configFilter;
// Issue an error and information message. Only the error message should be logged.
mySource.TraceEvent(TraceEventType.Error, 5, "Error message.");
mySource.TraceInformation("Informational message.");
Assert.Equal($"TraceSourceApp Error: 5 : Error message.{Environment.NewLine}", origListener.Output);
Assert.Equal($"TraceSourceApp Error: 5 : Error message.{Environment.NewLine}", secondListener.Output);
origListener.Clear();
secondListener.Clear();
mySource.Close();
}
public static async Task ConsoleLogAllEvents()
{
await _client.SubscribeToAllAsync(Position.End, async (subscription, evnt, cancellationToken) =>
{
Console.WriteLine($"{Environment.NewLine}{evnt.Event.EventType} appended{Environment.NewLine}");
await Task.CompletedTask;
}, filterOptions : new SubscriptionFilterOptions(EventTypeFilter.RegularExpression("Event")));
}
public void ReturnsGenericEventWithGivenHandlerType()
{
Event <TestHandler> generic = testType.Event <TestHandler>();
VerifyGenericEvent(selected, generic);
EventTypeFilter typed = VerifyFilter(selection, handlerType);
VerifyStaticEvents(typed.Source, testType);
}
public void ReturnsGenericEventWithGivenHandlerType()
{
Event <TestHandler> generic = members.Event <TestHandler>();
VerifyGenericEvent(selected, generic);
EventTypeFilter typed = VerifyFilter(selection, handlerType);
Assert.Same(events, typed.Source);
}
public void ReturnsGenericEventWithGivenHandlerTypeAndName()
{
Event <TestHandler> generic = testType.Event <TestHandler>(eventName);
VerifyGenericEvent(selected, generic);
MemberNameFilter <Event, EventInfo> named = VerifyFilter(selection, eventName);
EventTypeFilter typed = VerifyFilter(named.Source, handlerType);
VerifyStaticEvents(typed.Source, testType);
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
var eventStoreClient = _serviceProvider.GetRequiredService <EventStoreClient>();
await eventStoreClient.SubscribeToAllAsync(
await GetStartPosition(),
HandleEvent,
filterOptions : new SubscriptionFilterOptions(EventTypeFilter.ExcludeSystemEvents()),
cancellationToken : stoppingToken
);
}
private void Initialize(TraceInputConfiguration traceInputConfiguration)
{
Debug.Assert(traceInputConfiguration != null);
Debug.Assert(this.healthReporter != null);
this.subject = new EventFlowSubject <EventData>();
Filter = new EventTypeFilter(traceInputConfiguration.TraceLevel);
Trace.Listeners.Add(this);
this.healthReporter.ReportHealthy($"{nameof(TraceInput)} initialized.", TraceTag);
}
/// <summary>
/// Start the subscription to EventStoreDB
/// </summary>
/// <param name="cancellationToken"></param>
public async Task Start(CancellationToken cancellationToken)
{
var filter = new SubscriptionFilterOptions(EventTypeFilter.ExcludeSystemEvents());
_subscription = await _client.SubscribeToAllAsync(Position.Start,
EventAppeared,
subscriptionDropped : SubscriptionDropped,
filterOptions : filter,
resolveLinkTos : true,
cancellationToken : cancellationToken);
}
public PowerShellManagementAgent()
{
Tracer.IndentLevel = 0;
Tracer.Enter("initialize");
Tracer.Indent();
try
{
Tracer.TraceInformation("memory-usage {0:n} Mb", GC.GetTotalMemory(true) / 102400);
System.Reflection.Assembly assembly = System.Reflection.Assembly.GetExecutingAssembly();
FileVersionInfo fvi = FileVersionInfo.GetVersionInfo(assembly.Location);
string version = fvi.FileVersion;
Tracer.TraceInformation("psma-version {0}", version);
Tracer.TraceInformation("reading-registry-settings");
RegistryKey machineRegistry = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry64);
RegistryKey mreRootKey = machineRegistry.OpenSubKey(@"SOFTWARE\Granfeldt\FIM\ManagementAgents\PowerShell", false);
if (mreRootKey != null)
{
Tracer.TraceInformation("adding-eventlog-listener-for name: {0}, source: {1}", EventLogName, EventLogSource);
EventLog evl = new EventLog(EventLogName);
evl.Log = EventLogName;
evl.Source = EventLogSource;
EventLogTraceListener eventLog = new EventLogTraceListener(EventLogSource);
eventLog.EventLog = evl;
EventTypeFilter filter = new EventTypeFilter(SourceLevels.Warning | SourceLevels.Error | SourceLevels.Critical);
eventLog.TraceOutputOptions = TraceOptions.Callstack;
eventLog.Filter = filter;
Tracer.Trace.Listeners.Add(eventLog);
if (!EventLog.SourceExists(EventLogSource))
{
Tracer.TraceInformation("creating-eventlog-source '{0}'", EventLogSource);
EventLog.CreateEventSource(EventLogSource, EventLogName);
}
string logFileValue = mreRootKey.GetValue("DebugLogFileName", null) as string;
if (logFileValue != null)
{
Tracer.TraceWarning("Logging to file is no longer supported. Please remove registrykey DebugLogFileName and use DebugView or similar instead to catch traces from this Management Agent");
}
}
}
catch (Exception ex)
{
Tracer.TraceError("could-not-initialize", ex);
throw;
}
finally
{
Tracer.Unindent();
Tracer.Exit("initialize");
}
}
public void CreatedTraceListenerHasCorrectFilter()
{
MockLogObjectsHelper helper = new MockLogObjectsHelper();
MockTraceListenerData data = new MockTraceListenerData("listener");
data.Filter = SourceLevels.Critical;
helper.loggingSettings.TraceListeners.Add(data);
TraceListener listener = TraceListenerCustomFactory.Instance.Create(context, "listener", helper.configurationSource, reflectionCache);
Assert.IsNotNull(listener.Filter);
EventTypeFilter filter = (EventTypeFilter)listener.Filter;
Assert.AreEqual(data.Filter, filter.EventType);
}
static void Main(string[] args)
{
BooleanSwitch dataSwitch = new BooleanSwitch("Data", "DataAccess module");
TraceSwitch generalSwitch = new TraceSwitch("General", "Entire application");
// If you do not set tracelistener, it will be
// printed in View -> Output window!
// Testing debug!
Debug.WriteLine("DEBUG: Program started!");
// Testing trace!
Trace.WriteLine("TRACE: Program started!");
// this sets the trace to a console window (we currently use).
/*
* Trace.Listeners.Clear();
* Trace.Listeners.Add(
* new TextWriterTraceListener(Console.Out));
*/
Trace.WriteLine("TRACELISTENER: Kokeilu!");
Activity1();
EventTypeFilter configFilter = (EventTypeFilter)mySource.Listeners["console"].Filter;
mySource.Listeners["console"].Filter = new EventTypeFilter(SourceLevels.Critical);
Activity2();
mySource.Switch.Level = SourceLevels.All;
mySource.Listeners["console"].Filter = configFilter;
Activity3();
//Trace.TraceInformation("TraceInformation Test!");
//Trace.TraceWarning("TraceWarning Test!");
//Trace.TraceError("TraceError Test!");
int myvar = 123;
int result = MyMethod(myvar);
mySource.Close();
Console.ReadLine();
}
static Log()
{
// Setup the source
_source = new TraceSource("Log", SourceLevels.All);
// Register the default console listener
_consoleEventFilter = new EventTypeFilter(SourceLevels.Information | SourceLevels.Error | SourceLevels.Warning);
_source.Listeners.Add(
new ConsoleTraceListener()
{
Filter = _consoleEventFilter,
ShowSourceName = false,
ShowEventId = false,
ShowEventType = false,
});
}
public void Constructor()
{
var filter = new EventTypeFilter(SourceLevels.Error);
Assert.Equal(SourceLevels.Error, filter.EventType);
}
