App-ElasticSearch-Utilities
view release on metacpan or search on metacpan
lib/App/ElasticSearch/Utilities.pm view on Meta::CPAN
use App::ElasticSearch::Utilities::Connection;
use App::ElasticSearch::Utilities::VersionHacks qw(_fix_version_request);
# Collectors
sub _copy_argv { $COPY_ARGV = 1 }
sub _preprocess_argv { $ARGV_AT_INIT = 1 }
sub _delay_argv { $ARGV_AT_INIT = 0 }
# Global Variables
our %_GLOBALS = ();
my %DEF = ();
my %PATTERN_REGEX = (
'*' => qr/.*/,
ANY => qr/.*/,
DATE => qr/
(?<datestr>
(?<year>\d{4}) # Extract 4 digits for the year
(?:(?<datesep>[\-.]))? # Optionally, look for . - as a separator
(?<month>\d{2}) # Two digits for the month
\g{datesep} # Whatever the date separator was in the previous match
(?<day>\d{2}) # Two digits for the day
(?![a-zA-Z0-9]) # Zero width negative look ahead, not alphanumeric
)
/x,
);
my $PATTERN;
{
## no critic (ProhibitNoWarnings)
no warnings;
INIT {
return if $_init_complete++;
es_utils_initialize() if $ARGV_AT_INIT;
}
## use critic
}
{
# Argument Parsing Block
my @argv_original = ();
my $parsed_argv = 0;
sub _parse_options {
my ($opt_ref) = @_;
my @opt_spec = qw(
local
host=s
port=i
timeout=i
keep-proxy
index=s
pattern=s
base|index-basename=s
days=i
noop!
proto=s
http-username=s
password-exec=s
master-only|M
insecure
capath=s
cacert=s
cert=s
key=s
);
my $argv;
my %opt;
if( defined $opt_ref && is_arrayref($opt_ref) ) {
# If passed an argv array, use that
$argv = $COPY_ARGV ? [ @{ $opt_ref } ] : $opt_ref;
}
else {
# Ensure multiple calls to cli_helpers_initialize() yield the same results
if ( $parsed_argv ) {
## no critic
@ARGV = @argv_original;
## use critic
}
else {
@argv_original = @ARGV;
$parsed_argv++;
}
# Operate on @ARGV
$argv = $COPY_ARGV ? [ @ARGV ] : \@ARGV;
}
GetOptionsFromArray($argv, \%opt, @opt_spec );
return \%opt;
}
}
sub es_utils_initialize {
my ($argv) = @_;
# Parse Options
my $opts = _parse_options($argv);
# Config file locations
my @configs = (
'/etc/es-utils.yaml',
'/etc/es-utils.yml',
);
if( $ENV{HOME} ) {
push @configs, map { "$ENV{HOME}/.es-utils.$_" } qw( yaml yml );
my $xdg_config_home = $ENV{XDG_CONFIG_HOME} || "$ENV{HOME}/.config";
push @configs, map { "${xdg_config_home}/es-utils/config.$_" } qw( yaml yml );
}
my @ConfigData=();
foreach my $config_file (@configs) {
next unless -f $config_file;
debug("Loading options from $config_file");
eval {
my $ref = YAML::XS::LoadFile($config_file);
push @ConfigData, $ref;
debug_var($ref);
1;
} or do {
debug({color=>"red"}, "[$config_file] $@");
};
}
%_GLOBALS = @ConfigData ? %{ clone_merge(@ConfigData) } : ();
# Set defaults
%DEF = (
# Connection Options
HOST => exists $opts->{host} ? $opts->{host}
: exists $opts->{local} ? 'localhost'
: exists $_GLOBALS{host} ? $_GLOBALS{host}
: 'localhost',
PORT => exists $opts->{port} ? $opts->{port}
: exists $_GLOBALS{port} ? $_GLOBALS{port}
: 9200,
PROTO => exists $opts->{proto} ? $opts->{proto}
: exists $_GLOBALS{proto} ? $_GLOBALS{proto}
: 'http',
TIMEOUT => exists $opts->{timeout} ? $opts->{timeout}
: exists $_GLOBALS{timeout} ? $_GLOBALS{timeout}
: 10,
NOOP => exists $opts->{noop} ? $opts->{noop}
: exists $_GLOBALS{noop} ? $_GLOBALS{noop}
: undef,
NOPROXY => exists $opts->{'keep-proxy'} ? 0
: exists $_GLOBALS{'keep-proxy'} ? $_GLOBALS{'keep-proxy'}
: 1,
MASTERONLY => exists $opts->{'master-only'} ? $opts->{'master-only'} : 0,
# Index selection opts->ions
INDEX => exists $opts->{index} ? $opts->{index} : undef,
BASE => exists $opts->{base} ? lc $opts->{base}
: exists $_GLOBALS{base} ? $_GLOBALS{base}
: undef,
PATTERN => exists $opts->{pattern} ? $opts->{pattern} : '*',
DAYS => exists $opts->{days} ? $opts->{days}
: exists $_GLOBALS{days} ? $_GLOBALS{days} : 1,
# HTTP Basic Authentication
USERNAME => exists $opts->{'http-username'} ? $opts->{'http-username'}
: exists $_GLOBALS{'http-username'} ? $_GLOBALS{'http-username'}
: $ENV{USER},
PASSEXEC => exists $opts->{'password-exec'} ? $opts->{'password-exec'}
: exists $_GLOBALS{'password-exec'} ? $_GLOBALS{'password-exec'}
: undef,
# TLS Options
INSECURE => exists $opts->{insecure} ? 1
: exists $_GLOBALS{insecure} ? $_GLOBALS{insecure}
: 0,
CACERT => exists $opts->{cacert} ? 1
: exists $_GLOBALS{cacert} ? $_GLOBALS{cacert}
: undef,
CAPATH => exists $opts->{capath} ? 1
: exists $_GLOBALS{capath} ? $_GLOBALS{capath}
: undef,
CERT => exists $opts->{cert} ? 1
: exists $_GLOBALS{cert} ? $_GLOBALS{cert}
: undef,
KEY => exists $opts->{key} ? 1
: exists $_GLOBALS{key} ? $_GLOBALS{key}
: undef,
);
CLI::Helpers::override(verbose => 1) if $DEF{NOOP};
if( $DEF{NOPROXY} ) {
debug("Removing any active HTTP Proxies from ENV.");
delete $ENV{$_} for qw(http_proxy HTTP_PROXY);
}
# Build the Index Pattern
$PATTERN = $DEF{PATTERN};
my @ordered = qw(* DATE ANY);
foreach my $literal ( @ordered ) {
$PATTERN =~ s/\Q$literal\E/$PATTERN_REGEX{$literal}/g;
}
}
# Regexes for Pattern Expansion
our $CURRENT_VERSION;
my $CLUSTER_MASTER;
sub es_globals {
my ($key) = @_;
es_utils_initialize() unless keys %DEF;
return unless exists $_GLOBALS{$key};
return $_GLOBALS{$key};
}
my %_auth_cache = ();
sub es_basic_auth {
my ($host) = @_;
es_utils_initialize() unless keys %DEF;
$host ||= $DEF{HOST};
# Return the results if we've done this already
return @{ $_auth_cache{$host} }{qw(username password)}
if exists $_auth_cache{$host};
# Set the cached element
my %auth = ();
# Lookup the details netrc
my $netrc = Net::Netrc->lookup($host);
if( $DEF{HOST} eq $host ) {
%auth = map { lc($_) => $DEF{$_} } qw(USERNAME);
}
my %meta = ();
foreach my $k (qw( http-username password-exec )) {
foreach my $name ( $DEF{INDEX}, $DEF{BASE} ) {
next unless $name;
if( my $v = es_local_index_meta($k, $name) ) {
$meta{$k} = $v;
last;
}
}
}
# Get the Username
$auth{username} ||= $meta{'http-username'} ? $meta{'http-username'}
: defined $DEF{USERNAME} ? $DEF{USERNAME}
: defined $netrc ? $netrc->login
: $ENV{USER};
# Prompt for the password
$auth{password} ||= defined $netrc ? $netrc->password
: (es_pass_exec($host,$auth{username},$meta{'password-exec'})
|| prompt(sprintf "Password for '%s' at '%s': ", $auth{username}, $host)
);
# Store
$_auth_cache{$host} = \%auth;
return @auth{qw(username password)};
}
sub es_pass_exec {
my ($host,$username,$exec) = @_;
es_utils_initialize() unless keys %DEF;
# Simplest case we can't run
$exec ||= $DEF{PASSEXEC};
return unless length $exec && -x $exec;
my(@out,@err);
# Run the password command captue out, error and RC
run3 [ $exec, $host, $username ], \undef, \@out, \@err;
my $rc = $?;
# Record the error
if( @err or $rc != 0 ) {
output({color=>'red',stderr=>1},
sprintf("es_pass_exec() called '%s' and met with an error code '%d'", $exec, $rc),
@err
);
return;
}
# Format and return the result
my $passwd = $out[-1];
chomp($passwd);
return $passwd;
}
sub es_pattern {
es_utils_initialize() unless keys %DEF;
return {
re => $PATTERN,
string => $DEF{PATTERN},
};
}
sub _get_ssl_opts {
es_utils_initialize() unless keys %DEF;
my %opts = ();
$opts{SSL_ca_file} = $DEF{CACERT} if $DEF{CACERT};
$opts{SSL_ca_path} = $DEF{CAPATH} if $DEF{CAPATH};
$opts{SSL_cert_file} = $DEF{CERT} if $DEF{CERT};
$opts{SSL_key_file} = $DEF{KEY} if $DEF{KEY};
# Disable Certificate Verification
if ( $DEF{INSECURE} ) {
$opts{verify_hostname} = 0;
$opts{SSL_verify_mode} = 0x00;
}
return \%opts;
}
sub _get_es_version {
return $CURRENT_VERSION if defined $CURRENT_VERSION;
my $conn = es_connect();
# Build the request
my $req = App::ElasticSearch::Utilities::HTTPRequest->new(
GET => sprintf "%s://%s:%d",
$conn->proto, $conn->host, $conn->port
);
# Check if we're doing auth
my @auth = $DEF{PASSEXEC} ? es_basic_auth($conn->host) : ();
# Add authentication if we get a password
$req->authorization_basic( @auth ) if @auth;
# Retry with TLS and/or Auth
my %try = map { $_ => 1 } qw( tls auth );
my $resp;
while( not defined $CURRENT_VERSION ) {
$resp = $conn->ua->request($req);
if( $resp->is_success ) {
my $ver;
eval {
$ver = $resp->content->{version};
};
if( $ver ) {
if( $ver->{distribution} and $ver->{distribution} eq 'opensearch' ) {
$CURRENT_VERSION = version->parse($ver->{minimum_wire_compatibility_version});
}
else {
$CURRENT_VERSION = version->parse($ver->{number});
}
}
}
elsif( $resp->code == 500 && $resp->message eq "Server closed connection without sending any data back" ) {
# Try TLS
last unless $try{tls};
delete $try{tls};
$conn->proto('https');
warn "Attempting promotion to HTTPS, try setting 'proto: https' in ~/.es-utils.yaml";
}
elsif( $resp->code == 401 ) {
# Retry with credentials
last unless $try{auth};
delete $try{auth};
warn "Authorization required, try setting 'password-exec: /home/user/bin/get-password.sh` in ~/.es-utils.yaml'"
unless $DEF{PASSEXEC};
$req->authorization_basic( es_basic_auth($conn->host) );
}
else {
warn "Failed getting version";
last;
}
}
if( !defined $CURRENT_VERSION || $CURRENT_VERSION <= 2 ) {
output({color=>'red',stderr=>1}, sprintf "[%d] Unable to determine Elasticsearch version, something has gone terribly wrong: aborting.", $resp->code);
output({color=>'red',stderr=>1}, ref $resp->content ? YAML::XS::Dump($resp->content) : $resp->content) if $resp->content;
exit 1;
}
debug({color=>'magenta'}, "FOUND VERISON '$CURRENT_VERSION'");
return $CURRENT_VERSION;
}
my $ES = undef;
sub es_connect {
my ($override_servers) = @_;
es_utils_initialize() unless keys %DEF;
my %conn = (
host => $DEF{HOST},
port => $DEF{PORT},
proto => $DEF{PROTO},
timeout => $DEF{TIMEOUT},
ssl_opts => _get_ssl_opts,
);
# Only authenticate over TLS
if( $DEF{PROTO} eq 'https' ) {
$conn{username} = $DEF{USERNAME};
$conn{password} = es_pass_exec(@DEF{qw(HOST USERNAME)}) if $DEF{PASSEXEC};
}
# If we're overriding, return a unique handle
if(defined $override_servers) {
my @overrides = is_arrayref($override_servers) ? @$override_servers : $override_servers;
my @servers;
foreach my $entry ( @overrides ) {
my ($s,$p) = split /\:/, $entry;
$p ||= $conn{port};
push @servers, { %conn, host => $s, port => $p };
}
if( @servers > 0 ) {
my $pick = @servers > 1 ? $servers[int(rand(@servers))] : $servers[0];
return App::ElasticSearch::Utilities::Connection->new(%{$pick});
}
}
else {
# Check for index metadata
foreach my $k ( keys %conn ) {
foreach my $name ( $DEF{INDEX}, $DEF{BASE} ) {
next unless $name;
if( my $v = es_local_index_meta($k => $name) ) {
$conn{$k} = $v;
last;
}
}
}
}
# Otherwise, cache our handle
$ES ||= App::ElasticSearch::Utilities::Connection->new(%conn);
return $ES;
}
sub es_master {
my ($instance) = @_;
if(!defined $instance && defined $CLUSTER_MASTER) {
return $CLUSTER_MASTER;
}
my $is_master = 0;
my @request = ('/_cluster/state/master_node');
unshift @request, $instance if defined $instance;
my $cluster = es_request(@request);
if( defined $cluster && $cluster->{master_node} ) {
my $local = es_request('/_nodes/_local');
if ($local->{nodes} && $local->{nodes}{$cluster->{master_node}}) {
$is_master = 1;
}
}
$CLUSTER_MASTER = $is_master unless defined $instance;
return $is_master;
}
sub es_request {
my $instance = ref $_[0] eq 'App::ElasticSearch::Utilities::Connection' ? shift @_ : es_connect();
lib/App/ElasticSearch/Utilities.pm view on Meta::CPAN
scripts/es-aggregate.pl - Utility to search and aggregate index contents
scripts/es-search.pl - Utility to search and explore index contents
=head2 MONITORING
scripts/es-graphite-dynamic.pl - Perform index maintenance on daily indexes
scripts/es-index-fields.pl - Collect and report on field statistics for indices
scripts/es-index-scan.pl - Scan for potential index issues
scripts/es-nodes.pl - View node information
scripts/es-status.pl - Command line utility for ES Metrics
scripts/es-storage-overview.pl - View how shards/data is aligned on your cluster
=head2 MAINTENANCE
scripts/es-alias-manager.pl - Manage index aliases automatically
scripts/es-daily-index-maintenance.pl - Perform index maintenance on daily indexes
scripts/es-index-blocks.pl - Report and fix any blocks on indices
scripts/es-open.pl - Open any closed indices matching a index parameters
=head2 MANAGEMENT
scripts/es-apply-settings.pl - Apply settings to all indexes matching a pattern
scripts/es-cluster-settings.pl - Manage cluster settings
scripts/es-copy-index.pl - Copy an index from one cluster to another
scripts/es-storage-overview.pl - View how shards/data is aligned on your cluster
The App::ElasticSearch::Utilities module simply serves as a wrapper around the scripts for packaging and
distribution.
=head2 USAGE
The tools are all wrapped in their own documentation, please see:
$UTILITY --help
$UTILITY --manual
For individual options and capabilities
=head2 PATTERNS
Patterns are used to match an index to the aliases it should have. A few symbols are expanded into
regular expressions. Those patterns are:
* expands to match any number of any characters.
DATE expands to match YYYY.MM.DD, YYYY-MM-DD, or YYYYMMDD
ANY expands to match any number of any characters.
=head1 CONFIG FILES
Some options may be specified in the B</etc/es-utils.yaml>, B<$HOME/.es-utils.yaml>
or B<$HOME/.config/es-utils/config.yaml> file:
---
base: logstash
days: 7
host: esproxy.example.com
port: 80
timeout: 10
proto: https
http-username: bob
password-exec: /home/bob/bin/get-es-passwd.sh
=head1 ARGS
From App::ElasticSearch::Utilities:
--local Use localhost as the elasticsearch host
--host ElasticSearch host to connect to
--port HTTP port for your cluster
--proto Defaults to 'http', can also be 'https'
--http-username HTTP Basic Auth username
--password-exec Script to run to get the users password
--insecure Don't verify TLS certificates
--cacert Specify the TLS CA file
--capath Specify the directory with TLS CAs
--cert Specify the path to the client certificate
--key Specify the path to the client private key file
--noop Any operations other than GET are disabled, can be negated with --no-noop
--timeout Timeout to ElasticSearch, default 10
--keep-proxy Do not remove any proxy settings from %ENV
--index Index to run commands against
--base For daily indexes, reference only those starting with "logstash"
(same as --pattern logstash-* or logstash-DATE)
--pattern Use a pattern to operate on the indexes
--days If using a pattern or base, how many days back to go, default: 1
See also the "CONNECTION ARGUMENTS" and "INDEX SELECTION ARGUMENTS" sections from App::ElasticSearch::Utilities.
=head1 CONNECTION ARGUMENTS
Arguments for establishing a connection with the cluster. Unless specified otherwise, these options
can all be set in the globals file.
=over
=item B<local>
Assume ElasticSearch is running locally, connect to localhost.
=item B<host>
Use a different hostname or IP address to connect.
=item B<port>
Defaults to 9200.
=item B<proto>
Defaults to 'http', can also be 'https'.
=item B<http-username>
If HTTP Basic Authentication is required, use this username.
See also the L<HTTP Basic Authentication> section for more details
=item B<password-exec>
If HTTP Basic Authentication is required, run this command, passing the arguments:
<command_to_run> <es_host> <es_username>
The script expects the last line to contain the password in plaintext.
=item B<noop>
Prevents any communication to the cluster from making changes to the settings or data contained therein.
In short, it prevents anything but HEAD and GET requests, B<except> POST requests to the _search endpoint.
=item B<timeout>
Timeout for connections and requests, defaults to 10.
=item B<keep-proxy>
By default, HTTP proxy environment variables are stripped. Use this option to keep your proxy environment variables
in tact.
=item B<insecure>
Don't verify TLS certificates
=item B<cacert>
Specify a file with the TLS CA certificates.
=item B<capath>
Specify a directory containing the TLS CA certificates.
=item B<cert>
Specify the path to the TLS client certificate file..
=item B<key>
Specify the path to the TLS client private key file.
=back
=head1 AUTHENTICATION
HTTP Basic Authorization is only supported when the C<proto> is set to B<https>
as not to leak credentials all over.
The username is selected by going through these mechanisms until one is found:
--http-username
'http-username' in /etc/es-utils.yml or ~/.es-utils.yml
Netrc element matching the hostname of the request
CLI::Helpers prompt()
Once the username has been resolved, the following mechanisms are tried in order:
Netrc element matching the hostname of the request
Password executable defined by --password-exec
'password-exec' in /etc/es-utils.yml, ~/.es-utils.yml
CLI::Helpers prompt()
=head2 Password Exec
It is B<BAD> practice to specify passwords as a command line argument, or store it in a plaintext
file. There are cases where this may be necessary, but it is not recommended. The best method for securing your
password is to use the B<password-exec> option.
This option must point to an executable script. That script will be passed two arguments, the hostname and the username
for the request. It expects the password printed to STDOUT as the last line of output. Here's an example password-exec setup
using Apple Keychain:
#!/bin/sh
HOSTNAME=$1;
USERNAME=$2;
/usr/bin/security find-generic-password -w -a "$USERNAME" -s "$HOSTNAME"
If we save this to "$HOME/bin/get-passwd.sh" we can execute a script
like this:
$ es-search.pl --http-username bob --password-exec $HOME/bin/get-passwd.sh \
--base secure-data --fields
Though it's probably best to set this in your ~/.es-utils.yml file:
---
host: secured-cluster.example.org
port: 443
proto: https
http-username: bob
password-exec: /home/bob/bin/get-passwd.sh
=head3 CLI::Helpers and Password Prompting
If all the fails to yield a password, the last resort is to use CLI::Helpers::prompt() to ask the user for their
password. If the user is using version 1.1 or higher of CLI::Helpers, this call will turn off echo and readline magic
for the password prompt.
=head1 INDEX SELECTION ARGUMENTS
=over
=item B<base>
In an environment using monthly, weekly, daily, or hourly indexes. The base index name is everything without the date.
Parsing for bases, also provides splitting and matching on segments of the index name delineated by the '-' character.
If we have the following indexes:
web-dc1-YYYY.MM.DD
web-dc2-YYYY.MM.DD
logstash-dc1-YYYY.MM.DD
logstash-dc2-YYYY.MM.DD
Valid bases would be:
web
web-dc1
web-dc2
logstash
logstash-dc1
logstash-dc2
dc1
dc2
Combining that with the days option can provide a way to select many indexes at once.
=item B<days>
How many days backwards you want your operation to be relevant.
=item B<datesep>
Default is '.' Can be set to an empty string for no separator.
=item B<pattern>
A pattern to match the indexes. Can expand the following key words and characters:
'*' expanded to '.*'
'ANY' expanded to '.*'
'DATE' expanded to a pattern to match a date,
The indexes are compared against this pattern.
=back
=head1 OVERVIEW
In addition to the scripts, the libraries provide a simplistic interface to
write your own scripts. It builds C<CLI::Helpers> to provide consistent options
for scripts.
use App::ElasticSearch::Utilities qw(:all);
use Data::Printer;
my $res = es_result('_cluster/health');
p($res)
lib/App/ElasticSearch/Utilities.pm view on Meta::CPAN
es_index_bases()
es_index_days_old()
es_index_fields()
es_index_shards()
es_index_segments()
es_index_stats()
es_index_strip_date()
es_index_valid()
=item B<:indices>
:default
es_indices_meta()
=item B<:maintenance>
:default
es_close_index()
es_open_index()
es_delete_index()
es_optimize_index()
es_apply_index_settings()
=item B<:all> - All exportable functions
:config
:default
:index
:indices
:human
:maintenance
es_basic_auth()
es_flatten_hash()
es_local_index_meta()
es_master()
es_nodes()
es_node_stats()
es_pattern()
es_settings()
es_segment_stats()
=back
=head2 Configuration
It is possible to control how and when C<@ARGV> is processed to prevent conflicts.
=head1 CONFIG FUNCTIONS
=head2 es_utils_initialize()
Takes an optional reference to an C<@ARGV> like array. Performs environment and
argument parsing.
=head2 es_globals($key)
Grab the value of the global value from the es-utils.yaml files.
=head2 es_basic_auth($host)
Get the user/password combination for this host. This is called from LWP::UserAgent if
it recieves a 401, so the auth condition must be satisfied.
Returns the username and password as a list.
=head1 CONNECTION FUNCTIONS
=head2 es_connect
Without options, this connects to the server defined in the args. If passed
an array ref, it will use that as the connection definition.
=head2 es_request([$handle],$command,{ method => 'GET', uri_param => { a => 1 } }, {})
Retrieve URL from ElasticSearch, returns a hash reference
First hash ref contains options, including:
uri_param Query String Parameters
index Index name
type Index type
method Default is GET
If the request is not successful, this function will throw a fatal exception.
If you'd like to proceed you need to catch that error.
=head1 INDEX FUNCTIONS
=head2 es_index_strip_date( 'index-name' )
Returns the index name with the date removed.
=head2 es_index_bases( 'index-name' )
Returns an array of the possible index base names for this index
=head2 es_index_days_old( 'index-name' )
Return the number of days old this index is.
=head2 es_index_shards( 'index-name' )
Returns the number of replicas for a given index.
=head2 es_index_valid( 'index-name' )
Checks if the specified index is valid
=head2 es_index_fields('index-name')
Returns a hash reference with the following data:
key_name:
type: field_data_type
# If the field is nested
nested_path: nested_path
nested_key: nested_key
=head2 es_index_segments( 'index-name' )
Exposes GET /$index/_segments
Returns the segment data from the index in hashref:
=head2 es_index_stats( 'index-name' )
Exposes GET /$index/_stats
Returns a hashref
=head1 INDICES FUNCTIONS
=head2 es_indices_meta
Returns the hash of index meta data.
=head1 MAINTENANCE FUNCTIONS
=head2 es_close_index('index-name')
Closes an index
=head2 es_open_index('index-name')
Open an index
=head2 es_delete_index('index-name')
Deletes an index
=head2 es_optimize_index('index-name')
Optimize an index to a single segment per shard
=head2 es_apply_index_settings('index-name', { settings })
Apply a HASH of settings to an index.
=head1 FORMAT FUNCTIONS
=head2 es_human_count
Takes a number and returns the number as a string in docs, thousands, millions, or billions.
1_000 -> "1.00 thousand",
1_000_000 -> "1.00 million",
=head2 es_human_size
Takes a number and returns the number as a string in bytes, Kb, Mb, Gb, or Tb using base 1024.
1024 -> '1.00 Kb',
1048576 -> '1.00 Mb',
1073741824 -> '1.00 Gb',
=head2 es_format_numeric
Takes a value and the minimum digits of significance.
=head1 FUNCTIONS
=head2 es_pass_exec(host, username)
Called from es_basic_auth to exec a program, capture the password
and return it to the caller. This allows the use of password vaults
and keychains.
=head2 es_pattern
Returns a hashref of the pattern filter used to get the indexes
{
string => '*',
re => '.*',
}
=head2 es_master([$handle])
Returns true (1) if the handle is to the the cluster master, or false (0) otherwise.
=head2 es_nodes
Returns the hash of index meta data.
=head2 es_indices
Returns a list of active indexes matching the filter criteria specified on the command
line. Can handle indices named:
logstash-YYYY.MM.DD
dcid-logstash-YYYY.MM.DD
logstash-dcid-YYYY.MM.DD
logstash-YYYY.MM.DD-dcid
Makes use of --datesep to determine where the date is.
Options include:
=over 4
=item B<state>
Default is 'open', can be used to find 'closed' indexes as well.
=item B<check_state>
Default is 1, set to 0 to disable state checks. The combination of the default
with this option and the default for B<state> means only open indices are returned.
=item B<check_dates>
Default is 1, set to 0 to disable checking index age.
=back
=head2 es_segment_stats($index)
Return the number of shards and segments in an index as a hashref
=head2 es_settings()
Exposes GET /_settings
Returns a hashref
=head2 es_node_stats()
( run in 0.868 second using v1.01-cache-2.11-cpan-df04353d9ac )