public static DefaultHighLevelSerializer CreateStateful <T>(this IElasticsearchSerializer serializer, IJsonFormatter <T> formatter)
{
var currentFormatterResolver = ((IInternalSerializerWithFormatter)serializer).FormatterResolver;
var formatterResolver = new StatefulFormatterResolver <T>(formatter, currentFormatterResolver);
return(new DefaultHighLevelSerializer(formatterResolver));
}
protected ConnectionSettingsBase(
IConnectionPool connectionPool,
IConnection connection,
ConnectionSettings.SourceSerializerFactory sourceSerializerFactory,
IPropertyMappingProvider propertyMappingProvider
)
: base(connectionPool, connection, null)
{
var formatterResolver = new NestFormatterResolver(this);
var defaultSerializer = new DefaultHighLevelSerializer(formatterResolver);
var sourceSerializer = sourceSerializerFactory?.Invoke(defaultSerializer, this) ?? defaultSerializer;
var serializerAsMappingProvider = sourceSerializer as IPropertyMappingProvider;
_propertyMappingProvider = propertyMappingProvider ?? serializerAsMappingProvider ?? new PropertyMappingProvider();
//We wrap these in an internal proxy to facilitate serialization diagnostics
_sourceSerializer = new DiagnosticsSerializerProxy(sourceSerializer, "source");
UseThisRequestResponseSerializer = new DiagnosticsSerializerProxy(defaultSerializer);
_defaultFieldNameInferrer = p => p.ToCamelCase();
_defaultIndices = new FluentDictionary <Type, string>();
_defaultRelationNames = new FluentDictionary <Type, string>();
_inferrer = new Inferrer(this);
UserAgent(ConnectionSettings.DefaultUserAgent);
}
public static LoggerConfiguration ElasticSearch(
this LoggerSinkConfiguration loggerConfiguration,
string indexFormat = ElasticsearchSink.DefaultIndexFormat,
Uri node = null,
int connectionTimeOutInMilliseconds = ElasticsearchSink.DefaultConnectionTimeout,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
int batchPostingLimit = ElasticsearchSink.DefaultBatchPostingLimit,
TimeSpan?period = null,
IFormatProvider formatProvider = null,
IElasticsearchSerializer serializer = null
)
{
if (node == null)
{
node = new Uri("http://localhost:9200");
}
return(Elasticsearch(loggerConfiguration, new ElasticsearchSinkOptions(new [] { node })
{
Serializer = serializer,
FormatProvider = formatProvider,
IndexFormat = indexFormat,
ModifyConnectionSetttings = s => s.SetTimeout(connectionTimeOutInMilliseconds),
BatchPostingLimit = batchPostingLimit,
Period = period,
MinimumLogEventLevel = restrictedToMinimumLevel
}));
}
public Transport(
IConnectionConfigurationValues configurationValues,
IConnection connection,
IElasticsearchSerializer serializer,
IDateTimeProvider dateTimeProvider = null,
IMemoryStreamProvider memoryStreamProvider = null
)
{
this.ConfigurationValues = configurationValues;
this.Connection = connection ?? new HttpConnection(configurationValues);
this._serializer = serializer ?? new ElasticsearchDefaultSerializer();
this._connectionPool = this.ConfigurationValues.ConnectionPool;
this._dateTimeProvider = dateTimeProvider ?? new DateTimeProvider();
this._memoryStreamProvider = memoryStreamProvider ?? new MemoryStreamProvider();
this._lastSniff = this._dateTimeProvider.Now();
this.Settings.Serializer = this._serializer;
this._requestHandler = new RequestHandler(this.Settings, this._connectionPool, this.Connection, this._serializer, this._memoryStreamProvider, this);
this._requestHandlerAsync = new RequestHandlerAsync(this.Settings, this._connectionPool, this.Connection, this._serializer, this._memoryStreamProvider, this);
if (this._connectionPool.AcceptsUpdates && this.Settings.SniffsOnStartup)
{
Self.SniffClusterState();
}
}
public static LoggerConfiguration ElasticSearch(
this LoggerSinkConfiguration loggerConfiguration,
ConnectionConfiguration connectionConfiguration,
string indexFormat = ElasticsearchSink.DefaultIndexFormat,
LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum,
int batchPostingLimit = ElasticsearchSink.DefaultBatchPostingLimit,
TimeSpan?period = null,
IFormatProvider formatProvider = null,
IElasticsearchSerializer serializer = null
)
{
if (connectionConfiguration == null)
{
throw new ArgumentNullException("connectionConfiguration");
}
IConnectionConfigurationValues values = connectionConfiguration;
return(Elasticsearch(loggerConfiguration, new ElasticsearchSinkOptions(values.ConnectionPool)
{
Serializer = serializer,
FormatProvider = formatProvider,
IndexFormat = indexFormat,
ModifyConnectionSetttings = s => connectionConfiguration,
BatchPostingLimit = batchPostingLimit,
Period = period,
MinimumLogEventLevel = restrictedToMinimumLevel
}));
}
public static string SerializeToString <T>(
this IElasticsearchSerializer serializer,
T data,
IMemoryStreamFactory memoryStreamFactory = null,
SerializationFormatting formatting = SerializationFormatting.Indented
) =>
serializer.SerializeToBytes(data, memoryStreamFactory, formatting).Utf8String();
public static byte[] SerializeToBytes(this IElasticsearchSerializer serializer, object data, SerializationFormatting formatting = SerializationFormatting.Indented)
{
using (var ms = new MemoryStream())
{
serializer.Serialize(data, ms, formatting);
return(ms.ToArray());
}
}
public override object DeserializeResponse(IElasticsearchSerializer builtInSerializer, IApiCallDetails response, Stream stream) =>
response.Success
? new GetCertificatesResponse
{
Certificates = builtInSerializer.Deserialize <ClusterCertificateInformation[]>(stream)
}
: new GetCertificatesResponse();
/// <summary>
/// 初始化我的Elasticsearch日志格式化器
/// </summary>
/// <param name="formatProvider">格式化提供者</param>
/// <param name="closingDelimiter">A string that will be written after each log event is formatted. If null, System.Environment.NewLine will be used. Ignored if omitEnclosingObject is true.</param>
/// <param name="serializer">序列化器</param>
/// <param name="inlineFields">When set to true values will be written at the root of the json document</param>
/// <param name="rootFields">需要显示在根文档下的字段</param>
public MyElasticsearchJsonFormatter(IFormatProvider formatProvider = null,
string closingDelimiter = null, IElasticsearchSerializer serializer = null,
bool inlineFields = false, IList <string> rootFields = null) :
base(formatProvider: formatProvider, closingDelimiter: closingDelimiter, serializer: serializer, inlineFields: inlineFields)
{
_inlineFields = inlineFields;
_rootFields = rootFields ?? throw new ArgumentNullException(nameof(rootFields));
}
public override object DeserializeResponse(IElasticsearchSerializer builtInSerializer, IApiCallDetails response, Stream stream) =>
response.Success
? new PreviewDatafeedResponse <TDocument>
{
Data = builtInSerializer.Deserialize <IReadOnlyCollection <TDocument> >(stream)
}
: new PreviewDatafeedResponse <TDocument>();
public JsonFormatterAwareDiagnosticsSerializerProxy(IElasticsearchSerializer serializer, string purpose = "request/response")
: base(serializer, purpose)
{
if (serializer is IInternalSerializer s && s.TryGetJsonFormatter(out var formatterResolver))
{
_formatterResolver = formatterResolver;
_wrapsUtf8JsonSerializer = true;
}
public override async Task <object> DeserializeResponseAsync(IElasticsearchSerializer builtInSerializer, IApiCallDetails response, Stream stream, CancellationToken ctx = default) =>
response.Success
? new SourceResponse <TDocument>
{
Body = await builtInSerializer.DeserializeAsync <TDocument>(stream, ctx).ConfigureAwait(false)
}
: new SourceResponse <TDocument>();
public override object DeserializeResponse(IElasticsearchSerializer builtInSerializer, IApiCallDetails response, Stream stream) =>
response.Success
? new TranslateSqlResponse
{
Result = builtInSerializer.Deserialize <ISearchRequest>(stream)
}
: new TranslateSqlResponse();
public FractionalNumbers()
{
var pool = new SingleNodeConnectionPool(new Uri("http://localhost:9200"));
var settings = new ConnectionSettings(pool, new InMemoryConnection());
var client = new ElasticClient(settings);
_serializer = client.RequestResponseSerializer;
}
public override object DeserializeResponse(IElasticsearchSerializer builtInSerializer, IApiCallDetails response, Stream stream) =>
response.Success
? new SourceResponse <TDocument>
{
Body = builtInSerializer.Deserialize <TDocument>(stream)
}
: new SourceResponse <TDocument>();
/// <summary>
/// Constructs a <see cref="ExceptionAsObjectJsonFormatter"/>.
/// </summary>
/// <param name="omitEnclosingObject">If true, the properties of the event will be written to
/// the output without enclosing braces. Otherwise, if false, each event will be written as a well-formed
/// JSON object.</param>
/// <param name="closingDelimiter">A string that will be written after each log event is formatted.
/// If null, <see cref="Environment.NewLine"/> will be used. Ignored if <paramref name="omitEnclosingObject"/>
/// is true.</param>
/// <param name="renderMessage">If true, the message will be rendered and written to the output as a
/// property named RenderedMessage.</param>
/// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
/// <param name="serializer">Inject a serializer to force objects to be serialized over being ToString()</param>
/// <param name="inlineFields">When set to true values will be written at the root of the json document</param>
public LogExceptionFormatter(bool omitEnclosingObject = false,
string closingDelimiter = null,
bool renderMessage = true,
IFormatProvider formatProvider = null,
IElasticsearchSerializer serializer = null,
bool inlineFields = false)
: base(omitEnclosingObject, closingDelimiter, renderMessage, formatProvider, serializer, inlineFields)
{
}
public DiagnosticsSerializerProxy(IElasticsearchSerializer serializer, string purpose = "request/response")
{
_serializer = serializer;
_state = new SerializerRegistrationInformation(serializer.GetType(), purpose);
if (serializer is IInternalSerializer s && s.TryGetJsonFormatter(out var formatterResolver))
{
_formatterResolver = formatterResolver;
_wrapsUtf8JsonSerializer = true;
}
public static IList<Uri> FromStream(IElasticsearchResponse response, Stream stream, IElasticsearchSerializer serializer, TransportAddressScheme? preferedTransportOrder = null)
{
var order = preferedTransportOrder.GetValueOrDefault(TransportAddressScheme.Http);
var result = serializer.Deserialize<NodeInfoResponse>(stream);
return result.nodes.Values
.Select(kv => kv.GetFirstAddress(order))
.Where(url => url != null)
.ToList();
}
public DiagnosticsSerializerProxy(IElasticsearchSerializer serializer, string purpose = "request/response")
{
_serializer = serializer;
_state = new SerializerRegistrationInformation(serializer.GetType(), purpose);
if (serializer is IInternalSerializerWithFormatter withFormatter)
{
_formatterResolver = withFormatter.FormatterResolver;
}
}
public ExceptionSerializationTests()
{
var pool = new SingleNodeConnectionPool(new Uri("http://localhost:9200"));
var connection = new InMemoryConnection();
var values = new ConnectionConfiguration(pool, connection);
var lowlevelClient = new ElasticLowLevelClient(values);
_elasticsearchNetSerializer = lowlevelClient.Serializer;
}
internal LazyDocument(byte[] bytes, IJsonFormatterResolver formatterResolver)
{
Bytes = bytes;
var settings = formatterResolver.GetConnectionSettings();
_sourceSerializer = settings.SourceSerializer;
_requestResponseSerializer = settings.RequestResponseSerializer;
_memoryStreamFactory = settings.MemoryStreamFactory;
}
public JsonNetSerializer(
IElasticsearchSerializer builtinSerializer,
IConnectionSettingsValues connectionSettings,
Func <JsonSerializerSettings> jsonSerializerSettingsFactory = null,
Action <ConnectionSettingsAwareContractResolver> modifyContractResolver = null,
IEnumerable <JsonConverter> contractJsonConverters = null)
: base(builtinSerializer, connectionSettings, jsonSerializerSettingsFactory, modifyContractResolver, contractJsonConverters)
{
}
public static string SerializeToString <T>(this IElasticsearchSerializer serializer, T data,
SerializationFormatting formatting = SerializationFormatting.Indented
)
{
using (var ms = new MemoryStream())
{
serializer.Serialize(data, ms, formatting);
return(ms.Utf8String());
}
}
public RequestHandler(
IConnectionConfigurationValues settings,
IConnectionPool connectionPool,
IConnection connection,
IElasticsearchSerializer serializer,
IMemoryStreamProvider memoryStreamProvider,
ITransportDelegator delegator)
: base(settings, connection, connectionPool, serializer, memoryStreamProvider, delegator)
{
}
/// <summary>
/// Construct a <see cref="ElasticsearchJsonFormatter"/>.
/// </summary>
/// <param name="omitEnclosingObject">If true, the properties of the event will be written to
/// the output without enclosing braces. Otherwise, if false, each event will be written as a well-formed
/// JSON object.</param>
/// <param name="closingDelimiter">A string that will be written after each log event is formatted.
/// If null, <see cref="Environment.NewLine"/> will be used. Ignored if <paramref name="omitEnclosingObject"/>
/// is true.</param>
/// <param name="renderMessage">If true, the message will be rendered and written to the output as a
/// property named RenderedMessage.</param>
/// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
/// <param name="serializer">Inject a serializer to force objects to be serialized over being ToString()</param>
/// <param name="inlineFields">When set to true values will be written at the root of the json document</param>
public ElasticsearchJsonFormatter(bool omitEnclosingObject = false,
string closingDelimiter = null,
bool renderMessage = false,
IFormatProvider formatProvider = null,
IElasticsearchSerializer serializer = null,
bool inlineFields = false)
: base(omitEnclosingObject, closingDelimiter, renderMessage, formatProvider)
{
_serializer = serializer;
_inlineFields = inlineFields;
}
public override async Task <object> DeserializeResponseAsync(
IElasticsearchSerializer builtInSerializer,
IApiCallDetails response,
Stream stream,
CancellationToken ctx = default
) =>
response.Success
? await builtInSerializer.CreateStateful(Formatter)
.DeserializeAsync <MultiSearchResponse>(stream, ctx)
.ConfigureAwait(false)
: new MultiSearchResponse();
/// <summary>
/// Construct a <see cref="ElasticsearchJsonFormatter"/>.
/// </summary>
/// <param name="omitEnclosingObject">If true, the properties of the event will be written to
/// the output without enclosing braces. Otherwise, if false, each event will be written as a well-formed
/// JSON object.</param>
/// <param name="closingDelimiter">A string that will be written after each log event is formatted.
/// If null, <see cref="Environment.NewLine"/> will be used. Ignored if <paramref name="omitEnclosingObject"/>
/// is true.</param>
/// <param name="renderMessage">If true, the message will be rendered and written to the output as a
/// property named RenderedMessage.</param>
/// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
/// <param name="serializer">Inject a serializer to force objects to be serialized over being ToString()</param>
/// <param name="inlineFields">When set to true values will be written at the root of the json document</param>
public ElasticsearchJsonFormatter(bool omitEnclosingObject = false,
string closingDelimiter = null,
bool renderMessage = false,
IFormatProvider formatProvider = null,
IElasticsearchSerializer serializer = null,
bool inlineFields = false)
: base(omitEnclosingObject, closingDelimiter, renderMessage, formatProvider)
{
_serializer = serializer;
_inlineFields = inlineFields;
}
public static DefaultHighLevelSerializer CreateStateful <T>(this IElasticsearchSerializer serializer, IJsonFormatter <T> formatter)
{
if (!(serializer is IInternalSerializer s) || !s.TryGetJsonFormatter(out var currentFormatterResolver))
{
throw new Exception($"Can not create a stateful serializer because {serializer.GetType()} does not yield a json formatter");
}
var formatterResolver = new StatefulFormatterResolver <T>(formatter, currentFormatterResolver);
return(new DefaultHighLevelSerializer(formatterResolver));
}
public ElasticJsonNetSerializer(
IElasticsearchSerializer builtinSerializer,
IConnectionSettingsValues connectionSettings,
JsonSerializerSettings serializerSettings
) : base(
builtinSerializer,
connectionSettings,
() => CreateJsonSerializerSettings(serializerSettings),
contractJsonConverters: serializerSettings.Converters.ToList()
)
{
}
/// <summary>
/// Instantiate a new low level elasticsearch client
/// </summary>
/// <param name="settings">Specify how and where the client connects to elasticsearch, defaults to a static single node connectionpool
/// to http://localhost:9200
/// </param>
/// <param name="connection">Provide an alternative connection handler</param>
/// <param name="transport">Provide a custom transport implementation that coordinates between IConnectionPool, IConnection and ISerializer</param>
/// <param name="serializer">Provide a custom serializer</param>
public ElasticsearchClient(
IConnectionConfigurationValues settings = null,
IConnection connection = null,
ITransport transport = null,
IElasticsearchSerializer serializer = null
)
{
settings = settings ?? new ConnectionConfiguration();
this.Transport = transport ?? new Transport(settings, connection, serializer);
//neccessary to pass the serializer to ElasticsearchResponse
this.Settings.Serializer = this.Transport.Serializer;
}
internal static NameValueCollection ToNameValueCollection(this IDictionary<string, object> dict, IElasticsearchSerializer stringifier)
{
stringifier.ThrowIfNull("stringifier");
if (dict == null || dict.Count < 0)
return null;
var nv = new NameValueCollection();
foreach (var kv in dict.Where(kv => !kv.Key.IsNullOrEmpty()))
{
nv.Add(kv.Key, stringifier.Stringify(kv.Value));
}
return nv;
}
public override async Task <object> DeserializeResponseAsync(IElasticsearchSerializer builtInSerializer, IApiCallDetails response, Stream stream, CancellationToken ctx = default)
{
if (!response.Success || response.HttpStatusCode == 404)
{
return(await builtInSerializer.DeserializeAsync <CatResponse <TCatRecord> >(stream, ctx).ConfigureAwait(false));
}
var catResponse = new CatResponse <TCatRecord>();
var records = await builtInSerializer.DeserializeAsync <IReadOnlyCollection <TCatRecord> >(stream, ctx).ConfigureAwait(false);
catResponse.Records = records;
return(catResponse);
}
internal static void SerializeUsingWriter <T>(this IElasticsearchSerializer serializer, ref JsonWriter writer, T body, IConnectionConfigurationValues settings, SerializationFormatting formatting)
{
if (serializer is IInternalSerializer s && s.TryGetJsonFormatter(out var formatterResolver))
{
JsonSerializer.Serialize(ref writer, body, formatterResolver);
return;
}
var memoryStreamFactory = settings.MemoryStreamFactory;
var bodyBytes = serializer.SerializeToBytes(body, memoryStreamFactory, formatting);
writer.WriteRaw(bodyBytes);
}
public static IList<Uri> FromStream(IElasticsearchResponse response, Stream stream, IElasticsearchSerializer serializer)
{
var result = serializer.Deserialize<NodeInfoResponse>(stream);
var l = new List<Uri>();
foreach(var kv in result.nodes.Values)
{
if (!kv.http_address.IsNullOrEmpty())
l.Add(Parse("http", kv.http_address));
else if (!kv.https_address.IsNullOrEmpty())
l.Add(Parse("https",kv.https_address));
else if (!kv.thrift_address.IsNullOrEmpty())
l.Add(Parse("http", kv.thrift_address));
}
return l;
}
public static IList<Uri> FromStream(Stream stream, IElasticsearchSerializer serializer)
{
using (var memoryStream = new MemoryStream())
{
stream.CopyTo(memoryStream);
var response = serializer.Deserialize<NodeInfoResponse>(memoryStream.ToArray());
var l = new List<Uri>();
foreach(var kv in response.nodes.Values)
{
if (!kv.http_address.IsNullOrEmpty())
l.Add(Parse("http", kv.http_address));
else if (!kv.https_address.IsNullOrEmpty())
l.Add(Parse("https",kv.https_address));
else if (!kv.thrift_address.IsNullOrEmpty())
l.Add(Parse("http", kv.thrift_address));
}
return l;
}
}
public Transport(
IConnectionConfigurationValues configurationValues,
IConnection connection,
IElasticsearchSerializer serializer,
IDateTimeProvider dateTimeProvider = null
)
{
this._configurationValues = configurationValues;
this._connection = connection?? new HttpConnection(configurationValues);
this._serializer = serializer ?? new ElasticsearchDefaultSerializer();
this._connectionPool = this._configurationValues.ConnectionPool;
//TODO: take the datetimeprovider from the connection pool?
this._dateTimeProvider = dateTimeProvider ?? new DateTimeProvider();
if (this._configurationValues.SniffsOnStartup)
this.Sniff(fromStartup: true);
else
this._lastSniff = this._dateTimeProvider.Now();
}
/// <summary>
/// Constructs a <see cref="ExceptionAsObjectJsonFormatter"/>.
/// </summary>
/// <param name="omitEnclosingObject">If true, the properties of the event will be written to
/// the output without enclosing braces. Otherwise, if false, each event will be written as a well-formed
/// JSON object.</param>
/// <param name="closingDelimiter">A string that will be written after each log event is formatted.
/// If null, <see cref="Environment.NewLine"/> will be used. Ignored if <paramref name="omitEnclosingObject"/>
/// is true.</param>
/// <param name="renderMessage">If true, the message will be rendered and written to the output as a
/// property named RenderedMessage.</param>
/// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
/// <param name="serializer">Inject a serializer to force objects to be serialized over being ToString()</param>
/// <param name="inlineFields">When set to true values will be written at the root of the json document</param>
public ExceptionAsObjectJsonFormatter(bool omitEnclosingObject = false, string closingDelimiter = null, bool renderMessage = false, IFormatProvider formatProvider = null, IElasticsearchSerializer serializer = null, bool inlineFields = false)
: base(omitEnclosingObject, closingDelimiter, renderMessage, formatProvider, serializer, inlineFields)
{
}
public ElasticsearchSinkUniformityTestsBase(IElasticsearchSerializer serializer)
{
_options.Serializer = serializer;
}
