private static void OutputSingleQuery(PipeWriter pipeWriter, World row) { var writer = GetWriter(pipeWriter, sizeHint: 180); // in reality it's 150 writer.Write(_dbPreamble); var lengthWriter = writer; writer.Write(_contentLengthGap); // Date header writer.Write(DateHeader.HeaderBytes); writer.Commit(); Utf8JsonWriter utf8JsonWriter = t_writer ??= new Utf8JsonWriter(pipeWriter, new JsonWriterOptions { SkipValidation = true }); utf8JsonWriter.Reset(pipeWriter); // Body JsonSerializer.Serialize <World>(utf8JsonWriter, row, SerializerOptions); // Content-Length lengthWriter.WriteNumeric((uint)utf8JsonWriter.BytesCommitted); }
[Benchmark(Description = "ArrayPool")] public void SerializeWithArrayPool() { JsonWriterOptions options = new JsonWriterOptions() { Indented = false, Encoder = JavaScriptEncoder.Create(UnicodeRanges.All) }; byte[] buffer = ArrayPool <byte> .Shared.Rent(10240); using (MemoryStream stream = new MemoryStream(buffer)) { using (Utf8JsonWriter writer = new Utf8JsonWriter(stream, options)) { for (int i = 0; i < TestSize; i++) { Serialize2(writer); ReadOnlySpan <byte> span = new ReadOnlySpan <byte>(buffer, 0, (int)writer.BytesCommitted); writer.Reset(); stream.Position = 0; } } } ArrayPool <byte> .Shared.Return(buffer); }
private static void GenericConverterTestHelper <T>(string converterName, object objectValue, string stringValue, JsonSerializerOptions options, bool nullOptionOkay = true) { JsonConverter <T> converter = (JsonConverter <T>)options.GetConverter(typeof(T)); Assert.True(converter.CanConvert(typeof(T))); Assert.Equal(converterName, converter.GetType().Name); ReadOnlySpan <byte> data = Encoding.UTF8.GetBytes(stringValue); Utf8JsonReader reader = new Utf8JsonReader(data); reader.Read(); T valueRead = converter.Read(ref reader, typeof(T), nullOptionOkay ? null: options); Assert.Equal(objectValue, valueRead); if (reader.TokenType != JsonTokenType.EndObject) { valueRead = converter.Read(ref reader, typeof(T), options); // Test with given option if reader position haven't advanced. Assert.Equal(objectValue, valueRead); } using (var stream = new MemoryStream()) using (var writer = new Utf8JsonWriter(stream)) { converter.Write(writer, (T)objectValue, options); writer.Flush(); Assert.Equal(stringValue, Encoding.UTF8.GetString(stream.ToArray())); writer.Reset(stream); converter.Write(writer, (T)objectValue, nullOptionOkay ? null : options); writer.Flush(); Assert.Equal(stringValue + stringValue, Encoding.UTF8.GetString(stream.ToArray())); } }
/// <summary> /// Serializes an indexing operation in a bulk request /// </summary> /// <param name="message">Message to serialize.</param> private void SerializeIndexingRequest(LocalLogMessage message) { // serialize bulk request item object for indexing mRequestContentWriter.Reset(); mStage.WriteBulkRequestIndexAction_ECS110(mRequestContentWriter); // finalize line with a newline character mContentStream.WriteByte((byte)'\n'); // serialize the actual log message mRequestContentWriter.Reset(); mStage.WriteJsonMessage_ECS110(mRequestContentWriter, message); // finalize line with a newline character mContentStream.WriteByte((byte)'\n'); }
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context) { if (writer == null) { writer = new Utf8JsonWriter(stream); } else { writer.Reset(stream); } writer.WriteStartArray(); foreach (var span in this.spans) { var zipkinSpan = span.ToZipkinSpan(this.exporter.LocalEndpoint, this.exporter.options.UseShortTraceIds); zipkinSpan.Write(writer); zipkinSpan.Return(); } writer.WriteEndArray(); return(writer.FlushAsync()); }
private static void OutputUpdates(PipeWriter pipeWriter, World[] rows) { var writer = GetWriter(pipeWriter, sizeHint: 120 * rows.Length); // in reality it's 112 for one writer.Write(_dbPreamble); var lengthWriter = writer; writer.Write(_contentLengthGap); // Date header writer.Write(DateHeader.HeaderBytes); writer.Commit(); Utf8JsonWriter utf8JsonWriter = t_writer ??= new Utf8JsonWriter(pipeWriter, new JsonWriterOptions { SkipValidation = true }); utf8JsonWriter.Reset(pipeWriter); // Body JsonSerializer.Serialize(utf8JsonWriter, rows, SerializerContext.WorldArray); // Content-Length lengthWriter.WriteNumeric((uint)utf8JsonWriter.BytesCommitted); }
private static void OutputMultipleQueries <TWorld>(PipeWriter pipeWriter, TWorld[] rows, JsonTypeInfo <TWorld[]> jsonTypeInfo) { var writer = GetWriter(pipeWriter, sizeHint: 160 * rows.Length); // in reality it's 152 for one writer.Write(_dbPreamble); var lengthWriter = writer; writer.Write(_contentLengthGap); // Date header writer.Write(DateHeader.HeaderBytes); writer.Commit(); Utf8JsonWriter utf8JsonWriter = t_writer ??= new Utf8JsonWriter(pipeWriter, new JsonWriterOptions { SkipValidation = true }); utf8JsonWriter.Reset(pipeWriter); // Body JsonSerializer.Serialize <TWorld[]>(utf8JsonWriter, rows, jsonTypeInfo); // Content-Length lengthWriter.WriteNumeric((uint)utf8JsonWriter.BytesCommitted); }
public long SystemTextJson() { SystemTextJsonOutput.Position = 0; System.Text.Json.JsonSerializer.Serialize <IntClass>(SystemTextJsonWriter, Input); SystemTextJsonWriter.Reset(); return(SystemTextJsonOutput.Length); }
public void EndJsonObjectLine() { _jsonWriter.WriteEndObject(); _jsonWriter.Flush(); _stream.WriteByte((byte)'\n'); _stream.Flush(); _jsonWriter.Reset(); }
private void Init() { _utf8jsonMemory.Seek(0, SeekOrigin.Begin); _writer.Reset(); _writer.WriteStartObject(); _writer.WriteStartArray("funcs"); }
public void Utf8JsonWriterPooledWriter() { _writerWBufferWriter.WriteStartObject(); _writerWBufferWriter.WriteString("message", _result.message); _writerWBufferWriter.WriteEndObject(); _writerBufferWriter.Clear(); _writerWBufferWriter.Reset(); }
public void Utf8JsonWriterMemoryStreamWriter() { _writerWMemoryStream.WriteStartObject(); _writerWMemoryStream.WriteString("message", _result.message); _writerWMemoryStream.WriteEndObject(); _writerMemoryStream.Position = 0; _writerWMemoryStream.Reset(); }
public void ParseThenWrite() { _writer.Reset(); using (JsonDocument document = JsonDocument.Parse(_dataUtf8)) { document.WriteTo(_writer); } }
public T Clone <T>(T item) { _bufferWriter.Clear(); _jsonWriter.Reset(); JsonSerializer.Serialize(_jsonWriter, item, _options); return(JsonSerializer.Deserialize <T>(_bufferWriter.WrittenSpan, _options)); }
public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func <TState, Exception, string> formatter) { lock (_jsonWriter) { _jsonWriter.WriteStartObject(); if (!string.IsNullOrWhiteSpace(_options.TimestampFieldName)) { _jsonWriter.WriteString(_options.TimestampFieldName, DateTime.UtcNow); } if (!string.IsNullOrWhiteSpace(_options.MessageFieldName)) { _jsonWriter.WriteString(_options.MessageFieldName, formatter(state, exception)); } if (!string.IsNullOrWhiteSpace(_options.LevelFieldName)) { _jsonWriter.WriteString(_options.LevelFieldName, GetLogLevelString(logLevel)); } if (!string.IsNullOrWhiteSpace(_options.CategoryFieldName)) { _jsonWriter.WriteString(_options.CategoryFieldName, _categoryName); } if (!string.IsNullOrWhiteSpace(_options.EventIdFieldName)) { // This could really be just eventId.ToString() but this is to save on allocation if (eventId.Name != default) { _jsonWriter.WriteString(_options.EventIdFieldName, eventId.Name); } else if (eventId.Id != default) { _jsonWriter.WriteNumber(_options.EventIdFieldName, eventId.Id); } } if (!string.IsNullOrWhiteSpace(_options.ExceptionFieldName) && exception != default) { _jsonWriter.WriteString(_options.ExceptionFieldName, exception.ToString()); } WriteFormattedLogValues(state, _jsonWriter); _scopeProvider?.ForEachScope(WriteFormattedLogValues, _jsonWriter); _jsonWriter.WriteEndObject(); _jsonWriter.Flush(); _jsonWriter.Reset(); _options.Stream.Write(NewLine, 0, NewLine.Length); } }
public static void RenderOne <T>(IHeaderDictionary headerDictionary, PipeWriter pipeWriter, T t, IJsonSerializer <T> jsonSerializer) { headerDictionary.Add(_headerServer); headerDictionary.Add(_headerContentType); Utf8JsonWriter utf8JsonWriter = _utf8JsonWriter ??= new Utf8JsonWriter(pipeWriter, new JsonWriterOptions { SkipValidation = true }); utf8JsonWriter.Reset(pipeWriter); jsonSerializer.Serialize(utf8JsonWriter, t); utf8JsonWriter.Flush(); headerDictionary.Add(new KeyValuePair <string, StringValues>("Content-Length", utf8JsonWriter.BytesCommitted.ToString())); }
private static void GenericObjectOrJsonElementConverterTestHelper <T>(string converterName, object objectValue, string stringValue, bool throws) { var options = new JsonSerializerOptions(); JsonConverter <T> converter = (JsonConverter <T>)options.GetConverter(typeof(T)); Assert.Equal(converterName, converter.GetType().Name); ReadOnlySpan <byte> data = Encoding.UTF8.GetBytes(stringValue); Utf8JsonReader reader = new Utf8JsonReader(data); reader.Read(); T readValue = converter.Read(ref reader, typeof(T), null); if (readValue is JsonElement element) { Assert.Equal(JsonValueKind.Array, element.ValueKind); JsonElement.ArrayEnumerator iterator = element.EnumerateArray(); Assert.True(iterator.MoveNext()); Assert.Equal(3, iterator.Current.GetInt32()); } else { Assert.True(false, "Must be JsonElement"); } using (var stream = new MemoryStream()) using (var writer = new Utf8JsonWriter(stream)) { if (throws) { Assert.Throws <InvalidOperationException>(() => converter.Write(writer, (T)objectValue, options)); Assert.Throws <InvalidOperationException>(() => converter.Write(writer, (T)objectValue, null)); } else { converter.Write(writer, (T)objectValue, options); writer.Flush(); Assert.Equal(stringValue, Encoding.UTF8.GetString(stream.ToArray())); writer.Reset(stream); converter.Write(writer, (T)objectValue, null); // Test with null option writer.Flush(); Assert.Equal(stringValue + stringValue, Encoding.UTF8.GetString(stream.ToArray())); } } }
private static void Json(ref BufferWriter <WriterAdapter> writer) { writer.Write(_jsonPreamble); // Date header writer.Write(DateHeader.HeaderBytes); writer.Commit(); Utf8JsonWriter utf8JsonWriter = t_writer ??= new Utf8JsonWriter(writer.Output); utf8JsonWriter.Reset(writer.Output); // Body JsonSerializer.Serialize <JsonMessage>(utf8JsonWriter, new JsonMessage { message = "Hello, World!" }, SerializerOptions); }
private void Return(Utf8JsonWriter writer, StringBuilder output) { writer.Flush(); if (_cachedMemoryStream.Length > 0) { if (!_cachedMemoryStream.TryGetBuffer(out var byteArray)) { byteArray = new ArraySegment <byte>(_cachedMemoryStream.GetBuffer(), 0, (int)_cachedMemoryStream.Length); } CopyToStringBuilder(byteArray, _cachedEncodingBuffer, output); } writer.Reset(); _cachedMemoryStream.Position = 0; _cachedMemoryStream.SetLength(0); System.Threading.Interlocked.Exchange(ref _cachedJsonWriter, writer); }
private static void Json(ref BufferWriter <WriterAdapter> writer, IBufferWriter <byte> bodyWriter) { writer.Write(_jsonPreamble); // Date header writer.Write(DateHeader.HeaderBytes); writer.Commit(); Utf8JsonWriter utf8JsonWriter = t_writer ??= new Utf8JsonWriter(bodyWriter, new JsonWriterOptions { SkipValidation = true }); utf8JsonWriter.Reset(bodyWriter); // Body JsonSerializer.Serialize(utf8JsonWriter, new JsonMessage { message = "Hello, World!" }, SerializerContext.JsonMessage); }
public void SerializeMessageToJson(LoggerJsonMessage message, Stream stream) { try { _Writer.Reset(); try { JsonSerializer.Serialize(_Writer, message, _Options); } catch (JsonException JsonException) { JsonSerializer.Serialize( _Writer, new LoggerJsonMessage { LogLevel = message.LogLevel, TimestampUtc = message.TimestampUtc, ThreadId = message.ThreadId, EventId = message.EventId, GroupName = message.GroupName, CategoryName = message.CategoryName, Content = $"Message with Content [{message.Content}] contained data that could not be serialized into Json.", Exception = LoggerJsonMessageException.FromException(JsonException) }, _Options); } finally { LoggerJsonMessage.Return(message); } _Buffer.WriteToStream(stream); stream.Write(s_NewLine, 0, s_NewLine.Length); stream.Flush(); } finally { _Buffer.Clear(); } }
public static void RenderMany <T>(IHeaderDictionary headerDictionary, PipeWriter pipeWriter, T[] tArray, IJsonSerializer <T> jsonSerializer) { headerDictionary.Add(_headerServer); headerDictionary.Add(_headerContentType); Utf8JsonWriter utf8JsonWriter = _utf8JsonWriter ??= new Utf8JsonWriter(pipeWriter, new JsonWriterOptions { SkipValidation = true }); utf8JsonWriter.Reset(pipeWriter); utf8JsonWriter.WriteStartArray(); foreach (var t in tArray) { jsonSerializer.Serialize(utf8JsonWriter, t); } utf8JsonWriter.WriteEndArray(); utf8JsonWriter.Flush(); headerDictionary.Add(new KeyValuePair <string, StringValues>("Content-Length", ((uint)utf8JsonWriter.BytesCommitted).ToString())); }
private void Serialize_Документ_Чеки() { JsonWriterOptions options = new JsonWriterOptions { Indented = false, Encoder = JavaScriptEncoder.Create(UnicodeRanges.All) }; MemoryStream stream = new MemoryStream(2048); Utf8JsonWriter writer = new Utf8JsonWriter(stream, options); writer.WriteStartObject(); writer.WriteString("#type", "jcfg:CatalogObject.Партии"); writer.WritePropertyName("#value"); writer.WriteStartObject(); writer.Flush(); ReadOnlySpan <byte> span = new ReadOnlySpan <byte>(stream.GetBuffer(), 0, (int)writer.BytesCommitted); writer.Reset(); stream.Position = 0; }
[Benchmark(Description = "RecyclableStream")] public void SerializeWithRecyclableStream() { JsonWriterOptions options = new JsonWriterOptions() { Indented = false, Encoder = JavaScriptEncoder.Create(UnicodeRanges.All) }; using (MemoryStream stream = StreamManager.GetStream()) { using (Utf8JsonWriter writer = new Utf8JsonWriter(stream, options)) { for (int i = 0; i < TestSize; i++) { Serialize2(writer); ReadOnlySpan <byte> span = new ReadOnlySpan <byte>(stream.GetBuffer(), 0, (int)writer.BytesCommitted); writer.Reset(); stream.Position = 0; } } } }
private static void GenericObjectOrJsonElementConverterTestHelper <T>(string converterName, object objectValue, string stringValue) { var options = new JsonSerializerOptions(); JsonConverter <T> converter = (JsonConverter <T>)options.GetConverter(typeof(T)); Assert.Equal(converterName, converter.GetType().Name); ReadOnlySpan <byte> data = Encoding.UTF8.GetBytes(stringValue); Utf8JsonReader reader = new Utf8JsonReader(data); reader.Read(); T readValue = converter.Read(ref reader, typeof(T), options); if (readValue is JsonElement element) { JsonTestHelper.AssertJsonEqual(stringValue, element.ToString()); } else { Assert.True(false, "Must be JsonElement"); } using (var stream = new MemoryStream()) using (var writer = new Utf8JsonWriter(stream)) { converter.Write(writer, (T)objectValue, options); writer.Flush(); Assert.Equal(stringValue, Encoding.UTF8.GetString(stream.ToArray())); writer.Reset(stream); converter.Write(writer, (T)objectValue, null); // Test with null option writer.Flush(); Assert.Equal(stringValue + stringValue, Encoding.UTF8.GetString(stream.ToArray())); } }
public void RunSystemTextJson() { _utf8JsonWriter.Reset(); JsonSerializer.Serialize(_utf8JsonWriter, _instance); }
public void RunSystemTextJson() { _memoryStream.Position = 0; _utf8JsonWriter.Reset(); JsonSerializer.Serialize(_utf8JsonWriter, _instance); }
public override void ThreadFunction() { ErrorCallback(this, "Network processing startup.", "", false); bool should_exit = false; byte[] remote_bytes = Array.Empty <byte>(); NetworkHeader read_header = null; Utf8JsonWriter jsonwriter; lock (_thread_interlock) { jsonwriter = new Utf8JsonWriter(DeviceStream); CommandQueue.Clear(); } byte[] read_buffer = new byte[block_size]; void DataReader() { try { lock (_thread_interlock) DeviceStream.BeginRead(read_buffer, 0, read_buffer.Length, delegate(IAsyncResult ar) { try { lock (_thread_interlock) { if (DeviceStream == null) { return; } int len = DeviceStream.EndRead(ar); int pos = remote_bytes.Length; Array.Resize(ref remote_bytes, pos + len); Buffer.BlockCopy(read_buffer, 0, remote_bytes, pos, len); } } catch (Exception e) { bool exiting; lock (_thread_interlock) exiting = _thread_end; if (!exiting) { ErrorCallback(this, "Network error.", e.Message, false); } } DataReader(); }, null); } catch (Exception e) { bool exiting; lock (_thread_interlock) exiting = _thread_end; if (!exiting) { ErrorCallback(this, "Network error.", e.Message, false); } } } DataReader(); while (!should_exit) { Thread.Yield(); long consumed = 0; if (read_header == null) { try { lock (_thread_interlock) { if (remote_bytes.Length > 0) { Utf8JsonReader jsonreader = new Utf8JsonReader(new ReadOnlySpan <byte>(remote_bytes)); read_header = JsonSerializer.Deserialize <NetworkHeader>(ref jsonreader); consumed = jsonreader.BytesConsumed; } } } catch (JsonException) { } } else { CommandBase received_command = null; try { lock (_thread_interlock) { if (remote_bytes.Length > 0) { Utf8JsonReader jsonreader = new Utf8JsonReader(new ReadOnlySpan <byte>(remote_bytes)); switch (read_header.ObjectType) { case TransmissionType.Nothing: break; case TransmissionType.Ready: received_command = JsonSerializer.Deserialize <ReadyCommand>(ref jsonreader); break; case TransmissionType.Panic: received_command = JsonSerializer.Deserialize <PanicCommand>(ref jsonreader); break; case TransmissionType.Levels: received_command = JsonSerializer.Deserialize <LevelsCommand>(ref jsonreader); break; case TransmissionType.Raw: received_command = JsonSerializer.Deserialize <RawCommand>(ref jsonreader); break; case TransmissionType.Mode: received_command = JsonSerializer.Deserialize <ModeCommand>(ref jsonreader); break; case TransmissionType.Response: received_command = JsonSerializer.Deserialize <DeviceResponse>(ref jsonreader); break; case TransmissionType.Request: break; case TransmissionType.Error: received_command = JsonSerializer.Deserialize <ErrorCommand>(ref jsonreader); break; } consumed = jsonreader.BytesConsumed; } } } catch (JsonException) { } if (received_command != null) { switch (read_header.ObjectType) { case TransmissionType.Nothing: break; case TransmissionType.Ready: QueueStateCallback(this, 0); break; case TransmissionType.Panic: MassLevelSetCallback(this, 0, 0, 0, true); ErrorCallback(this, "PANIC!", "Panic received from remote!", true); break; case TransmissionType.Levels: LevelsCommand levels = (LevelsCommand)received_command; LastA = levels.A; LastB = levels.B; MassLevelSetCallback(this, levels.A, levels.B, levels.MA, levels.Mode == ControlMode.absolute); break; case TransmissionType.Raw: RawCommand raw = (RawCommand)received_command; if (raw.Address == (int)AddressByte.Pot_A) { LastA = raw.Data; } if (raw.Address == (int)AddressByte.Pot_B) { LastB = raw.Data; } StateUpdatedCallback(this, raw.Address, raw.Data); break; case TransmissionType.Mode: ModeCommand mode = (ModeCommand)received_command; StateUpdatedCallback(this, (int)AddressByte.ModeOverride, mode.Mode); StateUpdatedCallback(this, (int)AddressByte.Pot_MA, mode.MA); break; case TransmissionType.Request: break; case TransmissionType.Response: DeviceResponse response = (DeviceResponse)received_command; DataReturnedCallback(this, response.Address, response.Data); double current_unixtime = UnixTime.Current(); LevelEvent level = new LevelEvent() { unixtime = current_unixtime }; lock (_thread_interlock) { if (response.Address == (int)AddressByte.PulseAmp_A) { level.level = (int)Math.Sqrt(LastA * response.Data); AmpHistoryA.Add(level); } if (response.Address == (int)AddressByte.PulseAmp_B) { level.level = (int)Math.Sqrt(LastB * response.Data); AmpHistoryB.Add(level); } } break; case TransmissionType.Error: ErrorCommand error = (ErrorCommand)received_command; ErrorCallback(this, error.Error, error.Details, false); break; } read_header = null; } } if (consumed > 0) { lock (_thread_interlock) { byte[] remaining = new byte[remote_bytes.Length - consumed]; Buffer.BlockCopy(remote_bytes, (int)consumed, remaining, 0, remaining.Length); remote_bytes = remaining; } } lock (_thread_interlock) { if (CommandQueue.Count > 0) { CommandBase command = CommandQueue.First(); CommandQueue.RemoveAt(0); NetworkHeader write_header = new NetworkHeader() { ObjectType = command.ObjectType }; try { JsonSerializer.Serialize(jsonwriter, write_header, typeof(NetworkHeader)); jsonwriter.Flush(); jsonwriter.Reset(); switch (command.ObjectType) { case TransmissionType.Nothing: break; case TransmissionType.Ready: JsonSerializer.Serialize(jsonwriter, (ReadyCommand)command, typeof(ReadyCommand)); break; case TransmissionType.Panic: JsonSerializer.Serialize(jsonwriter, (PanicCommand)command, typeof(PanicCommand)); break; case TransmissionType.Levels: JsonSerializer.Serialize(jsonwriter, (LevelsCommand)command, typeof(LevelsCommand)); break; case TransmissionType.Raw: JsonSerializer.Serialize(jsonwriter, (RawCommand)command, typeof(RawCommand)); break; case TransmissionType.Mode: JsonSerializer.Serialize(jsonwriter, (ModeCommand)command, typeof(ModeCommand)); break; case TransmissionType.Request: JsonSerializer.Serialize(jsonwriter, (RequestCommand)command, typeof(RequestCommand)); break; case TransmissionType.Response: JsonSerializer.Serialize(jsonwriter, (ResponseCommand)command, typeof(ResponseCommand)); break; case TransmissionType.Error: JsonSerializer.Serialize(jsonwriter, (ErrorCommand)command, typeof(ErrorCommand)); break; } jsonwriter.Flush(); jsonwriter.Reset(); } catch (JsonException) { } catch (IOException e) when(e.InnerException is SocketException) { _thread_end = true; ErrorCallback(this, "Network error.", e.InnerException.Message, false); } catch (IOException e) { _thread_end = true; ErrorCallback(this, "Network error.", e.Message, false); } catch (Exception e) { _thread_end = true; ErrorCallback(this, "Network error.", e.Message, false); } if (CommandQueue.Count == 0 && command.ObjectType != TransmissionType.Ready) { CommandQueue.Add(new ReadyCommand()); } } should_exit = _thread_end; } } try { lock (_thread_interlock) { if (DeviceStream != null) { DeviceStream.Close(); DeviceStream.Dispose(); } DeviceStream = null; } } catch (Exception e) { ErrorCallback(this, "Network error.", e.Message, false); } ErrorCallback(this, "Network processing shutdown.", "", false); }
public void Write_String() { writer.Reset(); writer.WriteString(propertyNameString, propertyValueString); }
// Currently supports https://github.com/grafana/loki/blob/master/docs/api.md#post-lokiapiv1push public void Format(IEnumerable <LogEvent> logEvents, ITextFormatter formatter, TextWriter output) { if (logEvents == null) { throw new ArgumentNullException(nameof(logEvents)); } if (output == null) { throw new ArgumentNullException(nameof(output)); } if (!logEvents.Any()) { return; } var timestampOverride = SystemClock.Instance.GetCurrentInstant(); // process labels for grouping/sorting var sortedStreams = logEvents .GroupBy(x => x.Properties .Where(prop => _labelNames.Contains(prop.Key)) .Select(prop => new KeyValuePair <string, string>(prop.Key, cleanseString(prop.Value.ToString()))) .Concat(_labelNames.Contains("level") ? new[] { new KeyValuePair <string, string>("level", GetLevel(x.Level)) } : new KeyValuePair <string, string>[] { }) .Concat(_globalLabels).ToHashSet(), new HashSetComparer()) .Select(stream => new KeyValuePair <HashSet <KeyValuePair <string, string> >, IOrderedEnumerable <LogEvent> >(stream.Key, stream.OrderBy(log => log.Timestamp))); var logLineBuffer = new ArrayBufferWriter <byte>(); using var logLineJsonWriter = new Utf8JsonWriter(logLineBuffer); var outputBuffer = new ArrayBufferWriter <byte>(); using var jsonWriter = new Utf8JsonWriter(outputBuffer); jsonWriter.WriteStartObject(); jsonWriter.WriteStartArray("streams"); foreach (var stream in sortedStreams) { jsonWriter.WriteStartObject(); jsonWriter.WriteStartObject("stream"); foreach (var label in stream.Key) { jsonWriter.WriteString(label.Key, label.Value); } jsonWriter.WriteEndObject(); jsonWriter.WriteStartArray("values"); foreach (var logEvent in stream.Value) { jsonWriter.WriteStartArray(); var timestamp = this._preserveTimestamps ? Instant.FromDateTimeOffset(logEvent.Timestamp) : timestampOverride; jsonWriter.WriteStringValue((timestamp.ToUnixTimeTicks() * 100).ToString()); // Construct a json object for the log line logLineJsonWriter.WriteStartObject(); logLineJsonWriter.WriteString("message", logEvent.RenderMessage()); foreach (var property in logEvent.Properties) { logLineJsonWriter.WriteString(property.Key, cleanseString(property.Value.ToString())); } if (this._preserveTimestamps == false) { logLineJsonWriter.WriteString("timestamp", Instant.FromDateTimeOffset(logEvent.Timestamp).ToString()); } if (logEvent.Exception != null) { var sb = new StringBuilder(); var e = logEvent.Exception; while (e != null) { sb.AppendLine(e.Message); sb.AppendLine(e.StackTrace); e = e.InnerException; } logLineJsonWriter.WriteString("exception", sb.ToString()); } logLineJsonWriter.WriteEndObject(); logLineJsonWriter.Flush(); jsonWriter.WriteStringValue(Encoding.UTF8.GetString(logLineBuffer.WrittenSpan)); jsonWriter.WriteEndArray(); logLineJsonWriter.Reset(); logLineBuffer.Clear(); } jsonWriter.WriteEndArray(); jsonWriter.WriteEndObject(); } jsonWriter.WriteEndArray(); jsonWriter.WriteEndObject(); jsonWriter.Flush(); output.Write(Encoding.UTF8.GetString(outputBuffer.WrittenSpan)); }