def load_check(name, config, agentConfig):
checksd_path = get_checksd_path(getOS())
if checksd_path not in sys.path:
sys.path.append(checksd_path)
check_module = __import__(name)
check_class = None
classes = inspect.getmembers(check_module, inspect.isclass)
for name, clsmember in classes:
if clsmember == AgentCheck:
continue
if issubclass(clsmember, AgentCheck):
check_class = clsmember
if AgentCheck in clsmember.__bases__:
continue
else:
break
if check_class is None:
raise Exception(
"Unable to import check %s. Missing a class that inherits AgentCheck"
% name)
init_config = config.get('init_config', None)
# init the check class
return check_class(name, init_config=init_config, agentConfig=agentConfig)
def load_check(name, config, agentConfig):
checksd_path = get_checksd_path(getOS())
if checksd_path not in sys.path:
sys.path.append(checksd_path)
check_module = __import__(name)
check_class = None
classes = inspect.getmembers(check_module, inspect.isclass)
for name, clsmember in classes:
if clsmember == AgentCheck:
continue
if issubclass(clsmember, AgentCheck):
check_class = clsmember
if AgentCheck in clsmember.__bases__:
continue
else:
break
if check_class is None:
raise Exception("Unable to import check %s. Missing a class that inherits AgentCheck" % name)
init_config = config.get('init_config', None)
instances = config.get('instances')
# init the check class
try:
return check_class(name, init_config=init_config, agentConfig=agentConfig, instances=instances)
except:
# Backwards compatitiblity for old checks that don't support the
# instances argument.
c = check_class(name, init_config=init_config, agentConfig=agentConfig)
c.instances = instances
return c
def kill_subprocess(process_obj):
try:
process_obj.terminate()
except AttributeError:
# py < 2.6 doesn't support process.terminate()
if getOS() == 'windows':
import ctypes
PROCESS_TERMINATE = 1
handle = ctypes.windll.kernel32.OpenProcess(PROCESS_TERMINATE, False,
process_obj.pid)
ctypes.windll.kernel32.TerminateProcess(handle, -1)
ctypes.windll.kernel32.CloseHandle(handle)
else:
os.kill(process_obj.pid, signal.SIGKILL)
def kill_subprocess(process_obj):
try:
process_obj.terminate()
except AttributeError:
# py < 2.6 doesn't support process.terminate()
if getOS() == 'windows':
import ctypes
PROCESS_TERMINATE = 1
handle = ctypes.windll.kernel32.OpenProcess(
PROCESS_TERMINATE, False, process_obj.pid)
ctypes.windll.kernel32.TerminateProcess(handle, -1)
ctypes.windll.kernel32.CloseHandle(handle)
else:
os.kill(process_obj.pid, signal.SIGKILL)
def get_check(name, config_str):
checksd_path = get_checksd_path(getOS())
if checksd_path not in sys.path:
sys.path.append(checksd_path)
check_module = __import__(name)
check_class = None
classes = inspect.getmembers(check_module, inspect.isclass)
for name, clsmember in classes:
if AgentCheck in clsmember.__bases__:
check_class = clsmember
break
if check_class is None:
raise Exception("Unable to import check %s. Missing a class that inherits AgentCheck" % name)
return check_class.from_yaml(yaml_text=config_str, check_name=name)
def get_check(name, config_str):
checksd_path = get_checksd_path(getOS())
if checksd_path not in sys.path:
sys.path.append(checksd_path)
check_module = __import__(name)
check_class = None
classes = inspect.getmembers(check_module, inspect.isclass)
for name, clsmember in classes:
if AgentCheck in clsmember.__bases__:
check_class = clsmember
break
if check_class is None:
raise Exception(
"Unable to import check %s. Missing a class that inherits AgentCheck"
% name)
agentConfig = {'version': '0.1', 'api_key': 'tota'}
return check_class.from_yaml(yaml_text=config_str,
check_name=name,
agentConfig=agentConfig)
def load_check(name, config, agentConfig):
checksd_path = get_checksd_path(getOS())
if checksd_path not in sys.path:
sys.path.append(checksd_path)
check_module = __import__(name)
check_class = None
classes = inspect.getmembers(check_module, inspect.isclass)
for name, clsmember in classes:
if clsmember == AgentCheck:
continue
if issubclass(clsmember, AgentCheck):
check_class = clsmember
if AgentCheck in clsmember.__bases__:
continue
else:
break
if check_class is None:
raise Exception(
"Unable to import check %s. Missing a class that inherits AgentCheck"
% name)
init_config = config.get('init_config', None)
instances = config.get('instances')
# init the check class
try:
return check_class(name,
init_config=init_config,
agentConfig=agentConfig,
instances=instances)
except:
# Backwards compatitiblity for old checks that don't support the
# instances argument.
c = check_class(name, init_config=init_config, agentConfig=agentConfig)
c.instances = instances
return c
def load_check(name, config, agentConfig):
checksd_path = get_checksd_path(getOS())
if checksd_path not in sys.path:
sys.path.append(checksd_path)
check_module = __import__(name)
check_class = None
classes = inspect.getmembers(check_module, inspect.isclass)
for name, clsmember in classes:
if clsmember == AgentCheck:
continue
if issubclass(clsmember, AgentCheck):
check_class = clsmember
if AgentCheck in clsmember.__bases__:
continue
else:
break
if check_class is None:
raise Exception("Unable to import check %s. Missing a class that inherits AgentCheck" % name)
init_config = config.get('init_config', None)
# init the check class
return check_class(name, init_config=init_config, agentConfig=agentConfig)
def load_check_directory(agentConfig):
''' Return the checks from checks.d. Only checks that have a configuration
file in conf.d will be returned. '''
from util import yaml, yLoader
from checks import AgentCheck
checks = []
log = logging.getLogger('checks')
osname = getOS()
checks_path = get_checksd_path(osname)
confd_path = get_confd_path(osname)
check_glob = os.path.join(checks_path, '*.py')
# Update the python path before the import
sys.path.append(checks_path)
# For backwards-compatability with old style checks, we have to load every
# checks.d module and check for a corresponding config OR check if the old
# config will "activate" the check.
#
# Once old-style checks aren't supported, we'll just read the configs and
# import the corresponding check module
for check in glob.glob(check_glob):
check_name = os.path.basename(check).split('.')[0]
try:
check_module = __import__(check_name)
except:
log.exception('Unable to import check module %s.py from checks.d' % check_name)
continue
check_class = None
classes = inspect.getmembers(check_module, inspect.isclass)
for name, clsmember in classes:
if clsmember == AgentCheck:
continue
if issubclass(clsmember, AgentCheck):
check_class = clsmember
if AgentCheck in clsmember.__bases__:
continue
else:
break
if not check_class:
log.error('No check class (inheriting from AgentCheck) found in %s.py' % check_name)
continue
# Check if the config exists OR we match the old-style config
conf_path = os.path.join(confd_path, '%s.yaml' % check_name)
if os.path.exists(conf_path):
f = open(conf_path)
try:
check_config = yaml.load(f.read(), Loader=yLoader)
assert check_config is not None
f.close()
except:
f.close()
log.exception("Unable to parse yaml config in %s" % conf_path)
continue
elif hasattr(check_class, 'parse_agent_config'):
# FIXME: Remove this check once all old-style checks are gone
try:
check_config = check_class.parse_agent_config(agentConfig)
except Exception, e:
continue
if not check_config:
continue
d = [
"Configuring %s in datadog.conf is deprecated." % (check_name),
"Please use conf.d. In a future release, support for the",
"old style of configuration will be dropped.",
]
log.warn(" ".join(d))
else:
log.debug('No conf.d/%s.yaml found for checks.d/%s.py' % (check_name, check_name))
continue
# Look for the per-check config, which *must* exist
if not check_config.get('instances'):
log.error("Config %s is missing 'instances'" % conf_path)
continue
# Accept instances as a list, as a single dict, or as non-existant
instances = check_config.get('instances', {})
if type(instances) != type([]):
instances = [instances]
# Init all of the check's classes with
init_config = check_config.get('init_config', {})
# init_config: in the configuration triggers init_config to be defined
# to None.
if init_config is None:
init_config = {}
instances = check_config['instances']
try:
c = check_class(check_name, init_config=init_config,
agentConfig=agentConfig, instances=instances)
except TypeError, e:
# Backwards compatibility for checks which don't support the
# instances argument in the constructor.
c = check_class(check_name, init_config=init_config,
agentConfig=agentConfig)
c.instances = instances
def get_config(parse_args = True, cfg_path=None, init_logging=False, options=None):
if parse_args:
options, args = get_parsed_args()
elif not options:
args = None
# General config
agentConfig = {
'check_freq': DEFAULT_CHECK_FREQUENCY,
'debug_mode': False,
'dogstatsd_interval': DEFAULT_STATSD_FREQUENCY,
'dogstatsd_normalize': 'yes',
'dogstatsd_port': 8125,
'dogstatsd_target': 'http://localhost:17123',
'graphite_listen_port': None,
'hostname': None,
'listen_port': None,
'tags': None,
'use_ec2_instance_id': False, # DEPRECATED
'version': get_version(),
'watchdog': True,
}
dogstatsd_interval = DEFAULT_STATSD_FREQUENCY
# Config handling
try:
# Find the right config file
path = os.path.realpath(__file__)
path = os.path.dirname(path)
config_path = get_config_path(cfg_path, os_name=getOS())
config = ConfigParser.ConfigParser()
config.readfp(skip_leading_wsp(open(config_path)))
if init_logging:
initialize_logging(config_path, os_name=getOS())
# bulk import
for option in config.options('Main'):
agentConfig[option] = config.get('Main', option)
#
# Core config
#
# FIXME unnecessarily complex
if config.has_option('Main', 'use_dd'):
agentConfig['use_dd'] = config.get('Main', 'use_dd').lower() in ("yes", "true")
else:
agentConfig['use_dd'] = True
if options is not None and options.use_forwarder:
listen_port = 17123
if config.has_option('Main', 'listen_port'):
listen_port = int(config.get('Main', 'listen_port'))
agentConfig['dd_url'] = "http://localhost:" + str(listen_port)
elif options is not None and not options.disable_dd and options.dd_url:
agentConfig['dd_url'] = options.dd_url
else:
agentConfig['dd_url'] = config.get('Main', 'dd_url')
if agentConfig['dd_url'].endswith('/'):
agentConfig['dd_url'] = agentConfig['dd_url'][:-1]
# Whether also to send to Pup
if config.has_option('Main', 'use_pup'):
agentConfig['use_pup'] = config.get('Main', 'use_pup').lower() in ("yes", "true")
else:
agentConfig['use_pup'] = True
if agentConfig['use_pup']:
if config.has_option('Main', 'pup_url'):
agentConfig['pup_url'] = config.get('Main', 'pup_url')
else:
agentConfig['pup_url'] = 'http://localhost:17125'
pup_port = 17125
if config.has_option('Main', 'pup_port'):
agentConfig['pup_port'] = int(config.get('Main', 'pup_port'))
# Increases the frequency of statsd metrics when only sending to Pup
if not agentConfig['use_dd'] and agentConfig['use_pup']:
dogstatsd_interval = PUP_STATSD_FREQUENCY
if not agentConfig['use_dd'] and not agentConfig['use_pup']:
sys.stderr.write("Please specify at least one endpoint to send metrics to. This can be done in datadog.conf.")
exit(2)
# Which API key to use
agentConfig['api_key'] = config.get('Main', 'api_key')
# Debug mode
agentConfig['debug_mode'] = config.get('Main', 'debug_mode').lower() in ("yes", "true")
# local traffic only? Default to no
agentConfig['non_local_traffic'] = False
if config.has_option('Main', 'non_local_traffic'):
agentConfig['non_local_traffic'] = config.get('Main', 'non_local_traffic').lower() in ("yes", "true")
# DEPRECATED
if config.has_option('Main', 'use_ec2_instance_id'):
use_ec2_instance_id = config.get('Main', 'use_ec2_instance_id')
# translate yes into True, the rest into False
agentConfig['use_ec2_instance_id'] = (use_ec2_instance_id.lower() == 'yes')
if config.has_option('Main', 'check_freq'):
try:
agentConfig['check_freq'] = int(config.get('Main', 'check_freq'))
except:
pass
# Disable Watchdog (optionally)
if config.has_option('Main', 'watchdog'):
if config.get('Main', 'watchdog').lower() in ('no', 'false'):
agentConfig['watchdog'] = False
# Optional graphite listener
if config.has_option('Main','graphite_listen_port'):
agentConfig['graphite_listen_port'] = int(config.get('Main','graphite_listen_port'))
else:
agentConfig['graphite_listen_port'] = None
# Dogstatsd config
dogstatsd_defaults = {
'dogstatsd_port' : 8125,
'dogstatsd_target' : 'http://localhost:17123',
'dogstatsd_interval' : dogstatsd_interval,
'dogstatsd_normalize' : 'yes',
}
for key, value in dogstatsd_defaults.iteritems():
if config.has_option('Main', key):
agentConfig[key] = config.get('Main', key)
else:
agentConfig[key] = value
# normalize 'yes'/'no' to boolean
dogstatsd_defaults['dogstatsd_normalize'] = _is_affirmative(dogstatsd_defaults['dogstatsd_normalize'])
# optionally send dogstatsd data directly to the agent.
if config.has_option('Main', 'dogstatsd_use_ddurl'):
use_ddurl = _is_affirmative(config.get('Main', 'dogstatsd_use_ddurl'))
if use_ddurl:
agentConfig['dogstatsd_target'] = agentConfig['dd_url']
# Optional config
# FIXME not the prettiest code ever...
if config.has_option('Main', 'use_mount'):
agentConfig['use_mount'] = config.get('Main', 'use_mount').lower() in ("yes", "true", "1")
if config.has_option('datadog', 'ddforwarder_log'):
agentConfig['has_datadog'] = True
# Dogstream config
if config.has_option("Main", "dogstream_log"):
# Older version, single log support
log_path = config.get("Main", "dogstream_log")
if config.has_option("Main", "dogstream_line_parser"):
agentConfig["dogstreams"] = ':'.join([log_path, config.get("Main", "dogstream_line_parser")])
else:
agentConfig["dogstreams"] = log_path
elif config.has_option("Main", "dogstreams"):
agentConfig["dogstreams"] = config.get("Main", "dogstreams")
if config.has_option("Main", "nagios_perf_cfg"):
agentConfig["nagios_perf_cfg"] = config.get("Main", "nagios_perf_cfg")
if config.has_section('WMI'):
agentConfig['WMI'] = {}
for key, value in config.items('WMI'):
agentConfig['WMI'][key] = value
except ConfigParser.NoSectionError, e:
sys.stderr.write('Config file not found or incorrectly formatted.\n')
sys.exit(2)
def get_config(parse_args=True,
cfg_path=None,
init_logging=False,
options=None):
if parse_args:
options, args = get_parsed_args()
elif not options:
args = None
# General config
agentConfig = {
'check_freq': DEFAULT_CHECK_FREQUENCY,
'debug_mode': False,
'dogstatsd_interval': DEFAULT_STATSD_FREQUENCY,
'dogstatsd_normalize': 'yes',
'dogstatsd_port': 8125,
'dogstatsd_target': 'http://localhost:17123',
'graphite_listen_port': None,
'hostname': None,
'listen_port': None,
'tags': None,
'use_ec2_instance_id': False, # DEPRECATED
'version': get_version(),
'watchdog': True,
}
dogstatsd_interval = DEFAULT_STATSD_FREQUENCY
# Config handling
try:
# Find the right config file
path = os.path.realpath(__file__)
path = os.path.dirname(path)
config_path = get_config_path(cfg_path, os_name=getOS())
config = ConfigParser.ConfigParser()
config.readfp(skip_leading_wsp(open(config_path)))
if init_logging:
initialize_logging(config_path, os_name=getOS())
# bulk import
for option in config.options('Main'):
agentConfig[option] = config.get('Main', option)
#
# Core config
#
if config.has_option('Main', 'use_dd'):
agentConfig['use_dd'] = config.get('Main',
'use_dd').lower() in ("yes",
"true")
else:
agentConfig['use_dd'] = True
if options is not None and options.use_forwarder:
listen_port = 17123
if config.has_option('Main', 'listen_port'):
listen_port = config.get('Main', 'listen_port')
agentConfig['dd_url'] = "http://localhost:" + str(listen_port)
elif options is not None and not options.disable_dd and options.dd_url:
agentConfig['dd_url'] = options.dd_url
else:
agentConfig['dd_url'] = config.get('Main', 'dd_url')
if agentConfig['dd_url'].endswith('/'):
agentConfig['dd_url'] = agentConfig['dd_url'][:-1]
# Whether also to send to Pup
if config.has_option('Main', 'use_pup'):
agentConfig['use_pup'] = config.get('Main',
'use_pup').lower() in ("yes",
"true")
else:
agentConfig['use_pup'] = True
if agentConfig['use_pup']:
if config.has_option('Main', 'pup_url'):
agentConfig['pup_url'] = config.get('Main', 'pup_url')
else:
agentConfig['pup_url'] = 'http://localhost:17125'
pup_port = 17125
if config.has_option('Main', 'pup_port'):
agentConfig['pup_port'] = int(config.get('Main', 'pup_port'))
# Increases the frequency of statsd metrics when only sending to Pup
if not agentConfig['use_dd'] and agentConfig['use_pup']:
dogstatsd_interval = PUP_STATSD_FREQUENCY
if not agentConfig['use_dd'] and not agentConfig['use_pup']:
sys.stderr.write(
"Please specify at least one endpoint to send metrics to. This can be done in datadog.conf."
)
exit(2)
# Which API key to use
agentConfig['api_key'] = config.get('Main', 'api_key')
# Debug mode
agentConfig['debug_mode'] = config.get(
'Main', 'debug_mode').lower() in ("yes", "true")
# DEPRECATED
if config.has_option('Main', 'use_ec2_instance_id'):
use_ec2_instance_id = config.get('Main', 'use_ec2_instance_id')
# translate yes into True, the rest into False
agentConfig['use_ec2_instance_id'] = (
use_ec2_instance_id.lower() == 'yes')
if config.has_option('Main', 'check_freq'):
try:
agentConfig['check_freq'] = int(
config.get('Main', 'check_freq'))
except:
pass
# Disable Watchdog (optionally)
if config.has_option('Main', 'watchdog'):
if config.get('Main', 'watchdog').lower() in ('no', 'false'):
agentConfig['watchdog'] = False
# Optional graphite listener
if config.has_option('Main', 'graphite_listen_port'):
agentConfig['graphite_listen_port'] = int(
config.get('Main', 'graphite_listen_port'))
else:
agentConfig['graphite_listen_port'] = None
# Dogstatsd config
dogstatsd_defaults = {
'dogstatsd_port': 8125,
'dogstatsd_target': 'http://localhost:17123',
'dogstatsd_interval': dogstatsd_interval,
'dogstatsd_normalize': 'yes',
}
for key, value in dogstatsd_defaults.iteritems():
if config.has_option('Main', key):
agentConfig[key] = config.get('Main', key)
else:
agentConfig[key] = value
# normalize 'yes'/'no' to boolean
dogstatsd_defaults['dogstatsd_normalize'] = _is_affirmative(
dogstatsd_defaults['dogstatsd_normalize'])
# optionally send dogstatsd data directly to the agent.
if config.has_option('Main', 'dogstatsd_use_ddurl'):
use_ddurl = _is_affirmative(
config.get('Main', 'dogstatsd_use_ddurl'))
if use_ddurl:
agentConfig['dogstatsd_target'] = agentConfig['dd_url']
# Optional config
# FIXME not the prettiest code ever...
if config.has_option('Main', 'use_mount'):
agentConfig['use_mount'] = config.get(
'Main', 'use_mount').lower() in ("yes", "true", "1")
if config.has_option('datadog', 'ddforwarder_log'):
agentConfig['has_datadog'] = True
# Dogstream config
if config.has_option("Main", "dogstream_log"):
# Older version, single log support
log_path = config.get("Main", "dogstream_log")
if config.has_option("Main", "dogstream_line_parser"):
agentConfig["dogstreams"] = ':'.join(
[log_path,
config.get("Main", "dogstream_line_parser")])
else:
agentConfig["dogstreams"] = log_path
elif config.has_option("Main", "dogstreams"):
agentConfig["dogstreams"] = config.get("Main", "dogstreams")
if config.has_option("Main", "nagios_perf_cfg"):
agentConfig["nagios_perf_cfg"] = config.get(
"Main", "nagios_perf_cfg")
if config.has_section('WMI'):
agentConfig['WMI'] = {}
for key, value in config.items('WMI'):
agentConfig['WMI'][key] = value
except ConfigParser.NoSectionError, e:
sys.stderr.write('Config file not found or incorrectly formatted.\n')
sys.exit(2)
def load_check_directory(agentConfig):
''' Return the checks from checks.d. Only checks that have a configuration
file in conf.d will be returned. '''
from util import yaml, yLoader
from checks import AgentCheck
checks = []
log = logging.getLogger('checks')
osname = getOS()
checks_path = get_checksd_path(osname)
confd_path = get_confd_path(osname)
check_glob = os.path.join(checks_path, '*.py')
# Update the python path before the import
sys.path.append(checks_path)
# For backwards-compatability with old style checks, we have to load every
# checks.d module and check for a corresponding config OR check if the old
# config will "activate" the check.
#
# Once old-style checks aren't supported, we'll just read the configs and
# import the corresponding check module
for check in glob.glob(check_glob):
check_name = os.path.basename(check).split('.')[0]
try:
check_module = __import__(check_name)
except:
log.exception('Unable to import check module %s.py from checks.d' % check_name)
continue
check_class = None
classes = inspect.getmembers(check_module, inspect.isclass)
for name, clsmember in classes:
if clsmember == AgentCheck:
continue
if issubclass(clsmember, AgentCheck):
check_class = clsmember
if AgentCheck in clsmember.__bases__:
continue
else:
break
if not check_class:
log.error('No check class (inheriting from AgentCheck) found in %s.py' % check_name)
continue
# Check if the config exists OR we match the old-style config
conf_path = os.path.join(confd_path, '%s.yaml' % check_name)
if os.path.exists(conf_path):
f = open(conf_path)
try:
check_config = yaml.load(f.read(), Loader=yLoader)
assert check_config is not None
f.close()
except:
f.close()
log.exception("Unable to parse yaml config in %s" % conf_path)
continue
elif hasattr(check_class, 'parse_agent_config'):
# FIXME: Remove this check once all old-style checks are gone
check_config = check_class.parse_agent_config(agentConfig)
if not check_config:
continue
else:
log.debug('No conf.d/%s.yaml found for checks.d/%s.py' % (check_name, check_name))
continue
# Look for the per-check config, which *must* exist
if not check_config.get('instances'):
log.error("Config %s is missing 'instances'" % conf_path)
continue
# Accept instances as a list, as a single dict, or as non-existant
instances = check_config.get('instances', {})
if type(instances) != type([]):
instances = [instances]
# Init all of the check's classes with
init_config = check_config.get('init_config', {})
# init_config: in the configuration triggers init_config to be defined
# to None.
if init_config is None:
init_config = {}
init_config['instances_number'] = len(instances)
check_class = check_class(check_name, init_config=init_config,
agentConfig=agentConfig)
# Add custom pythonpath(s) if available
if 'pythonpath' in check_config:
pythonpath = check_config['pythonpath']
if not isinstance(pythonpath, list):
pythonpath = [pythonpath]
sys.path.extend(pythonpath)
log.debug('Loaded check.d/%s.py' % check_name)
checks.append({
'name': check_name,
'instances': check_config['instances'],
'class': check_class
})
log.info('checks.d checks: %s' % [c['name'] for c in checks])
return checks
def get_config(parse_args=True, cfg_path=None, init_logging=False, options=None):
if parse_args:
options, args = get_parsed_args()
elif not options:
args = None
# General config
agentConfig = {
"check_freq": DEFAULT_CHECK_FREQUENCY,
"debug_mode": False,
"dogstatsd_interval": DEFAULT_STATSD_FREQUENCY,
"dogstatsd_normalize": "yes",
"dogstatsd_port": 8125,
"dogstatsd_target": "http://localhost:17123",
"graphite_listen_port": None,
"hostname": None,
"listen_port": None,
"tags": None,
"use_ec2_instance_id": False, # DEPRECATED
"version": get_version(),
"watchdog": True,
}
dogstatsd_interval = DEFAULT_STATSD_FREQUENCY
# Config handling
try:
# Find the right config file
path = os.path.realpath(__file__)
path = os.path.dirname(path)
config_path = get_config_path(cfg_path, os_name=getOS())
config = ConfigParser.ConfigParser()
config.readfp(skip_leading_wsp(open(config_path)))
if init_logging:
initialize_logging(config_path, os_name=getOS())
# bulk import
for option in config.options("Main"):
agentConfig[option] = config.get("Main", option)
#
# Core config
#
# FIXME unnecessarily complex
if config.has_option("Main", "use_dd"):
agentConfig["use_dd"] = config.get("Main", "use_dd").lower() in ("yes", "true")
else:
agentConfig["use_dd"] = True
if options is not None and options.use_forwarder:
listen_port = 17123
if config.has_option("Main", "listen_port"):
listen_port = int(config.get("Main", "listen_port"))
agentConfig["dd_url"] = "http://localhost:" + str(listen_port)
elif options is not None and not options.disable_dd and options.dd_url:
agentConfig["dd_url"] = options.dd_url
else:
agentConfig["dd_url"] = config.get("Main", "dd_url")
if agentConfig["dd_url"].endswith("/"):
agentConfig["dd_url"] = agentConfig["dd_url"][:-1]
# Whether also to send to Pup
if config.has_option("Main", "use_pup"):
agentConfig["use_pup"] = config.get("Main", "use_pup").lower() in ("yes", "true")
else:
agentConfig["use_pup"] = True
if agentConfig["use_pup"]:
if config.has_option("Main", "pup_url"):
agentConfig["pup_url"] = config.get("Main", "pup_url")
else:
agentConfig["pup_url"] = "http://localhost:17125"
pup_port = 17125
if config.has_option("Main", "pup_port"):
agentConfig["pup_port"] = int(config.get("Main", "pup_port"))
# Increases the frequency of statsd metrics when only sending to Pup
if not agentConfig["use_dd"] and agentConfig["use_pup"]:
dogstatsd_interval = PUP_STATSD_FREQUENCY
if not agentConfig["use_dd"] and not agentConfig["use_pup"]:
sys.stderr.write(
"Please specify at least one endpoint to send metrics to. This can be done in datadog.conf."
)
exit(2)
# Which API key to use
agentConfig["api_key"] = config.get("Main", "api_key")
# Debug mode
agentConfig["debug_mode"] = config.get("Main", "debug_mode").lower() in ("yes", "true")
# local traffic only? Default to no
agentConfig["non_local_traffic"] = False
if config.has_option("Main", "non_local_traffic"):
agentConfig["non_local_traffic"] = config.get("Main", "non_local_traffic").lower() in ("yes", "true")
# DEPRECATED
if config.has_option("Main", "use_ec2_instance_id"):
use_ec2_instance_id = config.get("Main", "use_ec2_instance_id")
# translate yes into True, the rest into False
agentConfig["use_ec2_instance_id"] = use_ec2_instance_id.lower() == "yes"
if config.has_option("Main", "check_freq"):
try:
agentConfig["check_freq"] = int(config.get("Main", "check_freq"))
except:
pass
# Disable Watchdog (optionally)
if config.has_option("Main", "watchdog"):
if config.get("Main", "watchdog").lower() in ("no", "false"):
agentConfig["watchdog"] = False
# Optional graphite listener
if config.has_option("Main", "graphite_listen_port"):
agentConfig["graphite_listen_port"] = int(config.get("Main", "graphite_listen_port"))
else:
agentConfig["graphite_listen_port"] = None
# Dogstatsd config
dogstatsd_defaults = {
"dogstatsd_port": 8125,
"dogstatsd_target": "http://localhost:17123",
"dogstatsd_interval": dogstatsd_interval,
"dogstatsd_normalize": "yes",
}
for key, value in dogstatsd_defaults.iteritems():
if config.has_option("Main", key):
agentConfig[key] = config.get("Main", key)
else:
agentConfig[key] = value
# normalize 'yes'/'no' to boolean
dogstatsd_defaults["dogstatsd_normalize"] = _is_affirmative(dogstatsd_defaults["dogstatsd_normalize"])
# optionally send dogstatsd data directly to the agent.
if config.has_option("Main", "dogstatsd_use_ddurl"):
use_ddurl = _is_affirmative(config.get("Main", "dogstatsd_use_ddurl"))
if use_ddurl:
agentConfig["dogstatsd_target"] = agentConfig["dd_url"]
# Optional config
# FIXME not the prettiest code ever...
if config.has_option("Main", "use_mount"):
agentConfig["use_mount"] = config.get("Main", "use_mount").lower() in ("yes", "true", "1")
if config.has_option("datadog", "ddforwarder_log"):
agentConfig["has_datadog"] = True
# Dogstream config
if config.has_option("Main", "dogstream_log"):
# Older version, single log support
log_path = config.get("Main", "dogstream_log")
if config.has_option("Main", "dogstream_line_parser"):
agentConfig["dogstreams"] = ":".join([log_path, config.get("Main", "dogstream_line_parser")])
else:
agentConfig["dogstreams"] = log_path
elif config.has_option("Main", "dogstreams"):
agentConfig["dogstreams"] = config.get("Main", "dogstreams")
if config.has_option("Main", "nagios_perf_cfg"):
agentConfig["nagios_perf_cfg"] = config.get("Main", "nagios_perf_cfg")
if config.has_section("WMI"):
agentConfig["WMI"] = {}
for key, value in config.items("WMI"):
agentConfig["WMI"][key] = value
except ConfigParser.NoSectionError, e:
sys.stderr.write("Config file not found or incorrectly formatted.\n")
sys.exit(2)
def __init__(self, agentConfig, emitters, systemStats):
self.agentConfig = agentConfig
# system stats is generated by config.get_system_stats
self.agentConfig['system_stats'] = systemStats
# agent config is used during checks, system_stats can be accessed through the config
self.os = getOS()
self.plugins = None
self.emitters = emitters
self.metadata_interval = int(
agentConfig.get('metadata_interval', 10 * 60))
self.metadata_start = time.time()
socket.setdefaulttimeout(15)
self.run_count = 0
self.continue_running = True
# Unix System Checks
self._unix_system_checks = {
'disk': u.Disk(checks_logger),
'io': u.IO(),
'load': u.Load(checks_logger),
'memory': u.Memory(checks_logger),
'network': u.Network(checks_logger),
'processes': u.Processes(),
'cpu': u.Cpu(checks_logger)
}
# Win32 System `Checks
self._win32_system_checks = {
'disk': w32.Disk(checks_logger),
'io': w32.IO(checks_logger),
'proc': w32.Processes(checks_logger),
'memory': w32.Memory(checks_logger),
'network': w32.Network(checks_logger),
'cpu': w32.Cpu(checks_logger)
}
# Old-style metric checks
self._couchdb = CouchDb(checks_logger)
self._mongodb = MongoDb(checks_logger)
self._mysql = MySql(checks_logger)
self._rabbitmq = RabbitMq()
self._ganglia = Ganglia(checks_logger)
self._cassandra = Cassandra()
self._dogstream = Dogstreams.init(checks_logger, self.agentConfig)
self._ddforwarder = DdForwarder(checks_logger, self.agentConfig)
self._ec2 = EC2(checks_logger)
# Metric Checks
self._metrics_checks = [
ElasticSearch(checks_logger),
Jvm(checks_logger),
Tomcat(checks_logger),
ActiveMQ(checks_logger),
Solr(checks_logger),
WMICheck(checks_logger),
Memcache(checks_logger),
]
# Custom metric checks
for module_spec in [
s.strip()
for s in self.agentConfig.get('custom_checks', '').split(',')
]:
if len(module_spec) == 0: continue
try:
self._metrics_checks.append(
modules.load(module_spec, 'Check')(checks_logger))
logger.info("Registered custom check %s" % module_spec)
except Exception, e:
logger.exception('Unable to load custom check module %s' %
module_spec)
def load_check_directory(agentConfig):
''' Return the checks from checks.d. Only checks that have a configuration
file in conf.d will be returned. '''
from util import yaml, yLoader
from checks import AgentCheck
checks = []
log = logging.getLogger('checks')
osname = getOS()
checks_path = get_checksd_path(osname)
confd_path = get_confd_path(osname)
check_glob = os.path.join(checks_path, '*.py')
# Update the python path before the import
sys.path.append(checks_path)
# For backwards-compatability with old style checks, we have to load every
# checks.d module and check for a corresponding config OR check if the old
# config will "activate" the check.
#
# Once old-style checks aren't supported, we'll just read the configs and
# import the corresponding check module
for check in glob.glob(check_glob):
check_name = os.path.basename(check).split('.')[0]
try:
check_module = __import__(check_name)
except:
log.exception('Unable to import check module %s.py from checks.d' %
check_name)
continue
check_class = None
classes = inspect.getmembers(check_module, inspect.isclass)
for name, clsmember in classes:
if clsmember == AgentCheck:
continue
if issubclass(clsmember, AgentCheck):
check_class = clsmember
if AgentCheck in clsmember.__bases__:
continue
else:
break
if not check_class:
log.error(
'No check class (inheriting from AgentCheck) found in %s.py' %
check_name)
continue
# Check if the config exists OR we match the old-style config
conf_path = os.path.join(confd_path, '%s.yaml' % check_name)
if os.path.exists(conf_path):
f = open(conf_path)
try:
check_config = yaml.load(f.read(), Loader=yLoader)
assert check_config is not None
f.close()
except:
f.close()
log.exception("Unable to parse yaml config in %s" % conf_path)
continue
elif hasattr(check_class, 'parse_agent_config'):
# FIXME: Remove this check once all old-style checks are gone
check_config = check_class.parse_agent_config(agentConfig)
if not check_config:
continue
else:
log.debug('No conf.d/%s.yaml found for checks.d/%s.py' %
(check_name, check_name))
continue
# Look for the per-check config, which *must* exist
if not check_config.get('instances'):
log.error("Config %s is missing 'instances'" % conf_path)
continue
# Accept instances as a list, as a single dict, or as non-existant
instances = check_config.get('instances', {})
if type(instances) != type([]):
instances = [instances]
# Init all of the check's classes with
init_config = check_config.get('init_config', {})
# init_config: in the configuration triggers init_config to be defined
# to None.
if init_config is None:
init_config = {}
init_config['instances_number'] = len(instances)
check_class = check_class(check_name,
init_config=init_config,
agentConfig=agentConfig)
# Add custom pythonpath(s) if available
if 'pythonpath' in check_config:
pythonpath = check_config['pythonpath']
if not isinstance(pythonpath, list):
pythonpath = [pythonpath]
sys.path.extend(pythonpath)
log.debug('Loaded check.d/%s.py' % check_name)
checks.append({
'name': check_name,
'instances': check_config['instances'],
'class': check_class
})
log.info('checks.d checks: %s' % [c['name'] for c in checks])
return checks
def __init__(self, agentConfig, emitters, systemStats):
self.agentConfig = agentConfig
# system stats is generated by config.get_system_stats
self.agentConfig['system_stats'] = systemStats
# agent config is used during checks, system_stats can be accessed through the config
self.os = getOS()
self.plugins = None
self.emitters = emitters
self.metadata_interval = int(agentConfig.get('metadata_interval', 10 * 60))
self.metadata_start = time.time()
socket.setdefaulttimeout(15)
self.run_count = 0
self.continue_running = True
# Unix System Checks
self._unix_system_checks = {
'disk': u.Disk(checks_logger),
'io': u.IO(),
'load': u.Load(checks_logger),
'memory': u.Memory(checks_logger),
'network': u.Network(checks_logger),
'processes': u.Processes(),
'cpu': u.Cpu(checks_logger)
}
# Win32 System `Checks
self._win32_system_checks = {
'disk': w32.Disk(checks_logger),
'io': w32.IO(checks_logger),
'proc': w32.Processes(checks_logger),
'memory': w32.Memory(checks_logger),
'network': w32.Network(checks_logger),
'cpu': w32.Cpu(checks_logger)
}
# Old-style metric checks
self._couchdb = CouchDb(checks_logger)
self._mongodb = MongoDb(checks_logger)
self._mysql = MySql(checks_logger)
self._rabbitmq = RabbitMq()
self._ganglia = Ganglia(checks_logger)
self._cassandra = Cassandra()
self._dogstream = Dogstreams.init(checks_logger, self.agentConfig)
self._ddforwarder = DdForwarder(checks_logger, self.agentConfig)
self._ec2 = EC2(checks_logger)
# Metric Checks
self._metrics_checks = [
ElasticSearch(checks_logger),
WMICheck(checks_logger),
Memcache(checks_logger),
]
# Custom metric checks
for module_spec in [s.strip() for s in self.agentConfig.get('custom_checks', '').split(',')]:
if len(module_spec) == 0: continue
try:
self._metrics_checks.append(modules.load(module_spec, 'Check')(checks_logger))
logger.info("Registered custom check %s" % module_spec)
except Exception, e:
logger.exception('Unable to load custom check module %s' % module_spec)
def __init__(self, agentConfig, emitters):
self.agentConfig = agentConfig
self.os = getOS()
self.plugins = None
self.emitters = emitters
self.checksLogger = logging.getLogger('checks')
self.metadata_interval = int(agentConfig.get('metadata_interval', 10 * 60))
self.metadata_start = time.time()
socket.setdefaulttimeout(15)
# Unix System Checks
self._unix_system_checks = {
'disk': u.Disk(self.checksLogger),
'io': u.IO(),
'load': u.Load(self.checksLogger),
'memory': u.Memory(self.checksLogger),
'network': u.Network(self.checksLogger),
'processes': u.Processes(),
'cpu': u.Cpu()
}
# Win32 System Checks
self._win32_system_checks = {
'disk': w32.Disk(self.checksLogger),
'io': w32.IO(self.checksLogger),
'proc': w32.Processes(self.checksLogger),
'memory': w32.Memory(self.checksLogger),
'network': w32.Network(self.checksLogger),
'cpu': w32.Cpu(self.checksLogger)
}
# Old-style metric checks
self._apache = Apache(self.checksLogger)
self._couchdb = CouchDb(self.checksLogger)
self._mongodb = MongoDb(self.checksLogger)
self._mysql = MySql(self.checksLogger)
self._rabbitmq = RabbitMq()
self._ganglia = Ganglia(self.checksLogger)
self._cassandra = Cassandra()
self._dogstream = Dogstreams.init(self.checksLogger, self.agentConfig)
self._ddforwarder = DdForwarder(self.checksLogger, self.agentConfig)
self._ec2 = EC2(self.checksLogger)
# Metric Checks
self._metrics_checks = [
Varnish(self.checksLogger),
ElasticSearch(self.checksLogger),
Jvm(self.checksLogger),
Tomcat(self.checksLogger),
ActiveMQ(self.checksLogger),
Solr(self.checksLogger),
WMICheck(self.checksLogger),
Nginx(self.checksLogger),
Memcache(self.checksLogger),
]
# Custom metric checks
for module_spec in [s.strip() for s in self.agentConfig.get('custom_checks', '').split(',')]:
if len(module_spec) == 0: continue
try:
self._metrics_checks.append(modules.load(module_spec, 'Check')(self.checksLogger))
self.checksLogger.info("Registered custom check %s" % module_spec)
except Exception, e:
self.checksLogger.exception('Unable to load custom check module %s' % module_spec)
