public void OnUnfilteredLog(ActivityMonitorLogData data)
 {
     if (data.MaskedLevel == LogLevel.Trace)
     {
         Interlocked.Increment(ref Count);
     }
 }
 /// <summary>
 /// Writes a line entry as a uni-cast compact entry or as a multi-cast one if needed.
 /// </summary>
 /// <param name="data">The log line.</param>
 /// <param name="adapter">Multi-cast information to be able to write multi-cast entry when needed.</param>
 public void UnicastWrite(ActivityMonitorLogData data, IMulticastLogInfo adapter)
 {
     BeforeWriteEntry();
     Debug.Assert(_writer != null);
     LogEntry.WriteLog(_writer, adapter.GrandOutputId, adapter.MonitorId, adapter.PreviousEntryType, adapter.PreviousLogTime, adapter.GroupDepth, false, data.Level, data.LogTime, data.Text, data.Tags, data.ExceptionData, data.FileName, data.LineNumber);
     AfterWriteEntry();
 }
Beispiel #3
0
 protected override void OnUnfilteredLog(ActivityMonitorLogData data)
 {
     if (TestHelper.LogsToConsole)
     {
         Console.WriteLine("NotBuggyActivityMonitorClient.OnUnfilteredLog n°{0}: {1}", _number, data.Text);
     }
 }
Beispiel #4
0
        void IActivityMonitorClient.OnUnfilteredLog(ActivityMonitorLogData data)
        {
            var level = data.Level & LogLevel.Mask;

            if (data.Text == ActivityMonitor.ParkLevel)
            {
                if (_curLevel != -1)
                {
                    OnLeaveLevel((LogLevel)_curLevel);
                }
                _curLevel = -1;
            }
            else
            {
                if (_curLevel == (int)level)
                {
                    OnContinueOnSameLevel(data);
                }
                else
                {
                    if (_curLevel != -1)
                    {
                        OnLeaveLevel((LogLevel)_curLevel);
                    }
                    OnEnterLevel(data);
                    _curLevel = (int)level;
                }
            }
        }
        void Run()
        {
            try
            {
                int streamVersion = _reader.ReadInt32();
                if (_interProcess)
                {
                    _server.DisposeLocalCopyOfClientHandle();
                }
                for (; ;)
                {
                    var e = LogEntry.Read(_reader, streamVersion, out bool badEndOfStream);
                    if (e == null || badEndOfStream)
                    {
                        _endFlag = badEndOfStream ? LogReceiverEndStatus.MissingEndMarker : LogReceiverEndStatus.Normal;
                        break;
                    }
                    switch (e.LogType)
                    {
                    case LogEntryType.Line:
                    {
                        if (_monitor.ShouldLogLine(e.LogLevel, e.Tags, out var finalTags))
                        {
                            var d = new ActivityMonitorLogData(e.LogLevel | LogLevel.IsFiltered, finalTags, e.Text, CKException.CreateFrom(e.Exception), e.FileName, e.LineNumber);
                            d.SetExplicitLogTime(e.LogTime);
                            _monitor.UnfilteredLog(ref d);
                        }
                        break;
                    }

                    case LogEntryType.OpenGroup:
                    {
                        ActivityMonitorLogData d;
                        if (_monitor.ShouldLogLine(e.LogLevel, e.Tags, out var finalTags))
                        {
                            d = new ActivityMonitorLogData(e.LogLevel | LogLevel.IsFiltered, finalTags, e.Text, CKException.CreateFrom(e.Exception), e.FileName, e.LineNumber);
                            d.SetExplicitLogTime(e.LogTime);
                        }
                        else
                        {
                            d = default;
                        }
                        _monitor.UnfilteredOpenGroup(ref d);
                    }

                    break;

                    case LogEntryType.CloseGroup:
                        _monitor.CloseGroup(e.Conclusions, e.LogTime);
                        break;
                    }
                }
            }
            catch (Exception ex)
            {
                _endFlag = LogReceiverEndStatus.Error;
                _monitor.UnfilteredLog(LogLevel.Fatal, null, "While receiving pipe logs.", ex);
            }
        }
 public void OnUnfilteredLog(ActivityMonitorLogData data)
 {
     if (data.LogTime <= _lastOne)
     {
         ++NbClash;
     }
     _lastOne = data.LogTime;
 }
Beispiel #7
0
 public Entry(ActivityMonitorLogData d)
 {
     Level     = d.Level;
     Tags      = d.Tags;
     Text      = d.Text;
     Exception = d.Exception;
     LogTime   = d.LogTime;
 }
 void IActivityMonitorClient.OnUnfilteredLog(ref ActivityMonitorLogData data)
 {
     if (_file != null)
     {
         _file.UnicastWrite(data, this);
         _prevlogTime = data.LogTime;
         _prevLogType = LogEntryType.Line;
     }
 }
        void IActivityMonitorClient.OnUnfilteredLog(ActivityMonitorLogData data)
        {
            var h = EnsureChannel();

            if (h != null)
            {
                IMulticastLogEntry e = LogEntry.CreateMulticastLog(_monitorSource.UniqueId, _prevLogType, _prevlogTime, _currentGroupDepth, data.Text, data.LogTime, data.Level, data.FileName, data.LineNumber, data.Tags, data.EnsureExceptionData());
                h.Handle(new GrandOutputEventInfo(e, _monitorSource.Topic));
                _prevlogTime = data.LogTime;
                _prevLogType = LogEntryType.Line;
            }
        }
 protected override void OnUnfilteredLog( ActivityMonitorLogData data )
 {
     lock( _locker )
     {
         lock( _outLocker )
         {
             _outDone = true;
             Monitor.PulseAll( _outLocker );
         }
         while( !_done )
             Monitor.Wait( _locker );
     }
 }
Beispiel #11
0
 void OnContinueOnSameLevel(ActivityMonitorLogData data)
 {
     Entries.Add(new Entry(data));
     Writer.Write(data.Text);
     if (WriteTags)
     {
         Writer.Write("-[{0}]", data.Tags.ToString());
     }
     if (data.Exception != null)
     {
         Writer.Write("Exception: " + data.Exception.Message);
     }
 }
        void IActivityMonitorClient.OnUnfilteredLog(ref ActivityMonitorLogData data)
        {
            if (_central.IsDisposed)
            {
                return;
            }
            Debug.Assert(_monitorSource != null, "Since we are called by the monitor...");
            IMulticastLogEntry e = LogEntry.CreateMulticastLog(_central.GrandOutpuId, _monitorSource.UniqueId, _prevLogType, _prevlogTime, _currentGroupDepth, data.Text, data.LogTime, data.Level, data.FileName, data.LineNumber, data.Tags, data.ExceptionData);

            _central.Sink.Handle(e);
            _prevlogTime = data.LogTime;
            _prevLogType = LogEntryType.Line;
        }
Beispiel #13
0
 void OnEnterLevel(ActivityMonitorLogData data)
 {
     Entries.Add(new Entry(data));
     Writer.WriteLine();
     Writer.Write(data.MaskedLevel.ToString() + ": " + data.Text);
     if (WriteTags)
     {
         Writer.Write("-[{0}]", data.Tags.ToString());
     }
     if (data.Exception != null)
     {
         Writer.Write("Exception: " + data.Exception.Message);
     }
 }
Beispiel #14
0
 protected override void OnUnfilteredLog(ActivityMonitorLogData data)
 {
     lock ( _locker )
     {
         lock ( _outLocker )
         {
             _outDone = true;
             Monitor.PulseAll(_outLocker);
         }
         while (!_done)
         {
             Monitor.Wait(_locker);
         }
     }
 }
Beispiel #15
0
            /// <summary>
            /// Replays this monitor's content into another monitor.
            /// </summary>
            /// <param name="replay">The target monitor. Can not be null.</param>
            /// <param name="monitor">Optional monitor (nothing is logged when null).</param>
            public void Replay(IActivityMonitor replay, IActivityMonitor?monitor = null)
            {
                using (monitor?.OpenInfo($"Replaying activity from '{MonitorId}'."))
                {
                    int nbMissing = 0;
                    int nbTotal   = 0;
                    using (var page = ReadFirstPage(1024))
                    {
                        foreach (ParentedLogEntry e in page.Entries)
                        {
                            ++nbTotal;
                            LogLevel level = e.Entry.LogLevel;
                            if (e.IsMissing)
                            {
                                ++nbMissing;
                                level = LogLevel.Trace;
                            }
                            switch (e.Entry.LogType)
                            {
                            case LogEntryType.Line:
                                var d = new ActivityMonitorLogData(level, e.Entry.Tags, e.Entry.Text, CKException.CreateFrom(e.Entry.Exception), e.Entry.FileName, e.Entry.LineNumber);
                                d.SetExplicitLogTime(e.Entry.LogTime);
                                replay.UnfilteredLog(ref d);
                                break;

                            case LogEntryType.OpenGroup:
                                d = new ActivityMonitorLogData(level, e.Entry.Tags, e.Entry.Text, CKException.CreateFrom(e.Entry.Exception), e.Entry.FileName, e.Entry.LineNumber);
                                d.SetExplicitLogTime(e.Entry.LogTime);
                                replay.UnfilteredOpenGroup(ref d);
                                break;

                            case LogEntryType.CloseGroup:
                                replay.CloseGroup(e.Entry.Conclusions, e.Entry.LogTime);
                                break;
                            }
                        }
                        page.ForwardPage();
                    }
                    monitor?.CloseGroup($"Replayed {nbTotal} entries ({nbMissing} missing).");
                }
            }
 public void OnUnfilteredLog( ActivityMonitorLogData data )
 {
     if( data.LogTime <= _lastOne ) ++NbClash;
     _lastOne = data.LogTime;
 }
Beispiel #17
0
 void IActivityMonitorClient.OnUnfilteredLog(ActivityMonitorLogData data)
 {
     Assert.That(data.FileName, Is.Not.Null.And.Not.Empty);
     Util.InterlockedAdd(ref _text, String.Format("{0} {1} - {2} -[{3}]", new String('>', _depth), data.Level, data.Text, data.Tags));
 }
 public void OnUnfilteredLog(ActivityMonitorLogData data)
 {
     lock (_buffer) _buffer.Append(_prefix).AppendFormat("[{0}]{1}", data.Level, data.Text).AppendLine();
 }
 public void OnUnfilteredLog(ActivityMonitorLogData data)
 {
     MayFail();
 }
 void IActivityMonitorClient.OnUnfilteredLog(ref ActivityMonitorLogData data)
 {
     LogEntry.WriteLog(_writer, false, data.Level, data.LogTime, data.Text, data.Tags, data.ExceptionData, data.FileName, data.LineNumber);
 }
 protected override void OnUnfilteredLog( ActivityMonitorLogData data )
 {
     if( TestHelper.LogsToConsole ) Console.WriteLine( "NotBuggyActivityMonitorClient.OnUnfilteredLog n°{0}: {1}", _number, data.Text );
 }
 protected override void OnUnfilteredLog( ActivityMonitorLogData data )
 {
     _action();
 }
 protected override void OnUnfilteredLog( ActivityMonitorLogData data )
 {
     _monitor.Info().Send( "I'm buggy: I'm logging back in my monitor!" );
     base.OnUnfilteredLog( data );
 }
 void IActivityMonitorClient.OnUnfilteredLog( ActivityMonitorLogData data )
 {
     Assert.That( data.FileName, Is.Not.Null.And.Not.Empty );
     Util.InterlockedAdd( ref _text, String.Format( "{0} {1} - {2} -[{3}]", new String( '>', _depth ), data.Level, data.Text, data.Tags ) ); 
 }
Beispiel #25
0
 protected override void OnContinueOnSameLevel(ActivityMonitorLogData data)
 {
     XmlWriter.WriteString(data.Text);
 }
Beispiel #26
0
 protected override void OnUnfilteredLog(ActivityMonitorLogData data)
 {
     _monitor.Info().Send("I'm buggy: I'm logging back in my monitor!");
     base.OnUnfilteredLog(data);
 }
Beispiel #27
0
 protected override void OnEnterLevel(ActivityMonitorLogData data)
 {
     XmlWriter.WriteStartElement(data.MaskedLevel.ToString());
     XmlWriter.WriteString(data.Text);
 }
 protected override void OnUnfilteredLog( ActivityMonitorLogData data )
 {
     Assert.That( data.IsFilteredLog );
 }
Beispiel #29
0
 protected override void OnUnfilteredLog(ActivityMonitorLogData data)
 {
     _action();
 }