Ejemplo n.º 1
0
 /// <summary>
 /// Initializes a new <see cref="CKExceptionData"/> with all its fields.
 /// Use the factory method <see cref="CreateFrom"/> to create a data from any exception.
 /// </summary>
 /// <param name="message">Message of the exception. Must not be null.</param>
 /// <param name="exceptionTypeName">Type name of the exception (no namespace nor assembly). Must not be null nor empty..</param>
 /// <param name="exceptionTypeAssemblyQualifiedName">Full type name of the exception. Must not be null nor empty.</param>
 /// <param name="stackTrace">Stack trace. Can be null.</param>
 /// <param name="innerException">Inner exception. If <paramref name="aggregatedExceptions"/> is not null, it must be the same as the first aggregated exceptions.</param>
 /// <param name="fileName">File name related to the exception (if it makes sense). Can be null.</param>
 /// <param name="detailedInfo">More detailed information if any.</param>
 /// <param name="loaderExceptions">Loader exceptions. <see cref="LoaderExceptions"/>.</param>
 /// <param name="aggregatedExceptions">Aggregated exceptions can be null. Otherwise, it must contain at least one exception.</param>
 public CKExceptionData(
     string message,
     string exceptionTypeName,
     string exceptionTypeAssemblyQualifiedName,
     string stackTrace,
     CKExceptionData innerException,
     string fileName,
     string detailedInfo,
     CKExceptionData[] loaderExceptions,
     CKExceptionData[] aggregatedExceptions )
 {
     if( message == null ) throw new ArgumentNullException( nameof( message ) );
     if( String.IsNullOrWhiteSpace( exceptionTypeName ) ) throw new ArgumentNullException( nameof( exceptionTypeName ) );
     if( String.IsNullOrWhiteSpace( exceptionTypeAssemblyQualifiedName ) ) throw new ArgumentNullException( nameof( exceptionTypeAssemblyQualifiedName ) );
     if( aggregatedExceptions != null && aggregatedExceptions.Length == 0 ) throw new ArgumentException( Impl.CoreResources.AggregatedExceptionsMustContainAtLeastOne, nameof( aggregatedExceptions ) );
     if( innerException != null && aggregatedExceptions != null && aggregatedExceptions[0] != innerException ) throw new ArgumentException( Impl.CoreResources.InnerExceptionMustBeTheFirstAggregatedException );
     // No empty array for loaderExceptions: null or at least one inside.
     if( loaderExceptions != null && loaderExceptions.Length == 0 ) loaderExceptions = null;
     _message = message;
     _exceptionTypeName = exceptionTypeName;
     _exceptionTypeAQName = exceptionTypeAssemblyQualifiedName;
     _stackTrace = String.IsNullOrWhiteSpace( stackTrace ) ? null : stackTrace;
     _innerException = innerException;
     _fileName = fileName;
     _detailedInfo = detailedInfo;
     _loaderExceptions = loaderExceptions;
     _aggregatedExceptions = aggregatedExceptions;
 }
Ejemplo n.º 2
0
 /// <summary>
 /// Creates a <see cref="CKException"/> from a <see cref="CKExceptionData"/>. This method returns null when data is null.
 /// This is the symmetric of <see cref="CKExceptionData.CreateFrom"/>.
 /// </summary>
 /// <param name="data">Data of an exception for which a <see cref="CKException"/> wrapper must be created. Can be null: null is returned.</param>
 /// <returns>The exception that wraps the data.</returns>
 static public CKException CreateFrom(CKExceptionData data)
 {
     if (data == null)
     {
         return(null);
     }
     return(new CKException(data));
 }
Ejemplo n.º 3
0
 /// <summary>
 /// If <see cref="ExceptionData"/> is null, this method creates the <see cref="CKExceptionData"/>
 /// with the details from this exception.
 /// </summary>
 /// <returns>The <see cref="CKExceptionData"/> that describes this exception.</returns>
 public CKExceptionData EnsureExceptionData()
 {
     if (_exceptionData == null)
     {
         _exceptionData = new CKExceptionData(Message, "CKException", GetType().AssemblyQualifiedName, StackTrace, CKExceptionData.CreateFrom(InnerException), null, null, null, null);
     }
     return(_exceptionData);
 }
Ejemplo n.º 4
0
 public LEMCLog( Guid monitorId, int depth, DateTimeStamp previousLogTime, LogEntryType previousEntryType, string text, DateTimeStamp t, string fileName, int lineNumber, LogLevel l, CKTrait tags, CKExceptionData ex )
     : base( text, t, fileName, lineNumber, l, tags, ex )
 {
     _monitorId = monitorId;
     _depth = depth;
     _previousEntryType = previousEntryType;
     _previousLogTime = previousLogTime;
 }
Ejemplo n.º 5
0
 public LEOpenGroup( LEMCOpenGroup e )
 {
     _text = e.Text;
     _time = e.LogTime;
     _fileName = e.FileName;
     _lineNumber = e.LineNumber;
     _level = e.LogLevel;
     _tags = e.Tags;
     _ex = e.Exception;
 }
Ejemplo n.º 6
0
 public LEOpenGroup( string text, DateTimeStamp t, string fileName, int lineNumber, LogLevel l, CKTrait tags, CKExceptionData ex )
 {
     _text = text;
     _time = t;
     _fileName = fileName;
     _lineNumber = lineNumber;
     _level = l;
     _tags = tags;
     _ex = ex;
 }
Ejemplo n.º 7
0
        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 );
                }
            }

        }
Ejemplo n.º 8
0
 /// <summary>
 /// Initializes a new <see cref="CKExceptionData"/> with all its fields.
 /// Use the factory method <see cref="CreateFrom"/> to create a data from any exception.
 /// </summary>
 /// <param name="message">Message of the exception. Must not be null.</param>
 /// <param name="exceptionTypeName">Type name of the exception (no namespace nor assembly). Must not be null nor empty..</param>
 /// <param name="exceptionTypeAssemblyQualifiedName">Full type name of the exception. Must not be null nor empty.</param>
 /// <param name="stackTrace">Stack trace. Can be null.</param>
 /// <param name="innerException">Inner exception. If <paramref name="aggregatedExceptions"/> is not null, it must be the same as the first aggregated exceptions.</param>
 /// <param name="fileName">File name related to the exception (if it makes sense). Can be null.</param>
 /// <param name="detailedInfo">More detailed information if any.</param>
 /// <param name="loaderExceptions">Loader exceptions. <see cref="LoaderExceptions"/>.</param>
 /// <param name="aggregatedExceptions">Aggregated exceptions can be null. Otherwise, it must contain at least one exception.</param>
 public CKExceptionData(
     string message,
     string exceptionTypeName,
     string exceptionTypeAssemblyQualifiedName,
     string stackTrace,
     CKExceptionData innerException,
     string fileName,
     string detailedInfo,
     CKExceptionData[] loaderExceptions,
     CKExceptionData[] aggregatedExceptions)
 {
     if (message == null)
     {
         throw new ArgumentNullException(nameof(message));
     }
     if (String.IsNullOrWhiteSpace(exceptionTypeName))
     {
         throw new ArgumentNullException(nameof(exceptionTypeName));
     }
     if (String.IsNullOrWhiteSpace(exceptionTypeAssemblyQualifiedName))
     {
         throw new ArgumentNullException(nameof(exceptionTypeAssemblyQualifiedName));
     }
     if (aggregatedExceptions != null && aggregatedExceptions.Length == 0)
     {
         throw new ArgumentException(Impl.CoreResources.AggregatedExceptionsMustContainAtLeastOne, nameof(aggregatedExceptions));
     }
     if (innerException != null && aggregatedExceptions != null && aggregatedExceptions[0] != innerException)
     {
         throw new ArgumentException(Impl.CoreResources.InnerExceptionMustBeTheFirstAggregatedException);
     }
     // No empty array for loaderExceptions: null or at least one inside.
     if (loaderExceptions != null && loaderExceptions.Length == 0)
     {
         loaderExceptions = null;
     }
     _message              = message;
     _exceptionTypeName    = exceptionTypeName;
     _exceptionTypeAQName  = exceptionTypeAssemblyQualifiedName;
     _stackTrace           = String.IsNullOrWhiteSpace(stackTrace) ? null : stackTrace;
     _innerException       = innerException;
     _fileName             = fileName;
     _detailedInfo         = detailedInfo;
     _loaderExceptions     = loaderExceptions;
     _aggregatedExceptions = aggregatedExceptions;
 }
Ejemplo n.º 9
0
        /// <summary>
        /// Initializes a new <see cref="CKExceptionData"/> from a <see cref="CKBinaryReader"/>
        /// with a known version.
        /// See <see cref="Write(CKBinaryWriter,bool)"/>.
        /// </summary>
        /// <param name="r">The reader to read from.</param>
        /// <param name="streamIsCRLF">Whether the strings have CRLF or LF for end-of-lines.</param>
        /// <param name="version">Known version.</param>
        public CKExceptionData(CKBinaryReader r, bool streamIsCRLF, int version)
        {
            if (r == null)
            {
                throw new ArgumentNullException("r");
            }
            _message             = r.ReadString(streamIsCRLF);
            _exceptionTypeName   = r.ReadString();
            _exceptionTypeAQName = r.ReadString();
            _stackTrace          = r.ReadNullableString(streamIsCRLF);
            _fileName            = r.ReadNullableString();
            _detailedInfo        = r.ReadNullableString(streamIsCRLF);

            int nbAgg = version == 0 ? r.ReadInt32() : r.ReadSmallInt32();

            if (nbAgg > 0)
            {
                _aggregatedExceptions = new CKExceptionData[nbAgg];
                for (int i = 0; i < nbAgg; ++i)
                {
                    _aggregatedExceptions[i] = new CKExceptionData(r, streamIsCRLF, version == 0 ? r.ReadInt32() : version);
                }
                _innerException = _aggregatedExceptions[0];
            }
            else
            {
                if (nbAgg == 0)
                {
                    _innerException = new CKExceptionData(r, streamIsCRLF, version == 0 ? r.ReadInt32() : version);
                }
            }

            int nbLd = version == 0 ? r.ReadInt32() : r.ReadNonNegativeSmallInt32();

            if (nbLd != 0)
            {
                _loaderExceptions = new CKExceptionData[nbLd];
                for (int i = 0; i < nbLd; ++i)
                {
                    _loaderExceptions[i] = new CKExceptionData(r, streamIsCRLF, version == 0 ? r.ReadInt32() : version);
                }
            }
        }
Ejemplo n.º 10
0
 /// <summary>
 /// Gets or creates the <see cref="CKExceptionData"/> that captures exception information.
 /// If <see cref="P:Exception"/> is null, this returns null.
 /// </summary>
 /// <returns>A data representation of the exception or null.</returns>
 public CKExceptionData EnsureExceptionData()
 {
     return _exceptionData ?? (_exceptionData = CKExceptionData.CreateFrom( _exception ));
 }
Ejemplo n.º 11
0
 /// <summary>
 /// Gets or creates the <see cref="CKExceptionData"/> that captures exception information.
 /// If <see cref="P:Exception"/> is null, this returns null.
 /// </summary>
 /// <returns>A data representation of the exception or null.</returns>
 public CKExceptionData EnsureExceptionData()
 {
     return(_exceptionData ?? (_exceptionData = CKExceptionData.CreateFrom(_exception)));
 }
Ejemplo n.º 12
0
        /// <summary>
        /// Reads a <see cref="ILogEntry"/> from the binary reader that can be a <see cref="IMulticastLogEntry"/>.
        /// If the first read byte is 0, read stops and null is returned.
        /// The 0 byte is the "end marker" that <see cref="CKMonWriterClient.Close()"/> write, but this
        /// method can read non zero-terminated streams (it catches an EndOfStreamException when reading the first byte and handles it silently).
        /// This method can throw any type of exception (<see cref="System.IO.EndOfStreamException"/> or <see cref="InvalidDataException"/> for instance) that
        /// must be handled by the caller.
        /// </summary>
        /// <param name="r">The binary reader.</param>
        /// <param name="streamVersion">The version of the stream.</param>
        /// <param name="badEndOfFile">True whenever the end of file is the result of an <see cref="EndOfStreamException"/>.</param>
        /// <returns>The log entry or null if a zero byte (end marker) has been found.</returns>
        static public ILogEntry Read( CKBinaryReader r, int streamVersion, out bool badEndOfFile )
        {
            if( r == null ) throw new ArgumentNullException( "r" );
            badEndOfFile = false;
            StreamLogType t = StreamLogType.EndOfStream;
            LogLevel logLevel = LogLevel.None;
            try
            {
                ReadLogTypeAndLevel( r, out t, out logLevel );
            }
            catch( EndOfStreamException )
            {
                badEndOfFile = true;
                // Silently ignores here reading beyond the stream: this
                // kindly handles the lack of terminating 0 byte.
            }
            if( t == StreamLogType.EndOfStream ) return null;

            if( (t & StreamLogType.TypeMask) == StreamLogType.TypeGroupClosed )
            {
                return ReadGroupClosed( streamVersion, r, t, logLevel );
            }
            DateTimeStamp time = new DateTimeStamp( DateTime.FromBinary( r.ReadInt64() ), (t & StreamLogType.HasUniquifier) != 0 ? r.ReadByte() : (Byte)0 );
            if( time.TimeUtc.Year < 2014 || time.TimeUtc.Year > 3000 ) throw new InvalidDataException( "Date year before 2014 or after 3000 are considered invalid." );
            CKTrait tags = ActivityMonitor.Tags.Empty;
            string fileName = null;
            int lineNumber = 0;
            CKExceptionData ex = null;
            string text = null;

            if( (t & StreamLogType.HasTags) != 0 ) tags = ActivityMonitor.Tags.Register( r.ReadString() );
            if( (t & StreamLogType.HasFileName) != 0 )
            {
                fileName = r.ReadString();
                lineNumber = streamVersion < 6 ? r.ReadInt32() : r.ReadNonNegativeSmallInt32();
                if( lineNumber > 100*1000 ) throw new InvalidDataException( "LineNumber greater than 100K is considered invalid." );
            }
            if( (t & StreamLogType.HasException) != 0 )
            {
                ex = new CKExceptionData( r, (t & StreamLogType.IsLFOnly) == 0 );
                if( (t & StreamLogType.IsTextTheExceptionMessage) != 0 ) text = ex.Message;
            }
            if( text == null ) text = r.ReadString( (t & StreamLogType.IsLFOnly) == 0 );

            Guid mId;
            int depth;
            LogEntryType prevType;
            DateTimeStamp prevTime;

            if( (t & StreamLogType.TypeMask) == StreamLogType.TypeLine )
            {
                if( (t & StreamLogType.IsMultiCast) == 0 )
                {
                    return new LELog( text, time, fileName, lineNumber, logLevel, tags, ex );
                }
                ReadMulticastFooter( streamVersion, r, t, out mId, out depth, out prevType, out prevTime );
                return new LEMCLog( mId, depth, prevTime, prevType, text, time, fileName, lineNumber, logLevel, tags, ex );
            }
            if( (t & StreamLogType.TypeMask) != StreamLogType.TypeOpenGroup ) throw new InvalidDataException();
            if( (t & StreamLogType.IsMultiCast) == 0 )
            {
                return new LEOpenGroup( text, time, fileName, lineNumber, logLevel, tags, ex );
            }
            ReadMulticastFooter( streamVersion, r, t, out mId, out depth, out prevType, out prevTime );
            return new LEMCOpenGroup( mId, depth, prevTime, prevType, text, time, fileName, lineNumber, logLevel, tags, ex );
        }
Ejemplo n.º 13
0
        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 );
        }
Ejemplo n.º 14
0
 /// <summary>
 /// Initializes a new <see cref="CKException"/> with an <see cref="ExceptionData"/>.
 /// The message of this exception is the <see cref="CKExceptionData.Message"/>.
 /// Use the static <see cref="CreateFrom"/> to handle null data (a null CKException will be returned).
 /// </summary>
 /// <param name="data">The exception data. Must not be null.</param>
 public CKException(CKExceptionData data)
     : this(data.Message)
 {
     _exceptionData = data;
 }
Ejemplo n.º 15
0
 /// <summary>
 /// If <see cref="ExceptionData"/> is null, this method creates the <see cref="CKExceptionData"/> with the details
 /// from this exception.
 /// </summary>
 /// <returns>The <see cref="CKExceptionData"/> that describes this exception.</returns>
 public CKExceptionData EnsureExceptionData()
 {
     if( _exceptionData == null )
     {
         _exceptionData = new CKExceptionData( Message, "CKException", GetType().AssemblyQualifiedName, StackTrace, CKExceptionData.CreateFrom( InnerException ), null, null, null, null );
     }
     return _exceptionData; 
 }
Ejemplo n.º 16
0
        static string DumpErrorText(DateTimeStamp logTime, string text, LogLevel level, CKTrait tags, CKExceptionData exData)
        {
            StringBuilder buffer = CreateHeader(logTime, text, level, tags);

            if (exData != null)
            {
                exData.ToStringBuilder(buffer, String.Empty);
            }
            WriteFooter(level, buffer);
            return(buffer.ToString());
        }
Ejemplo n.º 17
0
 /// <summary>
 /// Initializes a new <see cref="CKException"/> with an <see cref="ExceptionData"/>.
 /// The message of this exception is the <see cref="CKExceptionData.Message"/>.
 /// Use the static <see cref="CreateFrom"/> to handle null data (a null CKException will be returned).
 /// </summary>
 /// <param name="data">The exception data. Must not be null.</param>
 public CKException( CKExceptionData data )
     : this( data.Message )
 {
     _exceptionData = data;
 }
Ejemplo n.º 18
0
 /// <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 );
 }
Ejemplo n.º 19
0
        /// <summary>
        /// Initializes a new <see cref="CKExceptionData"/> from a <see cref="CKBinaryReader"/>
        /// with a known version. 
        /// See <see cref="Write(CKBinaryWriter,bool)"/>.
        /// </summary>
        /// <param name="r">The reader to read from.</param>
        /// <param name="streamIsCRLF">Whether the strings have CRLF or LF for end-of-lines.</param>
        /// <param name="version">Known version.</param>
        public CKExceptionData( CKBinaryReader r, bool streamIsCRLF, int version )
        {
            if( r == null ) throw new ArgumentNullException( "r" );
            _message = r.ReadString( streamIsCRLF );
            _exceptionTypeName = r.ReadString();
            _exceptionTypeAQName = r.ReadString();
            _stackTrace = r.ReadNullableString( streamIsCRLF );
            _fileName = r.ReadNullableString();
            _detailedInfo = r.ReadNullableString( streamIsCRLF );

            int nbAgg = version == 0 ? r.ReadInt32() : r.ReadSmallInt32();
            if( nbAgg > 0 )
            {
                _aggregatedExceptions = new CKExceptionData[nbAgg];
                for( int i = 0; i < nbAgg; ++i ) _aggregatedExceptions[i] = new CKExceptionData( r, streamIsCRLF, version == 0 ? r.ReadInt32() : version );
                _innerException = _aggregatedExceptions[0];
            }
            else
            {
                if( nbAgg == 0 ) _innerException = new CKExceptionData( r, streamIsCRLF, version == 0 ? r.ReadInt32() : version );
            }

            int nbLd = version == 0 ? r.ReadInt32() : r.ReadNonNegativeSmallInt32();
            if( nbLd != 0 )
            {
                _loaderExceptions = new CKExceptionData[nbLd];
                for( int i = 0; i < nbLd; ++i ) _loaderExceptions[i] = new CKExceptionData( r, streamIsCRLF, version == 0 ? r.ReadInt32() : version );
            }
        }
Ejemplo n.º 20
0
        /// <summary>
        /// Creates a <see cref="CKExceptionData"/> from any <see cref="Exception"/>.
        /// </summary>
        /// <param name="ex">Exception for which data must be created. Can be null: null is returned.</param>
        /// <returns>The data that describes the exception.</returns>
        static public CKExceptionData CreateFrom( Exception ex )
        {
            if( ex == null ) return null;
            CKException ckEx = ex as CKException;
            if( ckEx != null ) return ckEx.EnsureExceptionData();
            Type t = ex.GetType();
            string exceptionTypeName = t.Name;
            string exceptionTypeAssemblyQualifiedName = t.AssemblyQualifiedName;

            CKExceptionData innerException;
            CKExceptionData[] aggregatedExceptions = null;
            var aggEx = ex as AggregateException;
            if( aggEx != null )
            {
                CKExceptionData[] a = new CKExceptionData[aggEx.InnerExceptions.Count];
                for( int i = 0; i < a.Length; ++i ) a[i] = CreateFrom( aggEx.InnerExceptions[i] );
                innerException = a[0];
                aggregatedExceptions = a;
            }
            else innerException = CreateFrom( ex.InnerException );

            string fileName = null;
            string detailedInfo = null;

            CKExceptionData[] loaderExceptions = null;
            var typeLoadEx = ex as ReflectionTypeLoadException;
            if( typeLoadEx != null )
            {
                CKExceptionData[] a = new CKExceptionData[typeLoadEx.LoaderExceptions.Length];
                for( int i = 0; i < a.Length; ++i ) a[i] = CreateFrom( typeLoadEx.LoaderExceptions[i] );
                loaderExceptions = a;
            }
            else
            {
                var fileNFEx = ex as System.IO.FileNotFoundException;
                if( fileNFEx != null )
                {
                    fileName = fileNFEx.FileName;
                    #if NET451 || NET46
                    detailedInfo = fileNFEx.FusionLog.NormalizeEOL();
                    #endif
                }
                else
                {
                    var loadFileEx = ex as System.IO.FileLoadException;
                    if( loadFileEx != null )
                    {
                        fileName = loadFileEx.FileName;
                        #if NET451 || NET46
                        detailedInfo = loadFileEx.FusionLog.NormalizeEOL();
                        #endif
                    }
                    else
                    {
                        #if NET451 || NET46
                        var configEx = ex as System.Configuration.ConfigurationException;
                        if( configEx != null )
                        {
                            fileName = configEx.Filename;
                        }
                        #endif
                    }
                }
            }
            return new CKExceptionData( ex.Message, exceptionTypeName, exceptionTypeAssemblyQualifiedName, ex.StackTrace, innerException, fileName, detailedInfo, loaderExceptions, aggregatedExceptions );
        }
Ejemplo n.º 21
0
 /// <summary>
 /// Creates a <see cref="ILogEntry"/> for an opened group.
 /// </summary>
 /// <param name="text">Text of the log entry.</param>
 /// <param name="t">Time stamp of the log entry.</param>
 /// <param name="level">Log level 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>
 /// <param name="tags">Tags of the log entry</param>
 /// <param name="ex">Exception of the log entry.</param>
 /// <returns>A log entry object.</returns>
 public static ILogEntry CreateOpenGroup( string text, DateTimeStamp t, LogLevel level, string fileName, int lineNumber, CKTrait tags, CKExceptionData ex )
 {
     return new LEOpenGroup( text, t, fileName, lineNumber, level, tags, ex );
 }
Ejemplo n.º 22
0
 /// <summary>
 /// Creates a <see cref="ILogEntry"/> for a line.
 /// </summary>
 /// <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="text">Text of the log entry.</param>
 /// <param name="t">Time stamp of the log entry.</param>
 /// <param name="level">Log level 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>
 /// <param name="tags">Tags of the log entry</param>
 /// <param name="ex">Exception of the log entry.</param>
 /// <returns>A log entry object.</returns>
 public static IMulticastLogEntry CreateMulticastLog( Guid monitorId, LogEntryType previousEntryType, DateTimeStamp previousLogTime, int depth, string text, DateTimeStamp t, LogLevel level, string fileName, int lineNumber, CKTrait tags, CKExceptionData ex )
 {
     return new LEMCLog( monitorId, depth, previousLogTime, previousEntryType, text, t, fileName, lineNumber, level, tags, ex );
 }
Ejemplo n.º 23
0
        /// <summary>
        /// Creates a <see cref="CKExceptionData"/> from any <see cref="Exception"/>.
        /// </summary>
        /// <param name="ex">Exception for which data must be created. Can be null: null is returned.</param>
        /// <returns>The data that describes the exception.</returns>
        static public CKExceptionData CreateFrom(Exception ex)
        {
            if (ex == null)
            {
                return(null);
            }
            Type   t = ex.GetType();
            string exceptionTypeName = t.Name;
            string exceptionTypeAssemblyQualifiedName = t.AssemblyQualifiedName;

            CKExceptionData innerException;

            CKExceptionData[] aggregatedExceptions = null;
            var aggEx = ex as AggregateException;

            if (aggEx != null)
            {
                CKExceptionData[] a = new CKExceptionData[aggEx.InnerExceptions.Count];
                for (int i = 0; i < a.Length; ++i)
                {
                    a[i] = CreateFrom(aggEx.InnerExceptions[i]);
                }
                innerException       = a[0];
                aggregatedExceptions = a;
            }
            else
            {
                innerException = CreateFrom(ex.InnerException);
            }

            string fileName     = null;
            string detailedInfo = null;

            CKExceptionData[] loaderExceptions = null;
            var typeLoadEx = ex as ReflectionTypeLoadException;

            if (typeLoadEx != null)
            {
                CKExceptionData[] a = new CKExceptionData[typeLoadEx.LoaderExceptions.Length];
                for (int i = 0; i < a.Length; ++i)
                {
                    a[i] = CreateFrom(typeLoadEx.LoaderExceptions[i]);
                }
                loaderExceptions = a;
            }
            else
            {
                var fileNFEx = ex as System.IO.FileNotFoundException;
                if (fileNFEx != null)
                {
                    fileName     = fileNFEx.FileName;
                    detailedInfo = fileNFEx.FusionLog.NormalizeEOL();
                }
                else
                {
                    var loadFileEx = ex as System.IO.FileLoadException;
                    if (loadFileEx != null)
                    {
                        fileName     = loadFileEx.FileName;
                        detailedInfo = loadFileEx.FusionLog.NormalizeEOL();
                    }
                }
            }
            return(new CKExceptionData(ex.Message, exceptionTypeName, exceptionTypeAssemblyQualifiedName, ex.StackTrace, innerException, fileName, detailedInfo, loaderExceptions, aggregatedExceptions));
        }
Ejemplo n.º 24
0
 /// <summary>
 /// Creates a <see cref="CKException"/> from a <see cref="CKExceptionData"/>. This method returns null when data is null.
 /// This is the symmetric of <see cref="CKExceptionData.CreateFrom"/>.
 /// </summary>
 /// <param name="data">Data of an exception for which a <see cref="CKException"/> wrapper must be created. Can be null: null is returned.</param>
 /// <returns>The exception that wraps the data.</returns>
 static public CKException CreateFrom( CKExceptionData data )
 {
     if( data == null ) return null;
     return new CKException( data );
 }
Ejemplo n.º 25
0
 /// <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 );
 }
Ejemplo n.º 26
0
 static string DumpErrorText( DateTimeStamp logTime, string text, LogLevel level, CKTrait tags, CKExceptionData exData )
 {
     StringBuilder buffer = CreateHeader( logTime, text, level, tags );
     if( exData != null ) exData.ToStringBuilder( buffer, String.Empty );
     WriteFooter( level, buffer );
     return buffer.ToString();
 }