/// <summary> /// /// </summary> /// <param name="elasticLowLevelClient"></param> /// <param name="cleanPayload"></param> /// <param name="elasticOpType"></param> public ElasticsearchLogClient(IElasticLowLevelClient elasticLowLevelClient, Func <string, long?, string, string> cleanPayload, ElasticOpType elasticOpType) { _elasticLowLevelClient = elasticLowLevelClient; _cleanPayload = cleanPayload; _elasticOpType = elasticOpType; }
/// <summary> /// /// </summary> /// <param name="pipelineName"></param> /// <param name="typeName"></param> /// <param name="serialize"></param> /// <param name="getIndexForEvent"></param> /// <param name="elasticOpType"></param> public ElasticsearchPayloadReader(string pipelineName, string typeName, Func <object, string> serialize, Func <string, DateTime, string> getIndexForEvent, ElasticOpType elasticOpType) { _pipelineName = pipelineName; _typeName = typeName; _serialize = serialize; _getIndexForEvent = getIndexForEvent; _elasticOpType = elasticOpType; }
internal static object CreateElasticAction(ElasticOpType opType, string indexName, string pipelineName = null, string id = null, string mappingType = null) { var actionPayload = new ElasticActionPayload( indexName: indexName, pipeline: string.IsNullOrWhiteSpace(pipelineName) ? null : pipelineName, id: id, mappingType: mappingType ); var action = opType == ElasticOpType.Create ? (object)new ElasticCreateAction(actionPayload) : new ElasticIndexAction(actionPayload); return(action); }
/// <summary> /// Overload to allow basic configuration through AppSettings. /// </summary> /// <param name="loggerSinkConfiguration">Options for the sink.</param> /// <param name="nodeUris">A comma or semi column separated list of URIs for Elasticsearch nodes.</param> /// <param name="indexFormat"><see cref="ElasticsearchSinkOptions.IndexFormat"/></param> /// <param name="templateName"><see cref="ElasticsearchSinkOptions.TemplateName"/></param> /// <param name="typeName"><see cref="ElasticsearchSinkOptions.TypeName"/></param> /// <param name="batchPostingLimit"><see cref="ElasticsearchSinkOptions.BatchPostingLimit"/></param> /// <param name="period"><see cref="ElasticsearchSinkOptions.Period"/></param> /// <param name="inlineFields"><see cref="ElasticsearchSinkOptions.InlineFields"/></param> /// <param name="restrictedToMinimumLevel">The minimum log event level required in order to write an event to the sink. Ignored when <paramref name="levelSwitch"/> is specified.</param> /// <param name="levelSwitch">A switch allowing the pass-through minimum level to be changed at runtime.</param> /// <param name="bufferBaseFilename"><see cref="ElasticsearchSinkOptions.BufferBaseFilename"/></param> /// <param name="bufferFileSizeLimitBytes"><see cref="ElasticsearchSinkOptions.BufferFileSizeLimitBytes"/></param> /// <param name="bufferFileCountLimit"><see cref="ElasticsearchSinkOptions.BufferFileCountLimit"/></param> /// <param name="bufferLogShippingInterval"><see cref="ElasticsearchSinkOptions.BufferLogShippingInterval"/></param> /// <param name="connectionGlobalHeaders">A comma or semi column separated list of key value pairs of headers to be added to each elastic http request</param> /// <param name="connectionTimeout"><see cref="ElasticsearchSinkOptions.ConnectionTimeout"/>The connection timeout (in seconds) when sending bulk operations to elasticsearch (defaults to 5).</param> /// <param name="emitEventFailure"><see cref="ElasticsearchSinkOptions.EmitEventFailure"/>Specifies how failing emits should be handled.</param> /// <param name="queueSizeLimit"><see cref="ElasticsearchSinkOptions.QueueSizeLimit"/>The maximum number of events that will be held in-memory while waiting to ship them to Elasticsearch. Beyond this limit, events will be dropped. The default is 100,000. Has no effect on durable log shipping.</param> /// <param name="pipelineName"><see cref="ElasticsearchSinkOptions.PipelineName"/>Name the Pipeline where log events are sent to sink. Please note that the Pipeline should be existing before the usage starts.</param> /// <param name="autoRegisterTemplate"><see cref="ElasticsearchSinkOptions.AutoRegisterTemplate"/>When set to true the sink will register an index template for the logs in elasticsearch.</param> /// <param name="autoRegisterTemplateVersion"><see cref="ElasticsearchSinkOptions.AutoRegisterTemplateVersion"/>When using the AutoRegisterTemplate feature, this allows to set the Elasticsearch version. Depending on the version, a template will be selected. Defaults to pre 5.0.</param> /// <param name="overwriteTemplate"><see cref="ElasticsearchSinkOptions.OverwriteTemplate"/>When using the AutoRegisterTemplate feature, this allows you to overwrite the template in Elasticsearch if it already exists. Defaults to false</param> /// <param name="registerTemplateFailure"><see cref="ElasticsearchSinkOptions.RegisterTemplateFailure"/>Specifies the option on how to handle failures when writing the template to Elasticsearch. This is only applicable when using the AutoRegisterTemplate option.</param> /// <param name="deadLetterIndexName"><see cref="ElasticsearchSinkOptions.DeadLetterIndexName"/>Optionally set this value to the name of the index that should be used when the template cannot be written to ES.</param> /// <param name="numberOfShards"><see cref="ElasticsearchSinkOptions.NumberOfShards"/>The default number of shards.</param> /// <param name="numberOfReplicas"><see cref="ElasticsearchSinkOptions.NumberOfReplicas"/>The default number of replicas.</param> /// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param> /// <param name="connection">Allows you to override the connection used to communicate with elasticsearch.</param> /// <param name="serializer">When passing a serializer unknown object will be serialized to object instead of relying on their ToString representation</param> /// <param name="connectionPool">The connectionpool describing the cluster to write event to</param> /// <param name="customFormatter">Customizes the formatter used when converting log events into ElasticSearch documents. Please note that the formatter output must be valid JSON :)</param> /// <param name="customDurableFormatter">Customizes the formatter used when converting log events into the durable sink. Please note that the formatter output must be valid JSON :)</param> /// <param name="failureSink">Sink to use when Elasticsearch is unable to accept the events. This is optionally and depends on the EmitEventFailure setting.</param> /// <param name="singleEventSizePostingLimit"><see cref="ElasticsearchSinkOptions.SingleEventSizePostingLimit"/>The maximum length of an event allowed to be posted to Elasticsearch.default null</param> /// <param name="templateCustomSettings">Add custom elasticsearch settings to the template</param> /// <param name="batchAction">Configures the OpType being used when inserting document in batch. Must be set to create for data streams.</param> /// <returns>LoggerConfiguration object</returns> /// <exception cref="ArgumentNullException"><paramref name="nodeUris"/> is <see langword="null" />.</exception> public static LoggerConfiguration Elasticsearch( this LoggerSinkConfiguration loggerSinkConfiguration, string nodeUris, string indexFormat = null, string templateName = null, string typeName = "logevent", int batchPostingLimit = 50, int period = 2, bool inlineFields = false, LogEventLevel restrictedToMinimumLevel = LevelAlias.Minimum, string bufferBaseFilename = null, long?bufferFileSizeLimitBytes = null, long bufferLogShippingInterval = 5000, string connectionGlobalHeaders = null, LoggingLevelSwitch levelSwitch = null, int connectionTimeout = 5, EmitEventFailureHandling emitEventFailure = EmitEventFailureHandling.WriteToSelfLog, int queueSizeLimit = 100000, string pipelineName = null, bool autoRegisterTemplate = false, AutoRegisterTemplateVersion autoRegisterTemplateVersion = AutoRegisterTemplateVersion.ESv2, bool overwriteTemplate = false, RegisterTemplateRecovery registerTemplateFailure = RegisterTemplateRecovery.IndexAnyway, string deadLetterIndexName = null, int?numberOfShards = null, int?numberOfReplicas = null, IFormatProvider formatProvider = null, IConnection connection = null, IElasticsearchSerializer serializer = null, IConnectionPool connectionPool = null, ITextFormatter customFormatter = null, ITextFormatter customDurableFormatter = null, ILogEventSink failureSink = null, long?singleEventSizePostingLimit = null, int?bufferFileCountLimit = null, Dictionary <string, string> templateCustomSettings = null, ElasticOpType batchAction = ElasticOpType.Index) { if (string.IsNullOrEmpty(nodeUris)) { throw new ArgumentNullException(nameof(nodeUris), "No Elasticsearch node(s) specified."); } IEnumerable <Uri> nodes = nodeUris .Split(new[] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries) .Select(uriString => new Uri(uriString)); var options = connectionPool == null ? new ElasticsearchSinkOptions(nodes) : new ElasticsearchSinkOptions(connectionPool); if (!string.IsNullOrWhiteSpace(indexFormat)) { options.IndexFormat = indexFormat; } if (!string.IsNullOrWhiteSpace(templateName)) { options.AutoRegisterTemplate = true; options.TemplateName = templateName; } if (!string.IsNullOrWhiteSpace(typeName)) { options.TypeName = typeName; } options.BatchPostingLimit = batchPostingLimit; options.BatchAction = batchAction; options.SingleEventSizePostingLimit = singleEventSizePostingLimit; options.Period = TimeSpan.FromSeconds(period); options.InlineFields = inlineFields; options.MinimumLogEventLevel = restrictedToMinimumLevel; options.LevelSwitch = levelSwitch; if (!string.IsNullOrWhiteSpace(bufferBaseFilename)) { Path.GetFullPath(bufferBaseFilename); // validate path options.BufferBaseFilename = bufferBaseFilename; } if (bufferFileSizeLimitBytes.HasValue) { options.BufferFileSizeLimitBytes = bufferFileSizeLimitBytes.Value; } if (bufferFileCountLimit.HasValue) { options.BufferFileCountLimit = bufferFileCountLimit.Value; } options.BufferLogShippingInterval = TimeSpan.FromMilliseconds(bufferLogShippingInterval); if (!string.IsNullOrWhiteSpace(connectionGlobalHeaders)) { NameValueCollection headers = new NameValueCollection(); connectionGlobalHeaders .Split(new[] { ',', ';' }, StringSplitOptions.RemoveEmptyEntries) .ToList() .ForEach(headerValueStr => { var headerValue = headerValueStr.Split(new[] { '=' }, 2, StringSplitOptions.RemoveEmptyEntries); headers.Add(headerValue[0], headerValue[1]); }); options.ModifyConnectionSettings = (c) => c.GlobalHeaders(headers); } options.ConnectionTimeout = TimeSpan.FromSeconds(connectionTimeout); options.EmitEventFailure = emitEventFailure; options.QueueSizeLimit = queueSizeLimit; options.PipelineName = pipelineName; options.AutoRegisterTemplate = autoRegisterTemplate; options.AutoRegisterTemplateVersion = autoRegisterTemplateVersion; options.RegisterTemplateFailure = registerTemplateFailure; options.OverwriteTemplate = overwriteTemplate; options.NumberOfShards = numberOfShards; options.NumberOfReplicas = numberOfReplicas; if (!string.IsNullOrWhiteSpace(deadLetterIndexName)) { options.DeadLetterIndexName = deadLetterIndexName; } options.FormatProvider = formatProvider; options.FailureSink = failureSink; options.Connection = connection; options.CustomFormatter = customFormatter; options.CustomDurableFormatter = customDurableFormatter; options.Serializer = serializer; options.TemplateCustomSettings = templateCustomSettings; return(Elasticsearch(loggerSinkConfiguration, options)); }
internal static string BulkAction(ElasticOpType elasticOpType) => elasticOpType == ElasticOpType.Create ? "create" : "index";