public void OnWindowLogMessage(LogMessageParams param)
{
if (param_.logger.IsTraceEnabled)
{
param_.logger.Trace(String.Format("[OnWindowLogMessage]{0}", param.message));
}
}
public void LogMessage(LogMessageParams @params)
{
_connection.SendNotification(new NotificationMessage <LogMessageParams>
{
method = "window/logMessage",
@params = @params
});
}
public Task LogMessage(string message, MessageType messageType)
{
var parameters = new LogMessageParams {
type = messageType,
message = message
};
return(_rpc.NotifyWithParameterObjectAsync("window/logMessage", parameters));
}
internal void Log(LogLevel level, string message)
{
var logMessage = new LogMessageParams {
Level = level,
Message = message
};
rpc.InvokeAsync(Methods.LogName, logMessage).Wait();
}
public Task LogMessage(string message, MessageType messageType)
{
var parameters = new LogMessageParams {
type = messageType,
message = message
};
return(_rpc.InvokeAsync <MessageActionItem?>("window/logMessage", parameters));
}
/// <summary>
/// Emit a log event.
/// </summary>
/// <param name="logEvent">
/// The log event information.
/// </param>
public void Emit(LogEvent logEvent)
{
if (_hasServerShutDown)
{
return;
}
if (logEvent.Level < _levelSwitch.MinimumLevel)
{
return;
}
LogMessageParams logParameters = new LogMessageParams
{
Message = logEvent.RenderMessage()
};
if (logEvent.Exception != null)
{
logParameters.Message += "\n" + logEvent.Exception.ToString();
}
switch (logEvent.Level)
{
case LogEventLevel.Error:
case LogEventLevel.Fatal:
{
logParameters.Type = MessageType.Error;
break;
}
case LogEventLevel.Warning:
{
logParameters.Type = MessageType.Warning;
break;
}
case LogEventLevel.Information:
{
logParameters.Type = MessageType.Info;
break;
}
default:
{
logParameters.Type = MessageType.Log;
break;
}
}
_languageServer.LogMessage(logParameters);
}
public void LogMessage(object arg, string message, MessageType messageType)
{
LogMessageParams parameter = new LogMessageParams
{
Message = message,
MessageType = messageType
};
this.rpc.NotifyWithParameterObjectAsync(Methods.WindowLogMessageName, parameter);
}
public void LogMessage(string message, MessageType messageType)
{
LogMessageParams parameter = new LogMessageParams
{
Message = message,
MessageType = messageType
};
#pragma warning disable VSTHRD110
rpc.NotifyWithParameterObjectAsync(Methods.WindowLogMessageName, parameter);
#pragma warning restore VSTHRD110
}
private void SendLogMessage(string text)
{
var logMessageParams = new LogMessageParams()
{
Message = text,
// A log message
// TODO: Introduce an enum for this
Type = 4
};
_messageWriter.WriteNotification("window/logMessage", logMessageParams);
}
public Task LogMessageAsync(string message, MessageType messageType)
{
if (messageType > _logLevel)
{
return(Task.CompletedTask);
}
var parameters = new LogMessageParams {
type = messageType,
message = message
};
return(_rpc.NotifyWithParameterObjectAsync("window/logMessage", parameters));
}
public Task LogMessageAsync(string message, TraceEventType eventType)
{
if (eventType > LogLevel && eventType != TraceEventType.Information)
{
return(Task.CompletedTask);
}
var parameters = new LogMessageParams {
type = eventType.ToMessageType(),
message = message
};
return(_clientApp.NotifyWithParameterObjectAsync("window/logMessage", parameters));
}
public void SimpleTest(string expected)
{
var model = new LogMessageParams {
Message = "message",
Type = MessageType.Error
};
var result = Fixture.SerializeObject(model);
result.Should().Be(expected);
var deresult = new LspSerializer(ClientVersion.Lsp3).DeserializeObject <LogMessageParams>(expected);
deresult.Should().BeEquivalentTo(model);
}
public void SimpleTest(string expected)
{
var model = new LogMessageParams()
{
Message = "message",
Type = MessageType.Error
};
var result = Fixture.SerializeObject(model);
result.Should().Be(expected);
var deresult = JsonConvert.DeserializeObject <LogMessageParams>(expected);
deresult.ShouldBeEquivalentTo(model);
}
void LogMessage(LogMessageParams message)
{
string fullMessage = string.Format("LanguageServer[{0}]: {1}", session.Id, message.Message);
switch (message.MessageType)
{
case MessageType.Error:
LanguageClientOutputPad.WriteError(fullMessage);
break;
default:
LanguageClientOutputPad.WriteText(fullMessage);
break;
}
}
private void RequestExecutionQueue_Errored(object sender, RequestShutdownEventArgs e)
{
// log message and shut down
var message = new LogMessageParams()
{
MessageType = MessageType.Error,
Message = e.Message
};
var asyncToken = _listener.BeginAsyncOperation(nameof(RequestExecutionQueue_Errored));
Task.Run(async() =>
{
await _jsonRpc.NotifyWithParameterObjectAsync(Methods.WindowLogMessageName, message).ConfigureAwait(false);
// The "default" here is the cancellation token, which these methods don't use, hence the discard name
await ShutdownAsync(_: default).ConfigureAwait(false);
private void RequestExecutionQueue_Errored(object?sender, RequestShutdownEventArgs e)
{
// log message and shut down
Logger?.TraceWarning($"Request queue is requesting shutdown due to error: {e.Message}");
var message = new LogMessageParams()
{
MessageType = MessageType.Error,
Message = e.Message
};
var asyncToken = Listener.BeginAsyncOperation(nameof(RequestExecutionQueue_Errored));
_errorShutdownTask = Task.Run(async() =>
{
Logger?.TraceInformation("Shutting down language server.");
await JsonRpc.NotifyWithParameterObjectAsync(Methods.WindowLogMessageName, message).ConfigureAwait(false);
ShutdownImpl();
ExitImpl();
}).CompletesAsyncOperation(asyncToken);
}
public static void LogMessage(this IResponseRouter mediator, LogMessageParams @params)
{
mediator.SendNotification(WindowNames.LogMessage, @params);
}
public static void Log(this IResponseRouter mediator, LogMessageParams @params)
{
mediator.LogMessage(@params);
}
/// <summary>
/// Emit a log event.
/// </summary>
/// <param name="logEvent">
/// The log event information.
/// </param>
public void Emit(LogEvent logEvent)
{
if (!CanLog)
{
return;
}
if (logEvent.Level < _levelSwitch.MinimumLevel)
{
return;
}
StringBuilder messageBuilder = new StringBuilder();
using (StringWriter messageWriter = new StringWriter(messageBuilder))
{
logEvent.RenderMessage(messageWriter);
}
if (logEvent.Exception != null)
{
messageBuilder.AppendLine();
messageBuilder.Append(
logEvent.Exception.ToString()
);
}
LogMessageParams logParameters = new LogMessageParams
{
Message = messageBuilder.ToString()
};
switch (logEvent.Level)
{
case LogEventLevel.Error:
case LogEventLevel.Fatal:
{
logParameters.Type = MessageType.Error;
break;
}
case LogEventLevel.Warning:
{
logParameters.Type = MessageType.Warning;
break;
}
case LogEventLevel.Information:
{
logParameters.Type = MessageType.Info;
break;
}
default:
{
logParameters.Type = MessageType.Log;
break;
}
}
_languageServer.LogMessage(logParameters);
}
public static void Log(this ILanguageServer mediator, LogMessageParams @params)
{
mediator.LogMessage(@params);
}
public abstract Task <Unit> Handle(LogMessageParams request, CancellationToken cancellationToken);
public override Task <Unit> Handle(LogMessageParams request, CancellationToken cancellationToken) => _handler.Invoke(request, cancellationToken);
public static void LogMessage(this ILanguageServerWindow mediator, LogMessageParams @params)
{
mediator.SendNotification(WindowNames.LogMessage, @params);
}
public static void LogMessage(this ILanguageServer mediator, LogMessageParams @params)
{
mediator.SendNotification("window/logMessage", @params);
}
public static void Log(this IWindowLanguageServer mediator, LogMessageParams @params) => mediator.LogMessage(@params);
