/// <summary> /// Initializes a new instance of the <see cref="EventSourceSettings" /> class. /// </summary> /// <param name="name">The friendly event source name.</param> /// <param name="eventSourceId">The event source id.</param> /// <param name="level">The level.</param> /// <param name="matchAnyKeyword">The match any keyword.</param> /// <param name="arguments">The arguments for the event source.</param> /// <param name="processNameFilters">The the process filters.</param> /// <exception cref="ConfigurationException">A validation exception.</exception> public EventSourceSettings( string name = null, Guid? eventSourceId = null, EventLevel level = EventLevel.LogAlways, EventKeywords matchAnyKeyword = Keywords.All, IEnumerable<KeyValuePair<string, string>> arguments = null, IEnumerable<string> processNameFilters = null) { // If no Id, Name should not be optional so we may derive an Id from it. if (!eventSourceId.HasValue || eventSourceId == Guid.Empty) { if (string.IsNullOrWhiteSpace(name)) { throw new ConfigurationException(Properties.Resources.MissingEventSourceNameAndId); } eventSourceId = TraceEventProviders.GetEventSourceGuidFromName(name); } else if (!string.IsNullOrWhiteSpace(name)) { // throw and both name & Id specified throw new ConfigurationException(Properties.Resources.EventSourceAmbiguityError); } this.EventSourceId = eventSourceId.Value; this.Name = name ?? eventSourceId.ToString(); // Set a not null value for later use this.Level = level; this.MatchAnyKeyword = matchAnyKeyword; this.Arguments = arguments ?? Enumerable.Empty<KeyValuePair<string, string>>(); this.ProcessNamesToFilter = processNameFilters ?? Enumerable.Empty<string>(); }
/// <summary> /// Initializes a new instance of the <see cref="EventTextFormatter" /> class. /// </summary> /// <param name="header">The header.</param> /// <param name="footer">The footer.</param> /// <param name="verbosityThreshold">The verbosity threshold.</param> /// <param name="dateTimeFormat">The date time format used for timestamp value.</param> public EventTextFormatter(string header = null, string footer = null, EventLevel verbosityThreshold = DefaultVerbosityThreshold, string dateTimeFormat = null) { this.Header = header; this.Footer = footer; this.VerbosityThreshold = verbosityThreshold; this.DateTimeFormat = dateTimeFormat; }
public static void EnableEvents(this EventListener self, IEnumerable<EventSource> sources, EventLevel level) { foreach (var source in sources) { self.EnableEvents(source, level); } }
protected void OnProcessEvent(EventLevel eventLevel, string message) { if (ProcessEventOccurred != null) { ProcessEventOccurred(this, new ProcessEventArgs(DateTime.Now, message, eventLevel)); } }
public override Task<bool> Start() { // Load the trace level if specified string levelStr = GetConfigurationSetting("Trace.Level"); EventLevel level; if (!String.IsNullOrEmpty(levelStr) && Enum.TryParse<EventLevel>(levelStr, true, out level)) { TraceLevel = level; } else { TraceLevel = EventLevel.Warning; } RoleEnvironment.Changing += (_, __) => ConfigurationChanging(); RoleEnvironment.Changed += (_, __) => ConfigurationChanging(); RoleEnvironment.StatusCheck += (sender, e) => { if (GetCurrentStatus() == ServiceStatus.Busy) { e.SetBusy(); } }; return base.Start(); }
private ActionResult Add(string projectId, int? transitionId, EventLevel level, EventType eventType, AppUser creator, object item, DateTime? createdOn = null) { try { var i = new ProjectHistory { CreatedBy = creator, CreatedOn = createdOn ?? DateTime.UtcNow, Description = JsonConvert.SerializeObject(item), Level = level, ProjectId = projectId, TransitionId = transitionId, Type = eventType }; if (!_dbContext.ChangeTracker.Entries().Where(e => e.State != EntityState.Unchanged).Any()) { _dbContext.ProjectHistory.Add(i); _dbContext.SaveChanges(); } else { _dbContext.ProjectHistory.Add(i); } return ActionResult.Success(item); } catch(Exception ex) { return ActionResult.Failed(ex); } }
internal TraceLoggingTypeInfo( Type dataType, string name, EventLevel level, EventOpcode opcode, EventKeywords keywords, EventTags tags) { if (dataType == null) { throw new ArgumentNullException("dataType"); } if (name == null) { throw new ArgumentNullException("eventName"); } Contract.EndContractBlock(); Statics.CheckName(name); this.name = name; this.keywords = keywords; this.level = level; this.opcode = opcode; this.tags = tags; this.dataType = dataType; }
/// <summary> /// Initializes the ConsoleLogListener. /// </summary> /// <param name="eventLevel">The event level.</param> public static void Initialize(EventLevel eventLevel) { if (instance == null) { instance = new ConsoleLogListener(eventLevel); } }
internal static void EnableProvider(TraceEventSession session, Guid providerId, EventLevel level, EventKeywords matchAnyKeyword, bool sendManifest = true) { // Make explicit the invocation for requesting the manifest from the EventSource (Provider). var values = sendManifest ? new Dictionary<string, string>() { { "Command", "SendManifest" } } : null; session.EnableProvider(providerId, (TraceEventLevel)level, (ulong)matchAnyKeyword, 0, TraceEventOptions.None, values); }
internal static void EnableProvider( TraceEventSession session, Guid providerId, EventLevel level, EventKeywords matchAnyKeyword, IEnumerable<KeyValuePair<string, string>> arguments, IEnumerable<string> processNamesToFilter, bool sendManifest = true) { // Make explicit the invocation for requesting the manifest from the EventSource (Provider). var argumentsDictionary = arguments.ToDictionary(kvp => kvp.Key, kvp => kvp.Value); if (sendManifest) { argumentsDictionary["Command"] = "SendManifest"; } var options = new TraceEventProviderOptions { Arguments = argumentsDictionary, ProcessNameFilter = processNamesToFilter.ToArray() }; session.EnableProvider(providerId, (TraceEventLevel)level, (ulong)matchAnyKeyword, options); }
/// <summary> /// Initializes a new instance of <see cref="DiagnosticsEventArgs" /> class. /// </summary> /// <param name="level">The level of the event.</param> /// <param name="message">The message of the event.</param> /// <param name="source">The source of the event.</param> public DiagnosticsEventArgs(EventLevel level, String message, String source) { Level = level; Message = message; Source = source; }
public ConsoleColor? Map(EventLevel eventLevel) { if (eventLevel == EventLevel.Error) { this.Color = Error; } return this.Color; }
public void WriteMessage(string eventMessage, EventLevel level, EventKeywords keywords) { #if ETW_SUPPORTED if(m_provider != null) m_provider.WriteMessageEvent(eventMessage, (byte)level, (long)keywords); #endif WriteToAllStreams(0, eventMessage); }
public bool IsEnabled(EventLevel level, EventKeywords keywords) { if (!m_providerEnabled) return false; if (m_level != 0 && m_level < level) return false; return m_matchAnyKeyword == 0 || (keywords & m_matchAnyKeyword) != 0; }
private ErrorLevel GetLogLevel(EventLevel level) { ErrorLevel mappedLevel; if (LevelMap.TryGetValue(level, out mappedLevel)) return mappedLevel; return ErrorLevel.Debug; }
public TestEventListener(string taretSourceName, EventLevel level) { // Store the arguments _targetSourceName = taretSourceName; _level = level; LoadSourceList(); }
public TestEventListener(Guid targetSourceGuid, EventLevel level) { // Store the arguments _targetSourceGuid = targetSourceGuid; _level = level; LoadSourceList(); }
public void VerifyEvent(ClientEventId id, EventLevel level, EventKeywords keywords, EventOpcode opcode, params object[] payloadItems) { Assert.Equal(1, this.Events.Count); Assert.Equal((int)id, this.Events[0].EventId); Assert.Equal(level, this.Events[0].Level); Assert.Equal(opcode, this.Events[0].Opcode); Assert.True(this.Events[0].Keywords.HasFlag(keywords)); Assert.Equal(payloadItems, this.Events[0].Payload.ToArray()); }
public bool IsEnabled(EventLevel level, EventKeywords keywords) { if (!m_eventSourceEnabled) return false; if (m_level != 0 && m_level < level) return false; if (m_matchAnyKeyword != 0 && (keywords & m_matchAnyKeyword) == 0) return false; return true; }
public TestEventListener(List<string> targetSourceNames, EventLevel level) { // Store the arguments foreach (var targetSourceName in targetSourceNames) { _targetSourceName.Add(targetSourceName, true); } _level = level; LoadSourceList(); }
public EventLevel GetLogLevel() { const string Key = "IOT_LOGLEVEL"; object logLevel = Environment.GetEnvironmentVariable(Key); if (logLevel != null) { _eventLevel = ConfigurationHelper.ConvertValue<EventLevel>(Key, logLevel); } return _eventLevel; }
public static void ValidateEventLogMessage(TestEventListener listener, string expectedMessage, EventLevel level) { bool messageFound = false; foreach (var actualEvent in listener.Messages.Where((arg) => { return arg.Level == level; })) { string actualMessage = string.Format(CultureInfo.InvariantCulture, actualEvent.Message, actualEvent.Payload.ToArray()); messageFound = messageFound || actualMessage.Contains(expectedMessage); } Assert.IsTrue(messageFound); }
/// <summary> /// Initializes a new instance of the <see cref="Microsoft.Practices.EnterpriseLibrary.SemanticLogging.Schema.EventSchema"/> class with the specified values. /// </summary> /// <param name="id">The event id.</param> /// <param name="providerId">The provider GUID.</param> /// <param name="providerName">The provider name.</param> /// <param name="level">The event level.</param> /// <param name="task">The event task.</param> /// <param name="taskName">The event task name.</param> /// <param name="opcode">The event operation code.</param> /// <param name="opcodeName">The event operation code name.</param> /// <param name="keywords">The event keywords.</param> /// <param name="keywordsDescription">The event keywords description.</param> /// <param name="version">The event version.</param> /// <param name="payload">The event payload.</param> public EventSchema(int id, Guid providerId, string providerName, EventLevel level, EventTask task, string taskName, EventOpcode opcode, string opcodeName, EventKeywords keywords, string keywordsDescription, int version, IEnumerable<string> payload) { this.id = id; this.providerId = providerId; this.providerName = providerName; this.level = level; this.task = task; this.taskName = taskName; this.opcode = opcode; this.opcodeName = opcodeName; this.keywords = keywords; this.keywordsDescription = keywordsDescription; this.version = version; this.payload = payload.ToArray(); }
/// <summary> /// Add a new logger to the logger pool. /// </summary> /// <param name="loggerId"></param> /// <param name="parentLoggerId"></param> /// <returns>The new logger if an existing logger is not found, otherwise the existing logger</returns> public static ILogger AddLogger(string loggerId, string parentLoggerId, EventLevel loggerEventLevel) { // attempt to find the logger by Id ILogger existingLogger = loggerPool.Find( delegate(ILogger logger) { return logger.LoggerId == loggerId; }); // if a logger is found return it, if (existingLogger != null) return existingLogger; // otherwise add the logger to the logger pool and return it ILogger newLogger = new Logger(loggerId, parentLoggerId, loggerEventLevel); loggerPool.Add(newLogger); return newLogger; }
public static EventEntry Create( int eventId = 0, Guid providerId = default(Guid), string providerName = null, EventLevel level = default(EventLevel), EventTask task = default(EventTask), string taskName = null, EventOpcode opcode = default(EventOpcode), string opcodeName = null, EventKeywords keywords = default(EventKeywords), string keywordsDescription = null, int version = 0, IEnumerable<string> payloadNames = null, string formattedMessage = null, IEnumerable<object> payload = null, DateTimeOffset timestamp = default(DateTimeOffset), Guid activityId = default(Guid), Guid relatedActivityId = default(Guid), int processId = 0, int threadId = 0) { return new EventEntry( providerId, eventId, formattedMessage, new ReadOnlyCollection<object>((payload ?? Enumerable.Empty<object>()).ToList()), timestamp != default(DateTimeOffset) ? timestamp : DateTimeOffset.UtcNow, processId, threadId, activityId, relatedActivityId, new EventSchema( eventId, providerId, providerName, level, task, taskName, opcode, opcodeName, keywords, keywordsDescription, version, (payloadNames ?? Enumerable.Empty<string>()))); }
/// <summary> /// Instanciate New Event Message /// </summary> /// <param name="level">as event level</param> /// <param name="action">as event action</param> /// <param name="result">as event result</param> /// <param name="data">as event messages in list</param> /// <param name="app">as application</param> /// <param name="appver">as application version</param> /// <param name="opcode">as operation code</param> /// <param name="keys">as key words</param> /// <param name="uid">us user's identifier</param> /// <param name="ip">as client's ip address</param> /// <param name="url">as assoicated page url</param> public EventMessage(EventLevel level, EventAction action, EventResult result, List<String> data, String app, String appver = "", String opcode = "", String keys = "", String uid = "", String ip = "", String url = "") { SetBase(); Level = level; Action = action; Result = result; Data = data; Application = app; ApplicationVersion = appver; OperationCode = opcode; KeyWords = keys; EventDateTime = DateTime.UtcNow; IP = ip; URL = url; if (!String.IsNullOrEmpty(uid)) UID = new Guid(uid); }
/// <summary> /// Wrapper around writing events /// </summary> /// <param name="Message">Message to write</param> /// <param name="theLevel">The EventLevel</param> /// <param name="SpecificID"></param> public static void Write(string Message, EventLevel theLevel = EventLevel.Information, int SpecificID = 1, string AppName = ChefServiceInstallerDefinition.ChefServiceName) { RegisterEventSource(AppName); switch (theLevel) { case EventLevel.Error: EventLog.WriteEntry(AppName, Message, EventLogEntryType.Error, SpecificID); break; case EventLevel.Information: EventLog.WriteEntry(AppName, Message, EventLogEntryType.Information, SpecificID); break; case EventLevel.Warning: EventLog.WriteEntry(AppName, Message, EventLogEntryType.Warning, SpecificID); break; } }
private static LogLevel MapLogLevel(EventLevel level) { switch (level) { case EventLevel.Error: return LogLevel.Error; case EventLevel.Warning: return LogLevel.Warning; case EventLevel.Informational: return LogLevel.Informational; case EventLevel.Verbose: return LogLevel.Verbose; default: throw new InvalidOperationException(); } }
/// <summary> /// Maps the specified <see cref="System.Diagnostics.Tracing.EventLevel"/> to a <see cref="System.ConsoleColor"/>. /// </summary> /// <param name="eventLevel">The event level.</param> /// <returns>The console color.</returns> public virtual ConsoleColor? Map(EventLevel eventLevel) { switch (eventLevel) { case EventLevel.Critical: return Critical; case EventLevel.Error: return Error; case EventLevel.Warning: return Warning; case EventLevel.Verbose: return Verbose; case EventLevel.LogAlways: return LogAlways; case EventLevel.Informational: return Informational; default: return null; } }
private TraceEventType ConvertLevel(EventLevel level) { switch (level) { case EventLevel.Critical: return TraceEventType.Critical; case EventLevel.Error: return TraceEventType.Error; case EventLevel.Informational: return TraceEventType.Information; case EventLevel.Warning: return TraceEventType.Warning; case EventLevel.Verbose: case EventLevel.LogAlways: default: return TraceEventType.Verbose; } }
public bool IsEnabled(EventLevel level, EventKeywords keywords) { return(false); }
public ITracer StartActivity(string activityName, EventLevel level) { return(new MockTracer()); }
public void AddDiagnosticConsoleEventListener(EventLevel maxVerbosity, Keywords keywordFilter) { this.listeners.Add(new DiagnosticConsoleEventListener(maxVerbosity, keywordFilter)); }
public ConsoleEventListener(Events eventSource, DateTime baseTime, WarningMapper warningMapper = null, EventLevel level = EventLevel.Verbose, bool captureAllDiagnosticMessages = false, TimeDisplay timeDisplay = TimeDisplay.None, EventMask eventMask = null, DisabledDueToDiskWriteFailureEventHandler onDisabledDueToDiskWriteFailure = null, bool listenDiagnosticMessages = false, bool useCustomPipDescription = false) : base(eventSource, baseTime, warningMapper, level, captureAllDiagnosticMessages, timeDisplay, eventMask, onDisabledDueToDiskWriteFailure, listenDiagnosticMessages, useCustomPipDescription) { }
private ListenerRegistration(EventLevel level, Type type, Func <IServiceProvider, object> factory) { Level = level; Type = type; Factory = factory; }
public void AddPrettyConsoleEventListener(EventLevel maxVerbosity, Keywords keywordFilter) { this.listeners.Add(new PrettyConsoleEventListener(maxVerbosity, keywordFilter)); }
public static string EventCode(EventLevel level, string eventName, string prefix) { return($"{GetEventLevelCode(level)}_CHECKOUT_{prefix}_{eventName}"); }
public LogMessage(string message, EventLevel eventLevel) { Message = message; EventLevel = eventLevel; }
public ITracer StartActivity(string childActivityName, EventLevel startStopLevel) { return(this.StartActivity(childActivityName, startStopLevel, null)); }
public virtual void RelatedEvent(EventLevel level, string eventName, EventMetadata metadata, Keywords keyword) { this.WriteEvent(eventName, level, keyword, metadata, opcode: 0); }
public MockListener(EventLevel maxVerbosity, Keywords keywordFilter) : base(maxVerbosity, keywordFilter) { }
internal static void EnableProvider(TraceEventSession session, Guid providerId, EventLevel level, EventKeywords matchAnyKeyword, bool sendManifest = true) { // Make explicit the invocation for requesting the manifest from the EventSource (Provider). var values = sendManifest ? new Dictionary <string, string>() { { "Command", "SendManifest" } } : null; session.EnableProvider(providerId, (TraceEventLevel)level, (ulong)matchAnyKeyword, 0, TraceEventOptions.None, values); }
public ITracer StartActivity(string childActivityName, EventLevel startStopLevel, EventMetadata startMetadata) { return(this.StartActivity(childActivityName, startStopLevel, Keywords.None, startMetadata)); }
public Tracer(StreamJsonRpc.JsonRpc pushRpc, string logFilePath, EventLevel logFileVerbosity, EventLevel outputPaneVerbosity) { Contract.Requires(pushRpc != null); Contract.Requires(!string.IsNullOrEmpty(logFilePath)); Contract.Requires(logFileVerbosity > outputPaneVerbosity, $"Log file verbosity ('{logFileVerbosity}') should be more detailed than output pane verbosity '{outputPaneVerbosity}'."); m_logFilePath = logFilePath; var outputEventWriter = new OutputWindowEventWriter( new OutputWindowReporter(pushRpc), File.CreateText(logFilePath), outputPaneVerbosity); m_loggingListeners = SetupLogging(logFileVerbosity, outputEventWriter); }
public static void WriteLine(string line, EventLevel el = EventLevel.Logging) { Write(line + "\n", el); }
/// <summary> /// Creates a new instance of <see cref="AzureEventSourceListener"/> that forwards events to <see cref="Console.WriteLine(string)"/>. /// </summary> /// <param name="level">The level of events to enable.</param> public static AzureEventSourceListener CreateConsoleLogger(EventLevel level = EventLevel.Informational) { return(new AzureEventSourceListener((eventData, text) => Console.WriteLine("[{1}] {0}: {2}", eventData.EventSource.Name, eventData.Level, text), level)); }
public virtual void RelatedEvent(EventLevel level, string eventName, EventMetadata metadata) { this.RelatedEvent(level, eventName, metadata, Keywords.None); }
public void AddLogFileEventListener(string logFilePath, EventLevel maxVerbosity, Keywords keywordFilter) { this.listeners.Add(new LogFileEventListener(logFilePath, maxVerbosity, keywordFilter)); }
public ExceptionLogMessage(Exception ex, EventLevel eventLevel = EventLevel.Error) : base(ex?.Message, eventLevel) { this.Exception = ex; }
public TypeAnalysis( Type dataType, EventDataAttribute?eventAttrib, List <Type> recursionCheck) { IEnumerable <PropertyInfo> propertyInfos = Statics.GetProperties(dataType); var propertyList = new List <PropertyAnalysis>(); foreach (PropertyInfo propertyInfo in propertyInfos) { if (Statics.HasCustomAttribute(propertyInfo, typeof(EventIgnoreAttribute))) { continue; } if (!propertyInfo.CanRead || propertyInfo.GetIndexParameters().Length != 0) { continue; } MethodInfo?getterInfo = Statics.GetGetMethod(propertyInfo); if (getterInfo == null) { continue; } if (getterInfo.IsStatic || !getterInfo.IsPublic) { continue; } Type propertyType = propertyInfo.PropertyType; var propertyTypeInfo = TraceLoggingTypeInfo.GetInstance(propertyType, recursionCheck); EventFieldAttribute?fieldAttribute = Statics.GetCustomAttribute <EventFieldAttribute>(propertyInfo); string propertyName = fieldAttribute != null && fieldAttribute.Name != null ? fieldAttribute.Name : Statics.ShouldOverrideFieldName(propertyInfo.Name) ? propertyTypeInfo.Name : propertyInfo.Name; propertyList.Add(new PropertyAnalysis( propertyName, propertyInfo, propertyTypeInfo, fieldAttribute)); } this.properties = propertyList.ToArray(); foreach (PropertyAnalysis property in this.properties) { TraceLoggingTypeInfo typeInfo = property.typeInfo; this.level = (EventLevel)Statics.Combine((int)typeInfo.Level, (int)this.level); this.opcode = (EventOpcode)Statics.Combine((int)typeInfo.Opcode, (int)this.opcode); this.keywords |= typeInfo.Keywords; this.tags |= typeInfo.Tags; } if (eventAttrib != null) { this.level = (EventLevel)Statics.Combine((int)eventAttrib.Level, (int)this.level); this.opcode = (EventOpcode)Statics.Combine((int)eventAttrib.Opcode, (int)this.opcode); this.keywords |= eventAttrib.Keywords; this.tags |= eventAttrib.Tags; this.name = eventAttrib.Name; } if (this.name == null) { this.name = dataType.Name; } }
/// <summary> /// Creates a new instance of <see cref="AzureEventSourceListener"/> that forwards events to <see cref="Trace.WriteLine(object)"/>. /// </summary> /// <param name="level">The level of events to enable.</param> public static AzureEventSourceListener CreateTraceLogger(EventLevel level = EventLevel.Informational) { return(new AzureEventSourceListener( (eventData, text) => Trace.WriteLine(string.Format(CultureInfo.InvariantCulture, "[{0}] {1}", eventData.Level, text), eventData.EventSource.Name), level)); }
public DiagnosticConsoleEventListener(EventLevel maxVerbosity, Keywords keywordFilter, IEventListenerEventSink eventSink) : base(maxVerbosity, keywordFilter, eventSink) { }
/// <inheritdoc /> public void WriteLine(EventLevel level, string message) { m_pushRpc .NotifyWithParameterObjectAsync(TraceTargetName, LogMessageParams.Create(level, message)) .IgnoreErrors(); }
private static void VerifyEventLevel(MethodInfo eventMethod, EventWrittenEventArgs actualEvent) { EventLevel expectedLevel = GetEventAttribute(eventMethod).Level; AssertEqual(expectedLevel, actualEvent.Level, "Level"); }
public void EnableEvents(EventSource eventSource, EventLevel level, EventKeywords matchAnyKeyword) { this.EnableEvents(eventSource, level, matchAnyKeyword, (IDictionary <string, string>)null); }
public void GetMetadataForHeartBeatDoesSetsEventLevelToInformationalWhenPlaceholdersHaveBeenCreated() { Mock <IPlaceholderCollection> mockPlaceholderDb = new Mock <IPlaceholderCollection>(MockBehavior.Strict); int filePlaceholderCount = 0; int folderPlaceholderCount = 0; mockPlaceholderDb.Setup(x => x.GetCount()).Returns(() => filePlaceholderCount + folderPlaceholderCount); mockPlaceholderDb.Setup(x => x.AddFile("test.txt", "1111122222333334444455555666667777788888")).Callback(() => ++ filePlaceholderCount); mockPlaceholderDb.Setup(x => x.AddFile("test.txt", "2222233333444445555566666777778888899999")).Callback(() => ++ filePlaceholderCount); mockPlaceholderDb.Setup(x => x.AddFile("test.txt", "3333344444555556666677777888889999900000")).Callback(() => ++ filePlaceholderCount); mockPlaceholderDb.Setup(x => x.AddPartialFolder("foo")).Callback(() => ++ folderPlaceholderCount); mockPlaceholderDb.Setup(x => x.GetFilePlaceholdersCount()).Returns(() => filePlaceholderCount); mockPlaceholderDb.Setup(x => x.GetFolderPlaceholdersCount()).Returns(() => folderPlaceholderCount); Mock <ISparseCollection> mockSparseDb = new Mock <ISparseCollection>(MockBehavior.Strict); mockSparseDb.Setup(x => x.GetAll()).Returns(new HashSet <string>()); using (MockBackgroundFileSystemTaskRunner backgroundTaskRunner = new MockBackgroundFileSystemTaskRunner()) using (FileSystemCallbacks fileSystemCallbacks = new FileSystemCallbacks( this.Repo.Context, this.Repo.GitObjects, RepoMetadata.Instance, new MockBlobSizes(), gitIndexProjection: null, backgroundFileSystemTaskRunner: backgroundTaskRunner, fileSystemVirtualizer: null, placeholderDatabase: mockPlaceholderDb.Object, sparseCollection: mockSparseDb.Object)) { fileSystemCallbacks.OnPlaceholderFileCreated("test.txt", "1111122222333334444455555666667777788888", "GVFS.UnitTests.exe"); EventMetadata metadata = fileSystemCallbacks.GetAndResetHeartBeatMetadata(out bool writeToLogFile); EventLevel eventLevel = writeToLogFile ? EventLevel.Informational : EventLevel.Verbose; eventLevel.ShouldEqual(EventLevel.Informational); // "ModifiedPathsCount" should be 1 because ".gitattributes" is always present metadata.Count.ShouldEqual(8); metadata.ContainsKey("FilePlaceholderCreation").ShouldBeTrue(); metadata.TryGetValue("FilePlaceholderCreation", out object fileNestedMetadata); JsonConvert.SerializeObject(fileNestedMetadata).ShouldContain("\"ProcessName1\":\"GVFS.UnitTests.exe\""); JsonConvert.SerializeObject(fileNestedMetadata).ShouldContain("\"ProcessCount1\":1"); metadata.ShouldContain("ModifiedPathsCount", 1); metadata.ShouldContain("FilePlaceholderCount", 1); metadata.ShouldContain("FolderPlaceholderCount", 0); metadata.ShouldContain(nameof(RepoMetadata.Instance.EnlistmentId), RepoMetadata.Instance.EnlistmentId); metadata.ContainsKey("PhysicalDiskInfo").ShouldBeTrue(); // Create more placeholders fileSystemCallbacks.OnPlaceholderFileCreated("test.txt", "2222233333444445555566666777778888899999", "GVFS.UnitTests.exe2"); fileSystemCallbacks.OnPlaceholderFileCreated("test.txt", "3333344444555556666677777888889999900000", "GVFS.UnitTests.exe2"); fileSystemCallbacks.OnPlaceholderFolderCreated("foo", "GVFS.UnitTests.exe2"); // Hydrate a file fileSystemCallbacks.OnPlaceholderFileHydrated("GVFS.UnitTests.exe2"); metadata = fileSystemCallbacks.GetAndResetHeartBeatMetadata(out bool writeToLogFile2); eventLevel = writeToLogFile2 ? EventLevel.Informational : EventLevel.Verbose; eventLevel.ShouldEqual(EventLevel.Informational); metadata.Count.ShouldEqual(8); // Only processes that have created placeholders since the last heartbeat should be named metadata.ContainsKey("FilePlaceholderCreation").ShouldBeTrue(); metadata.TryGetValue("FilePlaceholderCreation", out object fileNestedMetadata2); JsonConvert.SerializeObject(fileNestedMetadata2).ShouldContain("\"ProcessName1\":\"GVFS.UnitTests.exe2\""); JsonConvert.SerializeObject(fileNestedMetadata2).ShouldContain("\"ProcessCount1\":2"); metadata.ContainsKey("FolderPlaceholderCreation").ShouldBeTrue(); metadata.TryGetValue("FolderPlaceholderCreation", out object folderNestedMetadata2); JsonConvert.SerializeObject(folderNestedMetadata2).ShouldContain("\"ProcessName1\":\"GVFS.UnitTests.exe2\""); JsonConvert.SerializeObject(folderNestedMetadata2).ShouldContain("\"ProcessCount1\":1"); metadata.ContainsKey("FilePlaceholdersHydrated").ShouldBeTrue(); metadata.TryGetValue("FilePlaceholdersHydrated", out object hydrationNestedMetadata2); JsonConvert.SerializeObject(hydrationNestedMetadata2).ShouldContain("\"ProcessName1\":\"GVFS.UnitTests.exe2\""); JsonConvert.SerializeObject(hydrationNestedMetadata2).ShouldContain("\"ProcessCount1\":1"); metadata.ShouldContain("ModifiedPathsCount", 1); metadata.ShouldContain("FilePlaceholderCount", 3); metadata.ShouldContain("FolderPlaceholderCount", 1); metadata.ShouldContain(nameof(RepoMetadata.Instance.EnlistmentId), RepoMetadata.Instance.EnlistmentId); metadata.ContainsKey("PhysicalDiskInfo").ShouldBeTrue(); } mockPlaceholderDb.VerifyAll(); mockSparseDb.VerifyAll(); }
public void EnableEvents(EventSource eventSource, EventLevel level) { this.EnableEvents(eventSource, level, EventKeywords.None); }
public ITracer StartActivity(string activityName, EventLevel level, Keywords startStopKeywords, EventMetadata metadata) { return(new MockTracer()); }
protected override void Output(EventLevel level, int id, string eventName, EventKeywords eventKeywords, string text, bool doNotTranslatePaths = false) { Console.WriteLine($"[{DateTime.Now:HH:mm:ss.ff}] {text}"); }
private JsonEtwTracer(List <InProcEventListener> listeners, Guid parentActivityId, string activityName, EventLevel startStopLevel, Keywords startStopKeywords) { this.listeners = listeners; this.parentActivityId = parentActivityId; this.activityName = activityName; this.startStopLevel = startStopLevel; this.startStopKeywords = startStopKeywords; this.activityId = Guid.NewGuid(); }