/// <summary> /// Writes this exception data into a <see cref="BinaryWriter"/>. /// </summary> /// <param name="w">The writer to use. Can not be null.</param> /// <param name="writeVersion">False to not write the <see cref="CurrentStreamVersion"/>.</param> public void Write(CKBinaryWriter w, bool writeVersion = true) { if (writeVersion) { w.Write(CurrentStreamVersion); } WriteWithoutVersion(w); }
void ComputeSize( GrandOutputEventInfo logEvent, bool increment ) { using( MemoryStream m = new MemoryStream() ) using( CKBinaryWriter w = new CKBinaryWriter( m ) ) { logEvent.Entry.WriteLogEntry( w ); if( increment ) Interlocked.Add( ref SizeHandled, (int)m.Position ); } }
public void LogEntryReadWrite() { var exInner = new CKExceptionData( "message", "typeof(exception)", "assemblyQualifiedName", "stackTrace", null, "fileName", "fusionLog", null, null ); var ex2 = new CKExceptionData( "message2", "typeof(exception2)", "assemblyQualifiedName2", "stackTrace2", exInner, "fileName2", "fusionLog2", null, null ); var exL = new CKExceptionData( "loader-message", "typeof(loader-exception)", "loader-assemblyQualifiedName", "loader-stackTrace", null, "loader-fileName", "loader-fusionLog", null, null ); var exAgg = new CKExceptionData( "agg-message", "typeof(agg-exception)", "agg-assemblyQualifiedName", "agg-stackTrace", ex2, "fileName", "fusionLog", null, new[]{ ex2, exL } ); var prevLog = DateTimeStamp.UtcNow; ILogEntry e1 = LogEntry.CreateLog( "Text1", new DateTimeStamp( DateTime.UtcNow, 42 ), LogLevel.Info, "c:\\test.cs", 3712, ActivityMonitor.Tags.CreateDependentActivity, exAgg ); ILogEntry e2 = LogEntry.CreateMulticastLog( Guid.Empty, LogEntryType.Line, prevLog, 5, "Text2", DateTimeStamp.UtcNow, LogLevel.Fatal, null, 3712, ActivityMonitor.Tags.CreateDependentActivity, exAgg ); using( var mem = new MemoryStream() ) using( var w = new CKBinaryWriter( mem ) ) { w.Write( LogReader.CurrentStreamVersion ); e1.WriteLogEntry( w ); e2.WriteLogEntry( w ); w.Write( (byte)0 ); w.Flush(); byte[] versionBytes = new byte[4]; mem.Position = 0; mem.Read( versionBytes, 0, 4 ); Assert.That( BitConverter.ToInt32( versionBytes, 0 ), Is.EqualTo( LogReader.CurrentStreamVersion ) ); using( var reader = new LogReader( mem, LogReader.CurrentStreamVersion, 4 ) ) { Assert.That( reader.MoveNext() ); Assert.That( reader.Current.Text, Is.EqualTo( e1.Text ) ); Assert.That( reader.Current.LogLevel, Is.EqualTo( e1.LogLevel ) ); Assert.That( reader.Current.LogTime, Is.EqualTo( e1.LogTime ) ); Assert.That( reader.Current.FileName, Is.EqualTo( e1.FileName ) ); Assert.That( reader.Current.LineNumber, Is.EqualTo( e1.LineNumber ) ); Assert.That( reader.Current.Exception.ExceptionTypeAssemblyQualifiedName, Is.EqualTo( e1.Exception.ExceptionTypeAssemblyQualifiedName ) ); Assert.That( reader.Current.Exception.ToString(), Is.EqualTo( e1.Exception.ToString() ) ); Assert.That( reader.MoveNext() ); Assert.That( reader.CurrentMulticast.PreviousEntryType, Is.EqualTo( LogEntryType.Line ) ); Assert.That( reader.CurrentMulticast.PreviousLogTime, Is.EqualTo( prevLog ) ); Assert.That( reader.Current.Text, Is.EqualTo( e2.Text ) ); Assert.That( reader.Current.LogTime, Is.EqualTo( e2.LogTime ) ); Assert.That( reader.Current.FileName, Is.Null ); Assert.That( reader.Current.LineNumber, Is.EqualTo( 0 ), "Since no file name is set, line number is 0." ); Assert.That( reader.Current.Exception.ExceptionTypeAssemblyQualifiedName, Is.EqualTo( e2.Exception.ExceptionTypeAssemblyQualifiedName ) ); Assert.That( reader.Current.Exception.ToString(), Is.EqualTo( e2.Exception.ToString() ) ); Assert.That( reader.MoveNext(), Is.False ); Assert.That( reader.BadEndOfFileMarker, Is.False ); } } }
void WriteWithoutVersion(CKBinaryWriter w) { if (w == null) { throw new ArgumentNullException("w"); } w.Write(_message); w.Write(_exceptionTypeName); w.Write(_exceptionTypeAQName); w.WriteNullableString(_stackTrace); w.WriteNullableString(_fileName); w.WriteNullableString(_detailedInfo); if (_aggregatedExceptions != null) { w.WriteSmallInt32(_aggregatedExceptions.Length); foreach (var agg in _aggregatedExceptions) { agg.WriteWithoutVersion(w); } } else { if (_innerException != null) { w.WriteSmallInt32(0); _innerException.WriteWithoutVersion(w); } else { w.WriteSmallInt32(-1); } } if (_loaderExceptions != null) { w.WriteNonNegativeSmallInt32(_loaderExceptions.Length); foreach (var ld in _loaderExceptions) { ld.WriteWithoutVersion(w); } } else { w.WriteNonNegativeSmallInt32(0); } }
public override void WriteLogEntry( CKBinaryWriter w ) { LogEntry.WriteCloseGroup( w, _monitorId, _previousEntryType, _previousLogTime, _depth, LogLevel, LogTime, Conclusions ); }
/// <summary> /// Called when the current file is closed. /// </summary> protected override void CloseCurrentFile() { _writer.Write( (byte)0 ); base.CloseCurrentFile(); _writer.Dispose(); _writer = null; }
static void DoWriteLog( CKBinaryWriter w, StreamLogType t, LogLevel level, DateTimeStamp logTime, string text, CKTrait tags, CKExceptionData ex, string fileName, int lineNumber ) { if( tags != null && !tags.IsEmpty ) t |= StreamLogType.HasTags; if( ex != null ) { t |= StreamLogType.HasException; if( text == ex.Message ) t |= StreamLogType.IsTextTheExceptionMessage; } if( fileName != null ) t |= StreamLogType.HasFileName; if( logTime.Uniquifier != 0 ) t |= StreamLogType.HasUniquifier; WriteLogTypeAndLevel( w, t, level ); w.Write( logTime.TimeUtc.ToBinary() ); if( logTime.Uniquifier != 0 ) w.Write( logTime.Uniquifier ); if( (t & StreamLogType.HasTags) != 0 ) w.Write( tags.ToString() ); if( (t & StreamLogType.HasFileName) != 0 ) { w.Write( fileName ); w.WriteNonNegativeSmallInt32( lineNumber ); } if( (t & StreamLogType.HasException) != 0 ) ex.Write( w ); if( (t & StreamLogType.IsTextTheExceptionMessage) == 0 ) w.Write( text ); }
public override void WriteLogEntry( CKBinaryWriter w ) { LogEntry.WriteLog( w, _monitorId, _previousEntryType, _previousLogTime, _depth, false, LogLevel, LogTime, Text, Tags, Exception, FileName, LineNumber ); }
void WriteWithoutVersion( CKBinaryWriter w ) { if( w == null ) throw new ArgumentNullException( "w" ); w.Write( _message ); w.Write( _exceptionTypeName ); w.Write( _exceptionTypeAQName ); w.WriteNullableString( _stackTrace ); w.WriteNullableString( _fileName ); w.WriteNullableString( _detailedInfo ); if( _aggregatedExceptions != null ) { w.WriteSmallInt32( _aggregatedExceptions.Length ); foreach( var agg in _aggregatedExceptions ) agg.WriteWithoutVersion( w ); } else { if( _innerException != null ) { w.WriteSmallInt32( 0 ); _innerException.WriteWithoutVersion( w ); } else w.WriteSmallInt32( -1 ); } if( _loaderExceptions != null ) { w.WriteNonNegativeSmallInt32( _loaderExceptions.Length ); foreach( var ld in _loaderExceptions ) ld.WriteWithoutVersion( w ); } else w.WriteNonNegativeSmallInt32( 0 ); }
public virtual void WriteLogEntry( CKBinaryWriter w ) { LogEntry.WriteCloseGroup( w, _level, _time, _conclusions ); }
/// <summary> /// Binary writes a log entry. /// </summary> /// <param name="w">Binary writer to use.</param> /// <param name="isOpenGroup">True if this the opening of a group. False for a line.</param> /// <param name="level">Log level of the log entry.</param> /// <param name="text">Text of the log entry.</param> /// <param name="logTime">Time stamp of the log entry.</param> /// <param name="tags">Tags of the log entry</param> /// <param name="ex">Exception of the log entry.</param> /// <param name="fileName">Source file name of the log entry</param> /// <param name="lineNumber">Source line number of the log entry</param> static public void WriteLog( CKBinaryWriter w, bool isOpenGroup, LogLevel level, DateTimeStamp logTime, string text, CKTrait tags, CKExceptionData ex, string fileName, int lineNumber ) { if( w == null ) throw new ArgumentNullException( "w" ); DoWriteLog( w, isOpenGroup ? StreamLogType.TypeOpenGroup : StreamLogType.TypeLine, level, logTime, text, tags, ex, fileName, lineNumber ); }
/// <summary> /// Writes this exception data into a <see cref="BinaryWriter"/>. /// </summary> /// <param name="w">The writer to use. Can not be null.</param> /// <param name="writeVersion">False to not write the <see cref="CurrentStreamVersion"/>.</param> public void Write( CKBinaryWriter w, bool writeVersion = true ) { if( writeVersion ) w.Write( CurrentStreamVersion ); WriteWithoutVersion( w ); }
/// <summary> /// Binary writes a closing entry. /// </summary> /// <param name="w">Binary writer to use.</param> /// <param name="level">Log level of the log entry.</param> /// <param name="closeTime">Time stamp of the group closing.</param> /// <param name="conclusions">Group conclusions.</param> static public void WriteCloseGroup( CKBinaryWriter w, LogLevel level, DateTimeStamp closeTime, IReadOnlyList<ActivityLogGroupConclusion> conclusions ) { if( w == null ) throw new ArgumentNullException( "w" ); DoWriteCloseGroup( w, StreamLogType.TypeGroupClosed, level, closeTime, conclusions ); }
/// <summary> /// Called when a new file is created. /// </summary> /// <returns>The created stream.</returns> protected override Stream OpenNewFile() { Stream s = base.OpenNewFile(); _writer = new CKBinaryWriter( s ); _writer.Write( LogReader.FileHeader ); _writer.Write( LogReader.CurrentStreamVersion ); return s; }
static void DoWriteCloseGroup( CKBinaryWriter w, StreamLogType t, LogLevel level, DateTimeStamp closeTime, IReadOnlyList<ActivityLogGroupConclusion> conclusions ) { if( conclusions != null && conclusions.Count > 0 ) t |= StreamLogType.HasConclusions; if( closeTime.Uniquifier != 0 ) t |= StreamLogType.HasUniquifier; WriteLogTypeAndLevel( w, t, level ); w.Write( closeTime.TimeUtc.ToBinary() ); if( closeTime.Uniquifier != 0 ) w.Write( closeTime.Uniquifier ); if( (t & StreamLogType.HasConclusions) != 0 ) { w.WriteNonNegativeSmallInt32( conclusions.Count ); foreach( ActivityLogGroupConclusion c in conclusions ) { w.Write( c.Tag.ToString() ); w.Write( c.Text ); } } }
static void WriteMulticastFooter( CKBinaryWriter w, Guid monitorId, LogEntryType previousEntryType, DateTimeStamp previousStamp, int depth ) { w.Write( monitorId.ToByteArray() ); w.WriteNonNegativeSmallInt32( depth ); if( previousStamp.IsKnown ) { w.Write( previousStamp.TimeUtc.ToBinary() ); if( previousStamp.Uniquifier != 0 ) w.Write( previousStamp.Uniquifier ); w.Write( (byte)previousEntryType ); } }
/// <summary> /// Binary writes a multicast closing entry. /// </summary> /// <param name="w">Binary writer to use.</param> /// <param name="monitorId">Identifier of the monitor.</param> /// <param name="previousEntryType">Log type of the previous entry in the monitor..</param> /// <param name="previousLogTime">Time stamp of the previous entry in the monitor.</param> /// <param name="depth">Depth of the group (number of opened groups above).</param> /// <param name="level">Log level of the log entry.</param> /// <param name="closeTime">Time stamp of the group closing.</param> /// <param name="conclusions">Group conclusions.</param> static public void WriteCloseGroup( CKBinaryWriter w, Guid monitorId, LogEntryType previousEntryType, DateTimeStamp previousLogTime, int depth, LogLevel level, DateTimeStamp closeTime, IReadOnlyList<ActivityLogGroupConclusion> conclusions ) { if( w == null ) throw new ArgumentNullException( "w" ); StreamLogType type = StreamLogType.TypeGroupClosed | StreamLogType.IsMultiCast; type = UpdateTypeWithPrevious( type, previousEntryType, ref previousLogTime ); DoWriteCloseGroup( w, type, level, closeTime, conclusions ); WriteMulticastFooter( w, monitorId, previousEntryType, previousLogTime, depth ); }
public virtual void WriteLogEntry( CKBinaryWriter w ) { LogEntry.WriteLog( w, true, _level, _time, _text, _tags, _ex, _fileName, _lineNumber ); }
/// <summary> /// Binary writes a multicast log entry. /// </summary> /// <param name="w">Binary writer to use.</param> /// <param name="monitorId">Identifier of the monitor.</param> /// <param name="previousEntryType">Log type of the previous entry in the monitor..</param> /// <param name="previousLogTime">Time stamp of the previous entry in the monitor.</param> /// <param name="depth">Depth of the line (number of opened groups above).</param> /// <param name="isOpenGroup">True if this the opening of a group. False for a line.</param> /// <param name="text">Text of the log entry.</param> /// <param name="level">Log level of the log entry.</param> /// <param name="logTime">Time stamp of the log entry.</param> /// <param name="tags">Tags of the log entry</param> /// <param name="ex">Exception of the log entry.</param> /// <param name="fileName">Source file name of the log entry</param> /// <param name="lineNumber">Source line number of the log entry</param> static public void WriteLog( CKBinaryWriter w, Guid monitorId, LogEntryType previousEntryType, DateTimeStamp previousLogTime, int depth, bool isOpenGroup, LogLevel level, DateTimeStamp logTime, string text, CKTrait tags, CKExceptionData ex, string fileName, int lineNumber ) { if( w == null ) throw new ArgumentNullException( "w" ); StreamLogType type = StreamLogType.IsMultiCast | (isOpenGroup ? StreamLogType.TypeOpenGroup : StreamLogType.TypeLine); type = UpdateTypeWithPrevious( type, previousEntryType, ref previousLogTime ); DoWriteLog( w, type, level, logTime, text, tags, ex, fileName, lineNumber ); WriteMulticastFooter( w, monitorId, previousEntryType, previousLogTime, depth ); }