def test_bad_globbing():
with run_container("zookeeper:3.4") as zk_cont:
zkhost = container_ip(zk_cont)
assert wait_for(p(tcp_socket_open, zkhost, 2181), 30)
create_znode(zk_cont, "/env", "prod")
final_conf = BAD_GLOB_CONFIG.substitute(zk_endpoint="%s:2181" % zkhost)
with Agent.run(final_conf) as agent:
assert wait_for(
lambda: "zookeeper only supports globs" in agent.output)
def test_ecs_container_image_filtering():
with run_service("ecsmeta") as ecsmeta, run_container(
"redis:4-alpine") as redis:
ecsmeta_ip = container_ip(ecsmeta)
redis_ip = container_ip(redis)
with Agent.run("""
monitors:
- type: ecs-metadata
metadataEndpoint: http://%s/metadata_single?redis_ip=%s
statsEndpoint: http://%s/stats
excludedImages:
- redis:latest
""" % (ecsmeta_ip, redis_ip, ecsmeta_ip)) as agent:
assert ensure_always(lambda: not has_datapoint_with_dim(
agent.fake_services,
"container_id",
"c42fa5a73634bcb6e301dfb7b13ac7ead2af473210be6a15da75a290c283b66c",
))
def is_running(self):
if not self.container:
filters = {"name": self.container_name, "status": "running"}
if self.host_client and self.container_name and self.host_client.containers.list(filters=filters):
self.container = self.host_client.containers.get(self.container_name)
if self.container:
self.container.reload()
self.container_ip = container_ip(self.container)
return self.container.status == "running" and self.container_ip
return False
def test_with_default_config_2_4_5():
with run_service("elasticsearch/2.4.5") as es_container:
host = container_ip(es_container)
check_service_status(host)
agent_config = AGENT_CONFIG_TEMPLATE.format(host=host, flag="")
with Agent.run(agent_config) as agent:
assert wait_for(
p(any_metric_has_any_dim_key, agent.fake_services, METADATA.default_metrics, METADATA.dims)
), "Didn't get all default dimensions"
assert not has_log_message(agent.output.lower(), "error"), "error found in agent output!"
def run_consumer(image, kafka_host, **kwargs):
with run_container(
image,
name=f"kafka-consumer-{random_hex()}",
environment={"JMX_PORT": "9099", "START_AS": "consumer", "KAFKA_BROKER": f"{kafka_host}:9092"},
**kwargs,
) as kafka_consumer:
host = container_ip(kafka_consumer)
assert wait_for(p(tcp_socket_open, host, 9099), 60), "kafka consumer jmx didn't start"
yield host
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]
def test_ecs_observer_dim_label():
with run_service("ecsmeta") as ecsmeta:
with run_container("redis:4-alpine") as redis:
with run_agent(
CONFIG.substitute(
host=container_ip(ecsmeta),
redis_ip=container_ip(redis),
mongo_ip="not_used",
case="metadata_single",
)
) as [backend, _, _]:
assert wait_for(
p(has_datapoint_with_dim, backend, "container_spec_name", "redis")
), "Didn't get redis datapoints"
# Let redis be removed by docker observer and collectd restart
time.sleep(5)
backend.datapoints.clear()
assert ensure_always(lambda: not has_datapoint_with_dim(backend, "ClusterName", "seon-fargate-test"), 10)
def test_nginx():
with run_service("nginx") as nginx_container:
host = container_ip(nginx_container)
config = NGINX_CONFIG.substitute(host=host)
assert wait_for(p(tcp_socket_open, host, 80), 60), "service didn't start"
with Agent.run(config) as agent:
assert wait_for(
p(has_datapoint_with_dim, agent.fake_services, "plugin", "nginx")
), "Didn't get nginx datapoints"
def test_kong(kong_version): # pylint: disable=redefined-outer-name
pg_env = dict(POSTGRES_USER="******", POSTGRES_PASSWORD="******", POSTGRES_DB="kong")
kong_env = dict(
KONG_ADMIN_LISTEN="0.0.0.0:8001",
KONG_LOG_LEVEL="warn",
KONG_DATABASE="postgres",
KONG_PG_DATABASE=pg_env["POSTGRES_DB"],
KONG_PG_PASSWORD=pg_env["POSTGRES_PASSWORD"],
)
with run_container("postgres:9.5", environment=pg_env) as db:
db_ip = container_ip(db)
kong_env["KONG_PG_HOST"] = db_ip
assert wait_for(p(tcp_socket_open, db_ip, 5432))
with run_service(
"kong", buildargs={"KONG_VERSION": kong_version}, environment=kong_env, command="sleep inf"
) as migrations:
if kong_version in ["0.15-centos", "1.0.0-centos"]:
assert container_cmd_exit_0(migrations, "kong migrations bootstrap")
else:
assert container_cmd_exit_0(migrations, "kong migrations up")
with run_service("kong", buildargs={"KONG_VERSION": kong_version}, environment=kong_env) as kong:
kong_ip = container_ip(kong)
assert wait_for(p(http_status, url=f"http://{kong_ip}:8001/signalfx", status=[200]))
config = dedent(
f"""
monitors:
- type: collectd/kong
host: {kong_ip}
port: 8001
metrics:
- metric: connections_handled
report: true
"""
)
with Agent.run(config) as agent:
assert wait_for(
p(has_datapoint_with_dim, agent.fake_services, "plugin", "kong")
), "Didn't get Kong data point"
def test_redis(image):
with run_container(image) as test_container:
host = container_ip(test_container)
config = monitor_config.substitute(host=host)
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"
with run_agent(config) as [backend, _, _]:
assert wait_for(p(has_datapoint_with_dim, backend, "plugin", "redis_info")), "didn't get datapoints"
def test_etcd_monitor():
with run_etcd() as etcd_cont:
host = container_ip(etcd_cont)
config = ETCD_CONFIG.format(host=host)
with Agent.run(config) as agent:
assert wait_for(
p(has_datapoint,
agent.fake_services,
metric_name="process_cpu_seconds_total")
), "Didn't get etcd datapoints"
def test_consul():
with run_container("consul:0.9.3") as consul_cont:
host = container_ip(consul_cont)
config = CONSUL_CONFIG.substitute(host=host)
assert wait_for(p(tcp_socket_open, host, 8500), 60), "consul service didn't start"
with Agent.run(config) as agent:
assert wait_for(
p(has_datapoint_with_metric_name, agent.fake_services, "gauge.consul.catalog.services.total"), 60
), "Didn't get consul datapoints"
def test_haproxy(version):
with run_service("haproxy", buildargs={"HAPROXY_VERSION":
version}) as service_container:
host = container_ip(service_container)
config = MONITOR_CONFIG.substitute(host=host)
assert wait_for(p(tcp_socket_open, host, 9000),
120), "haproxy not listening on port"
with Agent.run(config) as agent:
assert wait_for(
p(has_datapoint_with_dim, agent.fake_services, "plugin",
"haproxy")), "didn't get datapoints"
def test_apache():
with run_service("apache") as apache_container:
host = container_ip(apache_container)
config = apache_config.substitute(host=host)
assert wait_for(p(tcp_socket_open, host, 80),
60), "service didn't start"
with run_agent(config) as [backend, _, _]:
assert wait_for(
p(has_datapoint_with_dim, backend, "plugin",
"apache")), "Didn't get apache datapoints"
def test_apache():
with run_service("apache") as apache_container:
host = container_ip(apache_container)
config = APACHE_CONFIG.substitute(host=host)
assert wait_for(p(tcp_socket_open, host, 80),
60), "service didn't start"
with Agent.run(config) as agent:
assert wait_for(
p(has_datapoint_with_dim, agent.fake_services, "plugin",
"apache")), "Didn't get apache datapoints"
def test_mongo():
with run_container("mongo:3.6") as mongo_cont:
host = container_ip(mongo_cont)
config = mongo_config.substitute(host=host)
assert wait_for(p(tcp_socket_open, host, 27017),
60), "service didn't start"
with run_agent(config) as [backend, _, _]:
assert wait_for(
p(has_datapoint_with_dim, backend, "plugin",
"mongo")), "Didn't get mongo datapoints"
def test_couchbase():
with run_service("couchbase",
hostname="node1.cluster") as couchbase_container:
host = container_ip(couchbase_container)
config = couchbase_config.substitute(host=host)
assert wait_for(p(tcp_socket_open, host, 8091),
60), "service didn't start"
with run_agent(config) as [backend, _, _]:
assert wait_for(p(has_datapoint_with_dim, backend, "plugin", "couchbase")), \
"Didn't get couchbase datapoints"
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
url: http://{host}:8080/stats?stats;csv
""") as agent:
verify(agent, EXPECTED_DEFAULTS - EXPECTED_DEFAULTS_FROM_SOCKET,
10)
def test_postgresql():
with run_container("postgres:10", environment=ENV) as cont:
host = container_ip(cont)
config = CONFIG_TEMP.substitute(host=host)
assert wait_for(p(tcp_socket_open, host, 5432), 60), "service didn't start"
with Agent.run(config) as agent:
assert wait_for(
p(has_datapoint_with_dim, agent.fake_services, "plugin", "postgresql")
), "Didn't get postgresql datapoints"
assert wait_for(p(has_datapoint_with_metric_name, agent.fake_services, "pg_blks.toast_hit"))
def run_kong(kong_version):
pg_env = dict(POSTGRES_USER="******", POSTGRES_PASSWORD="******", POSTGRES_DB="kong")
kong_env = dict(
KONG_ADMIN_LISTEN="0.0.0.0:8001",
KONG_LOG_LEVEL="warn",
KONG_DATABASE="postgres",
KONG_PG_DATABASE=pg_env["POSTGRES_DB"],
KONG_PG_PASSWORD=pg_env["POSTGRES_PASSWORD"],
)
with run_container("postgres:9.5", environment=pg_env) as db:
db_ip = container_ip(db)
kong_env["KONG_PG_HOST"] = db_ip
assert wait_for(p(tcp_socket_open, db_ip, 5432))
with run_service(
"kong",
name="kong-boot",
buildargs={"KONG_VERSION": kong_version},
environment=kong_env,
command="sleep inf",
) as migrations:
if kong_version in ["0.15-centos", "1.0.0-centos"]:
assert container_cmd_exit_0(migrations, "kong migrations bootstrap")
else:
assert container_cmd_exit_0(migrations, "kong migrations up")
with run_service(
"kong", name="kong", buildargs={"KONG_VERSION": kong_version}, environment=kong_env
) as kong, run_container(
"openresty/openresty:centos", files=[(SCRIPT_DIR / "echo.conf", "/etc/nginx/conf.d/echo.conf")]
) as echo:
kong_ip = container_ip(kong)
kong_admin = f"http://{kong_ip}:8001"
assert wait_for(p(http_status, url=f"{kong_admin}/signalfx", status=[200]))
paths, _ = configure_kong(kong_admin, kong_version, container_ip(echo))
# Needs time to settle after creating routes.
retry(lambda: run_traffic(paths, f"http://{kong_ip}:8000"), AssertionError, interval_seconds=2)
yield kong_ip
def test_ecs_container_stats_without_container_metadata():
with run_service("ecsmeta") as ecsmeta, run_container(
"redis:4-alpine") as redis:
ecsmeta_ip = container_ip(ecsmeta)
redis_ip = container_ip(redis)
with run_agent("""
monitors:
- type: ecs-metadata
metadataEndpoint: http://%s/metadata_single?redis_ip=%s&mask_redis=true
statsEndpoint: http://%s/stats
""" % (ecsmeta_ip, redis_ip, ecsmeta_ip)) as [backend, _, _]:
assert wait_for(
# container_id is included in stats.json file in ecsmeta app
# because stats data don't come directly from the docker container but from ecs metadata api
p(
has_datapoint_with_dim,
backend,
"container_id",
"c42fa5a73634bcb6e301dfb7b13ac7ead2af473210be6a15da75a290c283b66c",
)), "Didn't get redis datapoints"
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,
)
def test_etcd_monitor():
with run_container("quay.io/coreos/etcd:v2.3.8",
command=ETCD_COMMAND) as etcd_cont:
host = container_ip(etcd_cont)
config = etcd_config.substitute(host=host)
assert wait_for(p(tcp_socket_open, host, 2379),
60), "service didn't start"
with run_agent(config) as [backend, _, _]:
assert wait_for(
p(has_datapoint_with_dim, backend, "plugin",
"etcd")), "Didn't get etcd datapoints"
def run(config, metrics):
with run_service("apache") as apache_container:
host = container_ip(apache_container)
config = config.format(host=host)
assert wait_for(p(tcp_socket_open, host, 80),
60), "service didn't start"
with Agent.run(config) as agent:
verify(agent, metrics)
assert has_datapoint_with_dim(
agent.fake_services, "plugin",
"apache"), "Didn't get apache datapoints"
def test_basic_zk_config():
with run_container("zookeeper:3.4") as zk:
assert wait_for(p(container_cmd_exit_0, zk, "nc -z localhost 2181"), 5)
create_znode(zk, "/env", "prod")
create_znode(zk, "/monitors", "")
create_znode(zk, "/monitors/cpu", "- type: collectd/cpu")
create_znode(zk, "/monitors/signalfx-metadata", "- type: collectd/signalfx-metadata")
final_conf = config.substitute(zk_endpoint="%s:2181" % container_ip(zk))
with run_agent(final_conf) as [backend, get_output, _]:
assert wait_for(p(has_datapoint_with_dim, backend, "plugin", "signalfx-metadata"))
assert wait_for(p(has_datapoint_with_dim, backend, "env", "prod"))
def test_cassandra():
with run_service("cassandra") as cassandra_cont:
host = container_ip(cassandra_cont)
config = CASSANDRA_CONFIG.substitute(host=host)
# Wait for the JMX port to be open in the container
assert wait_for(p(tcp_socket_open, host, 7199), 60), "Cassandra JMX didn't start"
with run_agent(config) as [backend, _, _]:
assert wait_for(
p(has_datapoint_with_metric_name, backend, "counter.cassandra.ClientRequest.Read.Latency.Count"), 60
), "Didn't get Cassandra datapoints"
def test_ecs_container_label_dimension():
with run_service("ecsmeta") as ecsmeta, run_container("redis:4-alpine") as redis:
ecsmeta_ip = container_ip(ecsmeta)
redis_ip = container_ip(redis)
with Agent.run(
"""
monitors:
- type: ecs-metadata
metadataEndpoint: http://%s/metadata_single?redis_ip=%s
statsEndpoint: http://%s/stats
labelsToDimensions:
container_name: container_title
"""
% (ecsmeta_ip, redis_ip, ecsmeta_ip)
) as agent:
assert ensure_always(
lambda: not has_datapoint_with_dim(
agent.fake_services, "container_title", "ecs-seon-fargate-test-3-redis-baf2cfda88f8d8ee4900"
)
)
def test_snmp():
# snmp-simulator source is available at: https://github.com/xeemetric/snmp-simulator
# the hard coded uptime OID used in this test was fetched using the following command
# $ snmpget -On -v2c -c public <snmp simulator host>:161 system.sysUpTime.0
with run_container("xeemetric/snmp-simulator") as test_container:
host = container_ip(test_container)
config = monitor_config.substitute(host=host)
with run_agent(config) as [backend, _, _]:
assert wait_for(
p(has_datapoint_with_dim, backend, "plugin", "telegraf-snmp")
), "didn't get database io datapoints"
def test_openstack_default(devstack):
host = container_ip(devstack)
run_agent_verify(
f"""
monitors:
- type: collectd/openstack
authURL: http://{host}/identity/v3
username: admin
password: testing123
""",
DEFAULT_METRICS,
)
def run_vault_iam_test(iam_config):
"""
Test that Vault will authenticate a user with IAM crednetials and provide a
token
"""
with run_vault() as [vault_client, _], run_service("awsapi") as aws_cont:
aws_ip = container_ip(aws_cont)
assert wait_for(p(tcp_socket_open, aws_ip, 8080), 30)
vault_client.sys.enable_auth_method("aws")
vault_client.write(
"auth/aws/config/client",
**{
"iam_endpoint": f"http://{aws_ip}:8080/iam",
"sts_endpoint": f"http://{aws_ip}:8080/sts",
"ec2_endpoint": f"http://{aws_ip}:8080/ec2",
"secret_key": "MY_SECRET_KEY",
"access_key": "MY_ACCESS_KEY",
},
)
vault_client.sys.create_or_update_policy(
name="dev", policy=READ_ALL_SECRETS_POLICY)
vault_client.write(
"auth/aws/role/dev-role-iam",
**{
"auth_type": "iam",
"policies": "dev",
"bound_iam_principal_arn": "arn:aws:iam::0123456789:*"
},
)
vault_client.write("secret/data/app", data={"env": "dev"})
with Agent.run(
dedent(f"""
intervalSeconds: 1
globalDimensions:
env: {{"#from": "vault:secret/data/app[data.env]"}}
configSources:
vault:
vaultAddr: {vault_client.url}
authMethod: iam
iam: {json.dumps(iam_config)}
monitors:
- type: collectd/uptime
""")) as agent:
assert wait_for(p(has_datapoint,
agent.fake_services,
dimensions={"env": "dev"}),
timeout_seconds=10)
