def test_extra_metrics_passthrough(): """ The specified extraMetrics should be allowed through even though they are not included by default. """ metadata = Metadata.from_package("expvar") with run_expvar() as expvar_container_ip: with Agent.run(f""" monitors: - type: expvar host: {expvar_container_ip} port: 8080 intervalSeconds: 1 extraMetrics: - memstats.by_size.mallocs """) as agent: assert "memstats.by_size.mallocs" in metadata.nonincluded_metrics verify(agent, metadata.included_metrics | {"memstats.by_size.mallocs"})
def test_built_in_filtering_disabled_no_whitelist_for_monitor(): """ Test a monitor that doesn't have any entries in whitelist.json """ metadata = Metadata.from_package("expvar") with run_expvar() as expvar_container_ip: with Agent.run(f""" enableBuiltInFiltering: false monitors: - type: expvar host: {expvar_container_ip} port: 8080 intervalSeconds: 1 enhancedMetrics: true # This should be ignored extraMetrics: - memstats.by_size.mallocs metricsToExclude: - {{"#from": "{REPO_ROOT_DIR}/whitelist.json", flatten: true}} """) as agent: verify(agent, metadata.all_metrics)
def test_built_in_filtering_disabled_whitelisted_monitor(): """ Test a monitor that is in whitelist.json. """ metadata = Metadata.from_package("collectd/redis") with run_redis() as [ip_addr, redis_client]: redis_client.lpush("queue-1", *["a", "b", "c"]) redis_client.lpush("queue-2", *["x", "y"]) with Agent.run(f""" enableBuiltInFiltering: false monitors: - type: collectd/redis host: {ip_addr} port: 6379 intervalSeconds: 1 sendListLengths: - databaseIndex: 0 keyPattern: queue-* metricsToExclude: - {{"#from": "{REPO_ROOT_DIR}/whitelist.json", flatten: true}} """) as agent: key_llen_metric = "gauge.key_llen" assert key_llen_metric not in metadata.included_metrics verify(agent, metadata.included_metrics - {"gauge.slave_repl_offset"}) # Add a non-default metric to the whitelist via metricsToInclude # and make sure it comes through agent.config["metricsToInclude"] = [{ "monitorType": "collectd/redis", "metricName": key_llen_metric }] agent.write_config() verify( agent, metadata.included_metrics - {"gauge.slave_repl_offset"} | {key_llen_metric})
""" Tests for the cadvisor monitor """ from functools import partial as p import pytest from tests.helpers.assertions import tcp_socket_open from tests.helpers.metadata import Metadata from tests.helpers.util import container_ip, run_container, wait_for from tests.helpers.verify import run_agent_verify pytestmark = [pytest.mark.cadvisor, pytest.mark.monitor_without_endpoints] METADATA = Metadata.from_package("cadvisor", mon_type="cadvisor") def run(config, metrics): cadvisor_opts = dict( volumes={ "/": { "bind": "/rootfs", "mode": "ro" }, "/var/run": { "bind": "/var/run", "mode": "ro" }, "/sys": { "bind": "/sys", "mode": "ro"
""" Tests for the expvar monitor """ from contextlib import contextmanager import pytest from tests.helpers.assertions import tcp_socket_open from tests.helpers.metadata import Metadata from tests.helpers.util import container_ip, run_service, wait_for from tests.helpers.verify import run_agent_verify_all_metrics, run_agent_verify, run_agent_verify_default_metrics pytestmark = [pytest.mark.expvar, pytest.mark.monitor_with_endpoints] METADATA = Metadata.from_package("expvar") @contextmanager def run_expvar(): """expvar container fixture""" with run_service("expvar") as container: host = container_ip(container) assert wait_for(lambda: tcp_socket_open(host, 8080), 60), "service didn't start" yield host def test_expvar_default(): with run_expvar() as expvar_container_ip: run_agent_verify_default_metrics( f"""
@contextmanager def run_redis(image="redis:4-alpine"): with run_container(image) as redis_container: host = container_ip(redis_container) assert wait_for(p(tcp_socket_open, host, 6379), 60), "service not listening on port" redis_client = redis.StrictRedis(host=host, port=6379, db=0) assert wait_for(redis_client.ping, 60), "service didn't start" yield [host, redis_client] METADATA = Metadata.from_package("collectd/redis") @pytest.mark.parametrize("image", ["redis:3-alpine", "redis:4-alpine"]) def test_redis(image): with run_redis(image) as [hostname, _]: config = MONITOR_CONFIG.substitute(host=hostname) with Agent.run(config) as agent: verify(agent, METADATA.default_metrics - {"gauge.slave_repl_offset"}) def test_redis_key_lengths(): with run_redis() as [hostname, redis_client]: redis_client.lpush("queue-1", *["a", "b", "c"]) redis_client.lpush("queue-2", *["x", "y"])
from functools import partial as p import pytest from tests.helpers.agent import Agent from tests.helpers.assertions import any_metric_found, datapoints_have_some_or_all_dims, has_log_message from tests.helpers.metadata import Metadata from tests.helpers.util import container_ip, ensure_always, run_service from tests.helpers.verify import verify pytestmark = [pytest.mark.haproxy, pytest.mark.monitor_with_endpoints] METADATA = Metadata.from_package("haproxy") EXPECTED_DEFAULTS = METADATA.default_metrics EXPECTED_DEFAULTS_FROM_SOCKET = { "haproxy_connection_rate_all", "haproxy_idle_percent", "haproxy_requests", "haproxy_session_rate_all", } @pytest.mark.parametrize("version", ["1.8"]) def test_haproxy_default_metrics_from_stats_page(version): with run_service("haproxy", buildargs={"HAPROXY_VERSION": version}) as service_container: host = container_ip(service_container) with Agent.run(f""" monitors: - type: haproxy
import pytest from tests.helpers.agent import Agent from tests.helpers.assertions import any_metric_has_any_dim_key, has_datapoint_with_dim, has_log_message, http_status from tests.helpers.metadata import Metadata from tests.helpers.util import container_ip, run_service, wait_for from tests.helpers.verify import run_agent_verify pytestmark = [ pytest.mark.collectd, pytest.mark.elasticsearch, pytest.mark.monitor_with_endpoints, pytest.mark.flaky(reruns=2), ] METADATA = Metadata.from_package("elasticsearch") ENV = {"cluster.name": "testCluster"} AGENT_CONFIG_TEMPLATE = """ monitors: - type: elasticsearch host: {host} port: 9200 username: elastic password: testing123 {flag} """ def check_service_status(host): assert wait_for(p(http_status, url=f"http://{host}:9200/_nodes/_local", status=[200]), 180), "service didn't start"
- type: docker-container-stats """ ) as agent: assert wait_for( p(has_datapoint_with_dim, agent.fake_services, "container_id", nginx_container.id) ), "Didn't get nginx datapoints" nginx_container.remove(force=True) time.sleep(5) agent.fake_services.reset_datapoints() assert ensure_always( lambda: not has_datapoint_with_dim(agent.fake_services, "container_id", nginx_container.id) ) METADATA = Metadata.from_package("docker") def test_docker_default(): with run_service( "elasticsearch/6.6.1" ): # just get a container that does some block io running so we have some stats metrics = METADATA.default_metrics run_agent_verify( f""" monitors: - type: docker-container-stats """, metrics, )
import pytest from tests.helpers.agent import Agent from tests.helpers.assertions import has_datapoint_with_dim, has_datapoint_with_metric_name from tests.helpers.metadata import Metadata from tests.helpers.util import ensure_always, run_service, wait_for from tests.helpers.verify import ( run_agent_verify_included_metrics, verify_expected_is_subset, run_agent_verify_all_metrics, ) pytestmark = [pytest.mark.docker_container_stats, pytest.mark.monitor_without_endpoints] METADATA = Metadata.from_package("collectd/docker") def test_docker_included(): with run_service( "elasticsearch/6.6.1" ): # just get a container that does some block io running so we have some stats run_agent_verify_included_metrics( f""" monitors: - type: collectd/docker dockerURL: unix:///var/run/docker.sock """, METADATA, )
import sys import pytest from tests.helpers.agent import Agent from tests.helpers.metadata import Metadata from tests.helpers.verify import verify pytestmark = [ pytest.mark.windows, pytest.mark.memory, pytest.mark.monitor_without_endpoints ] METADATA = Metadata.from_package("memory") def test_memory(): expected_metrics = {"memory.used", "memory.utilization"} if sys.platform == "linux": expected_metrics.update({ "memory.buffered", "memory.cached", "memory.free", "memory.slab_recl", "memory.slab_unrecl" }) with Agent.run(""" monitors: - type: memory """) as agent: for met in expected_metrics: assert met in METADATA.default_metrics verify(agent, expected_metrics)
""" from contextlib import contextmanager from functools import partial as p import pytest from tests.helpers.agent import Agent from tests.helpers.assertions import has_datapoint_with_dim, tcp_socket_open from tests.helpers.metadata import Metadata from tests.helpers.util import container_ip, run_service, wait_for from tests.helpers.verify import verify pytestmark = [pytest.mark.collectd, pytest.mark.php, pytest.mark.monitor_with_endpoints] METADATA = Metadata.from_package("collectd/php") INSTANCE = "test" @contextmanager def run_php_fpm(): with run_service("php") as php_container: host = container_ip(php_container) assert wait_for(p(tcp_socket_open, host, 80), 60), "service didn't start" yield host def test_php_default(): with run_php_fpm() as host, Agent.run( f""" monitors:
import sys import pytest from tests.helpers.assertions import has_log_message from tests.helpers.metadata import Metadata from tests.helpers.verify import run_agent_verify_default_metrics, run_agent_verify_all_metrics pytestmark = [ pytest.mark.skipif(sys.platform != "win32", reason="only runs on windows"), pytest.mark.windows_only, pytest.mark.windowslegacy, ] METADATA = Metadata.from_package("windowslegacy") def test_windowslegacy_default(): agent = run_agent_verify_default_metrics( """ monitors: - type: windows-legacy """, METADATA, ) assert not has_log_message(agent.output.lower(), "error"), "error found in agent output!" def test_windowslegacy_all(): agent = run_agent_verify_all_metrics(
from contextlib import contextmanager from functools import partial as p import pytest from tests.helpers.agent import Agent from tests.helpers.assertions import has_datapoint_with_dim, tcp_socket_open from tests.helpers.metadata import Metadata from tests.helpers.util import container_ip, run_service, wait_for from tests.helpers.verify import verify pytestmark = [ pytest.mark.collectd, pytest.mark.nginx, pytest.mark.monitor_with_endpoints ] METADATA = Metadata.from_package("collectd/nginx") @contextmanager def run_nginx(): with run_service("nginx") as nginx_container: host = container_ip(nginx_container) assert wait_for(p(tcp_socket_open, host, 80), 60), "service didn't start" yield host def test_nginx_included(): with run_nginx() as host, Agent.run(f""" monitors: - type: collectd/nginx
import pytest from tests.helpers.kubernetes import LATEST from tests.helpers.metadata import Metadata from tests.helpers.verify import verify pytestmark = [pytest.mark.kubernetes] METADATA = Metadata.from_package("kubernetes/scheduler") @pytest.mark.kubernetes @LATEST def test_kubernetes_scheduler(k8s_cluster): config = """ observers: - type: k8s-api monitors: - type: kubernetes-scheduler discoveryRule: kubernetes_pod_name =~ "kube-scheduler" port: 10251 extraMetrics: ["*"] """ with k8s_cluster.run_agent(config) as agent: verify(agent, METADATA.all_metrics)
from tests.helpers.agent import Agent from tests.helpers.assertions import ( has_datapoint_with_dim, has_datapoint_with_metric_name, has_log_message, http_status, ) from tests.helpers.metadata import Metadata from tests.helpers.util import run_service, container_ip, wait_for pytestmark = [ pytest.mark.collectd, pytest.mark.elasticsearch, pytest.mark.monitor_with_endpoints ] METADATA = Metadata.from_package("collectd/elasticsearch") @pytest.mark.flaky(reruns=2) def test_elasticsearch_without_cluster_option(): with run_service("elasticsearch/6.4.2", environment={"cluster.name": "testCluster"}) as es_container: host = container_ip(es_container) assert wait_for( p(http_status, url=f"http://{host}:9200/_nodes/_local", status=[200]), 180), "service didn't start" config = dedent(f""" monitors: - type: collectd/elasticsearch
""" ETCD_TLS_CONFIG = """ monitors: - type: etcd host: {host} port: {port} useHTTPS: true clientCertPath: {testServices}/etcd/certs/client.crt clientKeyPath: {testServices}/etcd/certs/client.key caCertPath: {testServices}/etcd/certs/server.crt skipVerify: {skipValidation} sendAllMetrics: true """ METADATA = Metadata.from_package("etcd") @contextmanager def run_etcd(tls=False, **kwargs): if tls: cmd = """ --listen-client-urls https://0.0.0.0:2379 --advertise-client-urls https://0.0.0.0:2379 --trusted-ca-file /opt/testing/certs/server.crt --cert-file /opt/testing/certs/server.crt --key-file /opt/testing/certs/server.key --client-cert-auth """ with run_service("etcd", command=cmd, **kwargs) as container: host = container_ip(container)
from functools import partial as p import pytest import requests from tests.helpers.agent import Agent from tests.helpers.assertions import has_datapoint, tcp_socket_open from tests.helpers.metadata import Metadata from tests.helpers.util import container_ip, run_service, wait_for, wait_for_assertion from tests.helpers.verify import verify pytestmark = [pytest.mark.collectd, pytest.mark.haproxy, pytest.mark.monitor_with_endpoints] METADATA = Metadata.from_package("collectd/haproxy") EXPECTED_DEFAULTS = METADATA.included_metrics @pytest.mark.parametrize("version", ["1.9", "latest"]) def test_haproxy_basic(version): with run_service("haproxy", buildargs={"HAPROXY_VERSION": version}) as service_container: host = container_ip(service_container) assert wait_for(p(tcp_socket_open, host, 9000)), "haproxy not listening on port" with Agent.run( f""" monitors: - type: collectd/haproxy host: {host} port: 9000 enhancedMetrics: false """
from tests.helpers.agent import Agent from tests.helpers.assertions import has_datapoint, tcp_socket_open from tests.helpers.metadata import Metadata from tests.helpers.util import container_ip, run_container, wait_for from tests.helpers.verify import verify pytestmark = [ pytest.mark.collectd, pytest.mark.postgresql, pytest.mark.monitor_with_endpoints ] ENV = [ "POSTGRES_USER=test_user", "POSTGRES_PASSWORD=test_pwd", "POSTGRES_DB=test" ] METADATA = Metadata.from_package("collectd/postgresql") def test_postgresql_defaults(): with run_container("postgres:10", environment=ENV) as cont: host = container_ip(cont) assert wait_for(p(tcp_socket_open, host, 5432), 60), "service didn't start" with Agent.run(f""" monitors: - type: collectd/postgresql host: {host} port: 5432 username: "******" password: "******"
import pytest from tests.helpers.metadata import Metadata from tests.helpers.util import run_container, container_ip from tests.helpers.verify import run_agent_verify_included_metrics, run_agent_verify_all_metrics VERSIONS = ["memcached:1.5-alpine", "memcached:latest"] METADATA = Metadata.from_package("collectd/memcached") @pytest.mark.parametrize("version", VERSIONS) def test_memcached_included(version): with run_container(version) as container: host = container_ip(container) run_agent_verify_included_metrics( f""" monitors: - type: collectd/memcached host: {host} port: 11211 """, METADATA, ) @pytest.mark.parametrize("version", VERSIONS) def test_memcached_all(version): with run_container(version) as container: host = container_ip(container) run_agent_verify_all_metrics( f"""
from functools import partial as p from textwrap import dedent import pytest from signalfx.generated_protocol_buffers import signal_fx_protocol_buffers_pb2 as sf_pbuf from tests.helpers.metadata import Metadata from tests.helpers.agent import Agent from tests.helpers.assertions import has_datapoint, has_datapoint_with_dim from tests.helpers.verify import run_agent_verify_default_metrics from tests.helpers.util import wait_for pytestmark = [pytest.mark.telegraf] METADATA = Metadata.from_package("telegraf/monitors/dns") SERVER = "1.1.1.1" DOMAIN = "signalfx.com" def test_telegraf_dns_metrics(): # Config to get every possible metrics agent_config = dedent(f""" monitors: - type: telegraf/dns servers: - {SERVER} """) run_agent_verify_default_metrics(agent_config, METADATA) def test_telegraf_resolve(): with Agent.run(f""" monitors:
from contextlib import contextmanager from functools import partial as p from tests.helpers.agent import Agent from tests.helpers.assertions import tcp_socket_open from tests.helpers.metadata import Metadata from tests.helpers.util import container_ip, run_container, wait_for from tests.helpers.verify import run_agent_verify_default_metrics, verify_expected_is_subset METADATA = Metadata.from_package("collectd/zookeeper") ENV = ["ZOO_4LW_COMMANDS_WHITELIST=mntr,ruok", "ZOO_STANDALONE_ENABLED=false"] @contextmanager def run_zookeeper(version="zookeeper:3.4", env=None): with run_container(version, environment=env) as zk_cont: host = container_ip(zk_cont) assert wait_for(p(tcp_socket_open, host, 2181), 30) yield host def test_zookeeeper(): with run_zookeeper() as host: run_agent_verify_default_metrics( f""" monitors: - type: collectd/zookeeper host: {host} port: 2181 """,
import sys import pytest from tests.helpers.assertions import http_status from tests.helpers.metadata import Metadata from tests.helpers.verify import run_agent_verify_default_metrics, run_agent_verify_all_metrics pytestmark = [ pytest.mark.skipif(sys.platform != "win32", reason="only runs on windows"), pytest.mark.windows_only, pytest.mark.windowsiis, ] METADATA = Metadata.from_package("windowsiis") def test_windowsiis_default(): run_agent_verify_default_metrics( """ monitors: - type: windows-iis """, METADATA, ) def test_windowsiis_all(): # Required to make sure a worker (w3wp process) has started for process metrics. assert http_status("http://localhost", [200]), "IIS should be running on localhost"
from contextlib import contextmanager from functools import partial as p import pytest from tests.helpers.agent import Agent from tests.helpers.assertions import tcp_socket_open, has_datapoint_with_dim from tests.helpers.metadata import Metadata from tests.helpers.util import container_ip, run_container, wait_for from tests.helpers.verify import verify from tests.monitors.collectd_hadoop.hadoop_test import start_hadoop pytestmark = [pytest.mark.collectd, pytest.mark.hadoopjmx, pytest.mark.monitor_with_endpoints] METADATA = Metadata.from_package("collectd/hadoopjmx") LATEST_VERSION = "3.0.3" VERSIONS = ["2.9.1", LATEST_VERSION] NODETYPE_PORT = {"nameNode": 5677, "dataNode": 5677, "resourceManager": 5680, "nodeManager": 8002} NODETYPE_GROUP = { "nameNode": "name-node", "dataNode": "data-node", "resourceManager": "resource-manager", "nodeManager": "node-manager", } YARN_VAR = {"resourceManager": "YARN_RESOURCEMANAGER_OPTS", "nodeManager": "YARN_NODEMANAGER_OPTS"} YARN_OPTS = ( '%s="-Dcom.sun.management.jmxremote.ssl=false -Dcom.sun.management.jmxremote.authenticate=false ' '-Dcom.sun.management.jmxremote.port=%d $%s"' ) YARN_ENV_PATH = "/usr/local/hadoop/etc/hadoop/yarn-env.sh" HADOOPJMX_CONFIG = """
""" Tests for the cpu monitor """ import pytest from tests.helpers.metadata import Metadata from tests.helpers.verify import run_agent_verify_default_metrics, run_agent_verify_all_metrics pytestmark = [ pytest.mark.windows, pytest.mark.cpu, pytest.mark.monitor_without_endpoints ] METADATA = Metadata.from_package("cpu") def test_cpu_default(): run_agent_verify_default_metrics( """ monitors: - type: cpu """, METADATA, ) def test_cpu_all(): run_agent_verify_all_metrics( """ monitors: - type: cpu
""" Tests for the collectd/protocols monitor """ import pytest from tests.helpers.assertions import has_log_message from tests.helpers.metadata import Metadata from tests.helpers.verify import run_agent_verify_default_metrics, run_agent_verify_all_metrics pytestmark = [pytest.mark.collectd, pytest.mark.protocols, pytest.mark.monitor_without_endpoints] METADATA = Metadata.from_package("collectd/protocols") def test_protocols_default(): """ Test that we get all default metrics """ agent = run_agent_verify_default_metrics( """ monitors: - type: collectd/protocols """, METADATA, ) assert not has_log_message(agent.output.lower(), "error"), "error found in agent output!" def test_protocols_all(): """
pytest.mark.collectd, pytest.mark.jenkins, pytest.mark.monitor_with_endpoints ] METRICS_KEY = "33DD8B2F1FD645B814993275703F_EE1FD4D4E204446D5F3200E0F6-C55AC14E" JENKINS_VERSIONS = [ # technically we support 1.580.3, but the scripts needed to programmatically # setup jenkins do not work prior to 1.651.3 ("jenkins", "1.651.3-alpine"), # TODO: jenkins doesn't have a latest tag so we'll need to update this # periodically ("jenkins/jenkins", "2.196-alpine"), ] METADATA = Metadata.from_package("collectd/jenkins") ENHANCED_METRICS = { ("jenkins", "1.651.3-alpine"): METADATA.all_metrics - { "gauge.jenkins.job.duration", "gauge.jenkins.node.executor.count.value", "gauge.jenkins.node.executor.in-use.value", "gauge.jenkins.node.health-check.score", "gauge.jenkins.node.queue.size.value", "gauge.jenkins.node.slave.online.status", "gauge.jenkins.node.vm.memory.heap.usage", "gauge.jenkins.node.vm.memory.non-heap.used", "gauge.jenkins.node.vm.memory.total.used", }, ("jenkins/jenkins", "2.196-alpine"): METADATA.all_metrics - {"gauge.jenkins.job.duration", "gauge.jenkins.node.slave.online.status"}, }
import pytest from tests.helpers.agent import Agent from tests.helpers.metadata import Metadata from tests.helpers.verify import run_agent_verify_default_metrics, verify_expected_is_subset pytestmark = [pytest.mark.collectd, pytest.mark.disk, pytest.mark.monitor_without_endpoints] METADATA = Metadata.from_package("collectd/disk") def test_disk_default(): run_agent_verify_default_metrics( """ monitors: - type: collectd/disk """, METADATA, ) def test_disk_all(): with Agent.run( """ monitors: - type: collectd/disk extraMetrics: ["*"] """ ) as agent: # pending_operations only shows up sometimes on CI. Maybe only reported when non-zero? verify_expected_is_subset(agent, METADATA.all_metrics - {"pending_operations"})
from textwrap import dedent import pytest from tests.helpers.agent import Agent from tests.helpers.assertions import has_datapoint_with_dim from tests.helpers.metadata import Metadata from tests.helpers.util import wait_for from tests.helpers.verify import run_agent_verify_default_metrics pytestmark = [ pytest.mark.windows, pytest.mark.filesystems, pytest.mark.monitor_without_endpoints ] MONITOR = "ntp" METADATA = Metadata.from_package(MONITOR) HOST = "pool.ntp.org" @pytest.mark.flaky(reruns=2, reruns_delay=30) def test_default_metrics(): # Config to get every possible metrics agent_config = dedent(f""" monitors: - type: ntp host: {HOST} """) # every metrics should be reported for https site run_agent_verify_default_metrics(agent_config, METADATA)
import pytest from tests.helpers.agent import Agent from tests.helpers.assertions import has_datapoint from tests.helpers.metadata import Metadata from tests.helpers.util import run_service from tests.helpers.verify import verify pytestmark = [pytest.mark.monitor_without_endpoints] METADATA = Metadata.from_package("cgroups") def test_cgroup_monitor(): with run_service( "nginx", cpu_period=100_000, cpu_quota=10000, cpu_shares=50, mem_limit=20 * 1024 * 1024 ) as nginx_container: with Agent.run( """ monitors: - type: cgroups extraMetrics: ['*'] """ ) as agent: verify(agent, METADATA.all_metrics) expected_cgroup = "/docker/" + nginx_container.id assert has_datapoint( agent.fake_services, metric_name="cgroup.cpu_shares", value=50, dimensions={"cgroup": expected_cgroup} )