LiveLogViewer replacement for .NET Core

[exaiwitmx]

The .NET framework version of Loupe contains the class Gibraltar.Agent.Windows.LiveLogViewer.
The .NET core version does not contain this class.

We use LiveLogViewer to provide a log viewer in our application, which is based on .NET framework, but we want to upgrade to .NET 8.0.

What are the options to provide a log viewer in the application after upgrading?

[kendallmiller]

Excellent question. We're working on a port of the WinForms functionality forward into the new architecture used by .NET Core. is your client application just WinForms?

[exaiwitmx]

Yes, WinForms only - no other UI frameworks.

[exaiwitmx]

@kendallmiller

1. Is there already a plan for when this feature will be available?

2. In the meantime, we could redistribute LoupeViewer and call it from our application (by means of Process.Start). However, it would be nice if we could skip the session selection screen. And instead, pass in some parameters which identify the session of the parent application which calls LoupeViewer.exe.

3. I've also found the following information:

If you want, you can even develop your own viewer from the classes exposed by Loupe.Core in this repository.

Are there any examples / instructions on how to do that?

[kendallmiller]

1. Yes, we're hoping to release it with 6.0 since we're sharing come code/effort with that. Hopefully in a month or so.
2. The main Loupe desktop client (Gibraltar.Monitor.Windows.exse) does support this to a degree - but unfortunately only for sessions stored in a server repository (that's how it works where you can select the open in desktop option from the web browser and switch - the install registers a URL handler which routes to the loupe viewer and in turn it parses the input to open the session from the server). Unfortunately this doesn't work with live view. Let me see if we can quickly add support like that to LoupeViewer.exe - it's off in the Gibratar.Agent repo.
3. It doesn't look like we've published an example for that. But, you can get there by subscribing to the newer message published event and caching the data for your display:

using System;
using System.Windows.Forms;
using Gibraltar.Agent;
using Gibraltar.Agent.Data;

namespace YourApplication
{
    public partial class LiveViewerForm : Form
    {
        private ListBox messageListBox;
        
        public LiveViewerForm()
        {
            InitializeComponent();
            
            // Subscribe to the MessagePublished event
            Log.MessagePublished += OnLogMessagePublished;
        }
        
        private void OnLogMessagePublished(object sender, LogMessageEventArgs e)
        {
            // The event may contain multiple messages in a batch
            foreach (ILogMessage message in e.Messages)
            {
                // Process each message
                DisplayMessage(message);
                
                // Example: Access message properties
                string severity = message.Severity.ToString();
                string category = message.CategoryName;
                string caption = message.Caption;
                string description = message.Description;
                DateTimeOffset timestamp = message.Timestamp;
                int threadId = message.ThreadId;
                string threadName = message.ThreadName;
                
                // Check for exceptions
                if (message.HasException && message.Exception != null)
                {
                    string exceptionType = message.Exception.TypeName;
                    string exceptionMessage = message.Exception.Message;
                }
                
                // Access source location information
                if (!string.IsNullOrEmpty(message.MethodName))
                {
                    string method = message.MethodName;
                    string className = message.ClassName;
                    string fileName = message.FileName;
                    int lineNumber = message.LineNumber;
                }
            }
            
            // You can also check summary information about the batch
            LogMessageSeverity topSeverity = e.TopSeverity;
            int totalCount = e.TotalCount;
            int errorCount = e.ErrorCount;
            int warningCount = e.WarningCount;
            int criticalCount = e.CriticalCount;
        }
        
        private void DisplayMessage(ILogMessage message)
        {
            // Update UI on the UI thread
            if (InvokeRequired)
            {
                Invoke(new Action<ILogMessage>(DisplayMessage), message);
                return;
            }
            
            // Format and display the message
            string displayText = $"[{message.Severity}] {message.Timestamp:HH:mm:ss.fff} " +
                                $"[{message.CategoryName}] {message.Caption}";
            
            messageListBox.Items.Add(displayText);
            
            // Auto-scroll to bottom
            messageListBox.TopIndex = messageListBox.Items.Count - 1;
        }
        
        protected override void OnFormClosing(FormClosingEventArgs e)
        {
            // Unsubscribe when form closes
            Log.MessagePublished -= OnLogMessagePublished;
            base.OnFormClosing(e);
        }
    }
}