def get_connection(self):
connection_options = {
'database': self._db,
'host': self._server,
'port': self._port,
'user': self._username,
'password': self._password,
'backup_server_node': self._backup_servers,
'connection_load_balance': self._connection_load_balance,
'connection_timeout': self._timeout,
}
if self._client_lib_log_level:
connection_options['log_level'] = self._client_lib_log_level
# log_path is required by vertica client for using logging
# when log_path is set to '', vertica won't log to a file
# but we still get logs via parent root logger
connection_options['log_path'] = ''
if self._use_tls:
tls_context = self.get_tls_context()
connection_options['ssl'] = tls_context
try:
connection = vertica.connect(**exclude_undefined_keys(connection_options))
except Exception as e:
self.log.error('Unable to connect to database `%s` as user `%s`: %s', self._db, self._username, e)
self.service_check(self.SERVICE_CHECK_CONNECT, self.CRITICAL, tags=self._tags)
else:
self.service_check(self.SERVICE_CHECK_CONNECT, self.OK, tags=self._tags)
return connection
def test_query_construction(new_check, instance, filters, query):
instance['filters'] = filters
check = new_check(instance)
check.load_configuration_models()
assert construct_xpath_query(
exclude_undefined_keys(check.config.filters.dict())) == query
def construct_query(self):
query = self.config.query
if query:
self._query = query
return
self._query = construct_xpath_query(
exclude_undefined_keys(self.config.filters.dict()))
self.log.debug('Using constructed query: %s', self._query)
def version_metadata():
if '-' in ELASTIC_VERSION:
base, release = ELASTIC_VERSION.split('-')
parts = base.split('.')
else:
release = None
parts = ELASTIC_VERSION.split('.')
major = parts[0]
minor = parts[1] if len(parts) > 1 else mock.ANY
patch = parts[2] if len(parts) > 2 else mock.ANY
return exclude_undefined_keys({
'version.scheme': 'semver',
'version.major': major,
'version.minor': minor,
'version.patch': patch,
'version.raw': mock.ANY,
'version.release': release,
})
def __init__(self, name, init_config, instances=None):
super(MongoDb, self).__init__(name, init_config, instances)
# x.509 authentication
self.ssl_params = exclude_undefined_keys({
'ssl':
self.instance.get('ssl', None),
'ssl_keyfile':
self.instance.get('ssl_keyfile', None),
'ssl_certfile':
self.instance.get('ssl_certfile', None),
'ssl_cert_reqs':
self.instance.get('ssl_cert_reqs', None),
'ssl_ca_certs':
self.instance.get('ssl_ca_certs', None),
})
if 'server' in self.instance:
self.warning(
'Option `server` is deprecated and will be removed in a future release. Use `hosts` instead.'
)
self.server = self.instance['server']
else:
hosts = self.instance.get('hosts', [])
if not hosts:
raise ConfigurationError('No `hosts` specified')
username = self.instance.get('username')
password = self.instance.get('password')
if password and not username:
raise ConfigurationError(
'`username` must be set when a `password` is specified')
self.server = build_connection_string(
hosts,
scheme=self.instance.get('connection_scheme', 'mongodb'),
username=username,
password=password,
database=self.instance.get('database'),
options=self.instance.get('options'),
)
(
self.username,
self.password,
self.db_name,
self.nodelist,
self.clean_server_name,
self.auth_source,
) = parse_mongo_uri(self.server,
sanitize_username=bool(self.ssl_params))
self.additional_metrics = self.instance.get('additional_metrics', [])
# Get the list of metrics to collect
self.collect_tcmalloc_metrics = 'tcmalloc' in self.additional_metrics
self.metrics_to_collect = self._build_metric_list_to_collect()
if not self.db_name:
self.log.info(
'No MongoDB database found in URI. Defaulting to admin.')
self.db_name = 'admin'
# Tagging
custom_tags = list(set(self.instance.get('tags', [])))
self.service_check_tags = ["db:%s" % self.db_name] + custom_tags
# ...add the `server` tag to the metrics' tags only
# (it's added in the backend for service checks)
self.base_tags = custom_tags + ['server:%s' % self.clean_server_name]
if self.nodelist:
host = self.nodelist[0][0]
port = self.nodelist[0][1]
self.service_check_tags = self.service_check_tags + [
"host:%s" % host, "port:%s" % port
]
self.timeout = float(self.instance.get('timeout',
DEFAULT_TIMEOUT)) * 1000
# Authenticate
self.do_auth = True
self.use_x509 = self.ssl_params and not self.password
if not self.username:
self.log.debug(u"A username is required to authenticate to `%s`",
self.server)
self.do_auth = False
self.replica_check = is_affirmative(
self.instance.get('replica_check', True))
self.collections_indexes_stats = is_affirmative(
self.instance.get('collections_indexes_stats'))
self.coll_names = self.instance.get('collections', [])
self.custom_queries = self.instance.get("custom_queries", [])
# By default consider that this instance is a standalone, updated on each check run.
self.deployment = StandaloneDeployment()
self.collectors = []
self.last_states_by_server = {}
def __init__(self, instance, log):
self.log = log
# x.509 authentication
self.ssl_params = exclude_undefined_keys({
'ssl':
instance.get('ssl', None),
'ssl_keyfile':
instance.get('ssl_keyfile', None),
'ssl_certfile':
instance.get('ssl_certfile', None),
'ssl_cert_reqs':
instance.get('ssl_cert_reqs', None),
'ssl_ca_certs':
instance.get('ssl_ca_certs', None),
})
if 'server' in instance:
self.server = instance['server']
(
self.username,
self.password,
self.db_name,
self.hosts,
_,
self.auth_source,
) = parse_mongo_uri(self.server,
sanitize_username=bool(self.ssl_params))
self.scheme = None
self.additional_options = {}
self.hosts = ["%s:%s" % (host[0], host[1]) for host in self.hosts]
else:
self.server = None
self.hosts = instance.get('hosts', [])
self.username = instance.get('username')
self.password = instance.get('password')
# Deprecated
self.scheme = instance.get('connection_scheme', 'mongodb')
self.db_name = instance.get('database')
self.additional_options = instance.get('options', {})
self.auth_source = self.additional_options.get(
'authSource') or self.db_name or 'admin'
if not self.hosts:
raise ConfigurationError('No `hosts` specified')
self.clean_server_name = self._get_clean_server_name()
if self.password and not self.username:
raise ConfigurationError(
'`username` must be set when a `password` is specified')
if self.scheme != 'mongodb':
self.log.info(
"connection_scheme is deprecated and shouldn't be set to a value other than 'mongodb'"
)
if not self.db_name:
self.log.info(
'No MongoDB database found in URI. Defaulting to admin.')
self.db_name = 'admin'
self.timeout = float(instance.get('timeout', DEFAULT_TIMEOUT)) * 1000
self.additional_metrics = instance.get('additional_metrics', [])
# Authenticate
self.do_auth = True
self.use_x509 = self.ssl_params and not self.password
if not self.username:
self.log.info(
"Disabling authentication because a username was not provided."
)
self.do_auth = False
self.replica_check = is_affirmative(instance.get(
'replica_check', True))
self.collections_indexes_stats = is_affirmative(
instance.get('collections_indexes_stats'))
self.coll_names = instance.get('collections', [])
self.custom_queries = instance.get("custom_queries", [])
self._base_tags = list(set(instance.get('tags', [])))
self.service_check_tags = self._compute_service_check_tags()
self.metric_tags = self._compute_metric_tags()
