public void ProcessRequest(HttpContext context) { var input = JsonInput.FromRequestParams(context.Request.Params); var connId = context.Request.Params[HttpConstants.ConnectionId]; IConnection conn; if (string.IsNullOrEmpty(connId)) conn = ConnectionManager.Create(HttpConnection.Factory); else conn = ConnectionManager.Find(connId); if (conn == null) { var formatter = new JsonMessageFormatter(); context.Response.Write(formatter.FormatMessage(new ResponseMessage(input).Invalidate(CommonResources.LoginRequired))); context.Response.End(); return; } if (conn is HttpConnection) { (conn as HttpConnection).ProcessInput(input, context.Response); } else { // Process input for an IConnection instance. conn.EnqueueInput(input); } context.Response.End(); }
public void TestFormatterSerialization() { JsonMessageFormatter<TestModel> writeFormatter = new JsonMessageFormatter<TestModel>(Encoding.UTF8); TestModel writeObject = new TestModel() { ID = Guid.NewGuid().ToString(), TimeCreated = DateTime.Now }; Message message = new Message(writeObject, writeFormatter); writeFormatter.Write(message,writeObject); JsonMessageFormatter<TestModel> readFormatter = new JsonMessageFormatter<TestModel>(Encoding.UTF8); TestModel readObject = readFormatter.Read(message) as TestModel; string dateFormat = "yyyy-MM-dd HH:mm:ss.fff"; Assert.IsTrue(readObject != null && writeObject.ID == readObject.ID && writeObject.TimeCreated.ToString(dateFormat) == readObject.TimeCreated.ToString(dateFormat)); }
internal static JsonMessageFormatter ConfigureFormatter(JsonMessageFormatter formatter) { formatter.JsonSerializer.Converters.Add(AggregateJsonConverter.Instance); return(formatter); }
public void ProtocolVersion_Default() { var formatter = new JsonMessageFormatter(); Assert.Equal(new Version(2, 0), formatter.ProtocolVersion); }
public void DefaultEncodingLacksPreamble() { var formatter = new JsonMessageFormatter(); Assert.Empty(formatter.Encoding.GetPreamble()); }
public async Task InitializeAsync() { Tuple <Nerdbank.FullDuplexStream, Nerdbank.FullDuplexStream> streams = Nerdbank.FullDuplexStream.CreateStreams(); TraceSource mxServerTraceSource = new TraceSource("MX Server", SourceLevels.Information); TraceSource mxClientTraceSource = new TraceSource("MX Client", SourceLevels.Information); mxServerTraceSource.Listeners.Add(new XunitTraceListener(this.Logger)); mxClientTraceSource.Listeners.Add(new XunitTraceListener(this.Logger)); MultiplexingStream[] mxStreams = await Task.WhenAll( MultiplexingStream.CreateAsync( streams.Item1, new MultiplexingStream.Options { TraceSource = mxServerTraceSource, DefaultChannelTraceSourceFactory = (id, name) => new TraceSource("MX Server channel " + id, SourceLevels.Verbose) { Listeners = { new XunitTraceListener(this.Logger) } }, }, this.TimeoutToken), MultiplexingStream.CreateAsync( streams.Item2, new MultiplexingStream.Options { TraceSource = mxClientTraceSource, DefaultChannelTraceSourceFactory = (id, name) => new TraceSource("MX Client channel " + id, SourceLevels.Verbose) { Listeners = { new XunitTraceListener(this.Logger) } }, }, this.TimeoutToken)); this.serverMx = mxStreams[0]; this.clientMx = mxStreams[1]; MultiplexingStream.Channel[] rpcStreams = await Task.WhenAll( this.serverMx.AcceptChannelAsync(string.Empty, this.TimeoutToken), this.clientMx.OfferChannelAsync(string.Empty, this.TimeoutToken)); MultiplexingStream.Channel rpcServerStream = rpcStreams[0]; MultiplexingStream.Channel rpcClientStream = rpcStreams[1]; var serverFormatter = new JsonMessageFormatter { MultiplexingStream = this.serverMx }; var clientFormatter = new JsonMessageFormatter { MultiplexingStream = this.clientMx }; var serverHandler = new HeaderDelimitedMessageHandler(rpcServerStream, serverFormatter); var clientHandler = new HeaderDelimitedMessageHandler(rpcClientStream, clientFormatter); this.serverRpc = new JsonRpc(serverHandler, this.server); this.clientRpc = new JsonRpc(clientHandler); this.serverRpc.TraceSource = new TraceSource("Server", SourceLevels.Information); this.clientRpc.TraceSource = new TraceSource("Client", SourceLevels.Information); this.serverRpc.TraceSource.Listeners.Add(new XunitTraceListener(this.Logger)); this.clientRpc.TraceSource.Listeners.Add(new XunitTraceListener(this.Logger)); this.serverRpc.StartListening(); this.clientRpc.StartListening(); }
private static readonly LogWriter sLog_TagBC = sLog7.WithTags("TagB", "TagC"); // same as sLog7, but tags messages with 'TagB' and 'TagC' private static void Main(string[] args) { // Initialize the logging subsystem bool initConfig = false; Log.Initialize <VolatileLogConfiguration>( // volatile configuration (programmatic configuration only, no persistence) // Log.Initialize<FileBackedLogConfiguration>( // file-based configuration (default location, beside the executable with file extension '.gplogconf') config => { // VolatileLogConfiguration only: // Always initialize the configuration programmatically initConfig = false; // for VolatileLogConfiguration // FileBackedLogConfiguration only: // Initialize the configuration only, if the configuration file does not exist, yet // config.Path = "./my-conf.gplogconf"; // override the default location of the file // initConfig = !File.Exists(config.FullPath); if (initConfig) { // Add configuration for log writers that attach 'TagA' // - set base log level to 'None' effectively silencing the log writer // - include log level 'Notice' // - no excluded log levels // - tags must contain 'TagA' // => enabled log levels: 'Notice' config.AddLogWritersByWildcard( "*", x => x .WithTag("TagA") .WithBaseLevel(LogLevel.None) .WithLevel(LogLevel.Notice)); // Add configuration for log writers that attach 'TagB' and/or 'TagC' // - set base log level to 'None' effectively silencing the log writer // - include log level 'Warning' // - no excluded log levels // - tags must contain 'TagB' and/or 'TagC' // => enabled log levels: 'Warning' config.AddLogWritersByWildcard( "*", x => x .WithTagRegex("^Tag[BC]$") .WithBaseLevel(LogLevel.None) .WithLevel(LogLevel.Warning)); // Add configuration for log writer 'GriffinPlus.Lib.Logging.Demo.MyClass1' only // - set base log level to 'Notice' => enables log level 'Emergency', 'Alert', 'Critical', 'Error', 'Warning' and 'Notice' // - include log level 'Trace' // - exclude log level 'Warning' // - tags are not evaluated // => enabled log levels: 'Emergency', 'Alert', 'Critical', 'Error', 'Notice', 'Trace' config.AddLogWriter <MyClass1>( x => x .WithBaseLevel(LogLevel.Notice) .WithLevel(LogLevel.Trace) .WithoutLevel("Warning")); // Add configuration for log writer 'GriffinPlus.Lib.Logging.Demo.MyClass2' only // - set base log level to 'None' effectively silencing the log writer // - no included/excluded log levels // - tags are not evaluated // => no enabled log levels config.AddLogWriter( typeof(MyClass2), x => x.WithBaseLevel(LogLevel.None)); // Add configuration for log writer 'GriffinPlus.Lib.Logging.Demo.MyClass3' only // - set base log level to 'All' enabling all log levels (including aspects) // - exclude all log levels from 'Informational' up to 'Trace' ('Informational', 'Debug', 'Trace') // - tags are not evaluated // => enabled log levels: All log levels, but 'Informational', 'Debug', 'Trace' config.AddLogWriter( typeof(MyClass3), x => x .WithBaseLevel(LogLevel.All) .WithoutLevelRange(LogLevel.Informational, LogLevel.Debug)); // Add configuration for log writers matching regex pattern // - pattern matches 'GriffinPlus.Lib.Logging.Demo.MyClassA' and 'GriffinPlus.Lib.Logging.Demo.MyClassB' // - base level defaults to 'Error' => enables log level 'Emergency', 'Alert', 'Critical', 'Error' // - include all log levels from 'Informational' up to 'Trace' ('Informational', 'Debug', 'Trace') // - no excluded log levels // - tags are not evaluated // => enabled log levels: 'Emergency', 'Alert', 'Critical', 'Error', 'Informational', 'Debug' config.AddLogWritersByRegex( "^GriffinPlus.Lib.Logging.Demo.MyClass[A-Z]$", x => x.WithLevelRange(LogLevel.Informational, LogLevel.Debug)); // Add configuration for log writers matching wildcard pattern // - applies to 'GriffinPlus.Lib.Logging.Demo.MyClass4' only // (other writers are handled by preceding steps) // - base level defaults to 'Error' => enables log level 'Emergency', 'Alert', 'Critical', 'Error' // - include log level 'Trace' // - no excluded log levels // - tags are not evaluated // => enabled log levels: 'Emergency', 'Alert', 'Critical', 'Error', 'Trace' config.AddLogWritersByWildcard( "GriffinPlus.Lib.Logging.Demo.MyClass*", x => x.WithLevel(LogLevel.Trace)); // Add configuration for log writer 'My Fancy Writer' // (matches everything that was not handled explicitly before) // - set base log level to 'None' effectively silencing the log writer // - include aspect log level 'Demo Aspect' // - no excluded log levels // - tags are not evaluated // => enabled log levels: 'Demo Aspect' config.AddLogWriter( "My Fancy Writer", x => x .WithBaseLevel(LogLevel.None) .WithLevel("Demo Aspect")); // Add configuration for log writer 'Timing' to enable logging time measurements written by the internal // 'Timing' log writer (see below for time measurements) config.AddLogWriterTiming(); // Add default configuration for log writers that have not been handled up to this point // - base level defaults to level 'Notice' // - no included/excluded log levels // => enabled log levels: 'Emergency', 'Alert', 'Critical', 'Error', 'Warning', 'Notice' config.AddLogWriterDefault(); } }, builder => { // Create log message formatter that prints log messages in a tabular fashion var tableFormatter = new TableMessageFormatter(); tableFormatter.AddTimestampColumn("yyyy-MM-dd HH:mm:ss.fff"); // use custom timestamp format tableFormatter.AddProcessIdColumn(); tableFormatter.AddProcessNameColumn(); tableFormatter.AddApplicationNameColumn(); tableFormatter.AddLogWriterColumn(); tableFormatter.AddLogLevelColumn(); tableFormatter.AddTagsColumn(); tableFormatter.AddTextColumn(); // Create log message formatter that prints log messages as JSON var jsonFormatter = new JsonMessageFormatter(); jsonFormatter.Style = JsonMessageFormatterStyle.Beautified; jsonFormatter.AddTimestampField("yyyy-MM-dd HH:mm:ss.fff"); // use custom timestamp format jsonFormatter.AddProcessIdField(); jsonFormatter.AddProcessNameField(); jsonFormatter.AddApplicationNameField(); jsonFormatter.AddLogWriterField(); jsonFormatter.AddLogLevelField(); jsonFormatter.AddTagsField(); jsonFormatter.AddTextField(); // Create pipeline stage for printing to the console builder.Add <ConsoleWriterPipelineStage>( "Console", stage => { stage.MessageQueueSize = 500; // buffer up to 500 messages (default) stage.DiscardMessagesIfQueueFull = false; // block if the queue is full (default) stage.ShutdownTimeout = TimeSpan.FromMilliseconds(5000); // wait up to 5000ms for the stage to shut down (default) stage.Formatter = tableFormatter; // use specific formatter stage.DefaultStream = ConsoleOutputStream.Stdout; // print to stdout by default (default) stage.MapLogLevelToStream(LogLevel.Emergency, ConsoleOutputStream.Stderr); // print errors to stderr stage.MapLogLevelToStream(LogLevel.Alert, ConsoleOutputStream.Stderr); // stage.MapLogLevelToStream(LogLevel.Critical, ConsoleOutputStream.Stderr); // stage.MapLogLevelToStream(LogLevel.Error, ConsoleOutputStream.Stderr); // }); // Create pipeline stage for writing to a file builder.Add <FileWriterPipelineStage>( "File", stage => { stage.Path = "Unnamed.log"; // Path of the file to write to (default) stage.Append = false; // do not append written messages to existing log file (default) stage.MessageQueueSize = 500; // buffer up to 500 messages (default) stage.DiscardMessagesIfQueueFull = false; // block if the queue is full (default) stage.ShutdownTimeout = TimeSpan.FromMilliseconds(5000); // wait up to 5000ms for the stage to shut down (default) stage.Formatter = jsonFormatter; // use specific formatter }); // Create pipeline stage that forwards to Elasticsearch using the Elasticsearch Common Schema (ECS) version 1.10. // The stage supports the following password-based authentication schemes: // - Basic authentication (with custom credentials only) // - Digest authentication (with custom credentials only) // - NTLM Authentication (with custom credentials and login user credentials) // - Kerberos Authentication (with custom credentials and login user credentials) // - Negotiate Authentication (with custom credentials and login user credentials) builder.Add <ElasticsearchPipelineStage>( "Elasticsearch", stage => { stage.ApiBaseUrls = new[] { new Uri("http://127.0.0.1:9200/") }; // use local elasticsearch server stage.AuthenticationSchemes = AuthenticationScheme.PasswordBased; // support all password based authentication schemes stage.Username = ""; // username to use when authenticating (empty to use login user) stage.Password = ""; // password to use when authenticating (empty to use login user) stage.Domain = ""; // domain to use when authenticating (for schemes 'Digest', 'NTLM', 'Kerberos' and 'Negotiate') stage.BulkRequestMaxConcurrencyLevel = 5; // maximum number of requests on the line stage.BulkRequestMaxSize = 5 * 1024 * 1024; // maximum size of a bulk request stage.BulkRequestMaxMessageCount = 0; // maximum number of messages in a bulk request (0 = unlimited) stage.IndexName = "logs"; // elasticsearch index to write log messages into stage.OrganizationId = ""; // value of the 'organization.id' field stage.OrganizationName = ""; // value of the 'organization.name' field stage.SendQueueSize = 50000; // maximum number of messages the stage buffers before discarding messages }); }); // Save configuration, if it was initialized programmatically (after initialization the configuration is bound to // the pipeline stages, so stages can persist their settings in the configuration) if (initConfig) { Log.Configuration.Save(true); } // ----------------------------------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------------------------------- // Use the logging subsystem // ----------------------------------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------------------------------- // Get an aspect log level. var aspect = LogLevel.GetAspect("Demo Aspect"); // Write messages to all known log levels (predefined log levels + aspects). foreach (var level in LogLevel.KnownLevels) { sLog1.Write(level, "This is sLog1 writing using level '{0}'.", level.Name); sLog2.Write(level, "This is sLog2 writing using level '{0}'.", level.Name); sLog3.Write(level, "This is sLog3 writing using level '{0}'.", level.Name); sLog4.Write(level, "This is sLog4 writing using level '{0}'.", level.Name); sLog5.Write(level, "This is sLog5 writing using level '{0}'.", level.Name); sLog6.Write(level, "This is sLog6 writing using level '{0}'.", level.Name); sLog7.Write(level, "This is sLog7 writing using level '{0}'.", level.Name); sLog_TagA.Write(level, "This is sLog_TagA writing using level '{0}'.", level.Name); sLog_TagB.Write(level, "This is sLog_TagB writing using level '{0}'.", level.Name); sLog_TagBC.Write(level, "This is sLog_TagBC writing using level '{0}'.", level.Name); } // Use a timing logger to determine how long an operation takes. It uses log level 'Timing' and log writer // 'Timing' by default, so you need to ensure that the configuration lets these messages pass). sLog1.Write(LogLevel.Notice, "Presenting a timing logger with default settings..."); using (TimingLogger.Measure()) { Thread.Sleep(500); } // Use a timing logger, customize the log writer/level it uses and associate an operation name with the // measurement that is printed to the log as well. sLog1.Write(LogLevel.Notice, "A timing logger with custom log level/writer and operation name..."); using (TimingLogger.Measure(sLog1, LogLevel.Notice, "Waiting for 500ms")) { Thread.Sleep(500); } // ----------------------------------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------------------------------- // Wait for the user to press a key to shut the logging subsystem down // ----------------------------------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------------------------------- Thread.Sleep(1000); Console.WriteLine(); Console.WriteLine("Press any key to shut the logging subsystem down..."); Console.ReadKey(); // ----------------------------------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------------------------------- // Shut the logging subsystem down // ----------------------------------------------------------------------------------------------------------------- // ----------------------------------------------------------------------------------------------------------------- // Shut the logging subsystem down Log.Shutdown(); }
private static void ReadMessageFromGivenQueueName(string queueName, int interval, MessageSource source, JsonMessageFormatter <NotificationMessage> formatter) { logger.Info($"Read Messages From Queue : {queueName}"); MessageQueue messageQueue = GetQueue(queueName); if (messageQueue != null && messageQueue.CanRead) { Message receivedMessage = messageQueue.Receive(new TimeSpan(0, 0, interval)); receivedMessage.Formatter = formatter; logger.Info($"Recieved Message from queue: {receivedMessage}"); MessageProcessor.ProcessMessage(receivedMessage, source); } }