version: 2.1

default_resource_class: &default_resource_class medium

cimg_base_image: &cimg_base_image cimg/base:stable

python39_image: &python39_image cimg/python:3.9

ddtrace_dev_image: &ddtrace_dev_image datadog/dd-trace-py:buster

datadog_agent_image: &datadog_agent_image datadog/agent:latest

redis_image: &redis_image redis:4.0-alpine

memcached_image: &memcached_image memcached:1.5-alpine

cassandra_image: &cassandra_image cassandra:3.11.7

consul_image: &consul_image consul:1.6.0

moto_image: &moto_image palazzem/moto:1.0.1

mysql_image: &mysql_image mysql:5.7

postgres_image: &postgres_image postgres:10.5-alpine

mongo_image: &mongo_image mongo:3.6

httpbin_image: &httpbin_image kennethreitz/httpbin@sha256:2c7abc4803080c22928265744410173b6fea3b898872c01c5fd0f0f9df4a59fb

vertica_image: &vertica_image sumitchawla/vertica:latest

rabbitmq_image: &rabbitmq_image rabbitmq:3.7-alpine

orbs:

win: circleci/[email protected]

machine_executor: &machine_executor

machine:

image: ubuntu-2004:202107-02

environment:

- BOTO_CONFIG: /dev/null

# https://support.circleci.com/hc/en-us/articles/360045268074-Build-Fails-with-Too-long-with-no-output-exceeded-10m0s-context-deadline-exceeded-

- PYTHONUNBUFFERED: 1

steps:

- &pyenv-set-global

run:

name: Set global pyenv

command: |

pyenv global 3.9.4

contrib_job: &contrib_job

executor: ddtrace_dev

parallelism: 4

contrib_job_small: &contrib_job_small

executor: ddtrace_dev_small

parallelism: 1

commands:

save_coverage:

description: "Save coverage.py results to workspace"

steps:

- run: |

set -ex

mkdir coverage

if [ -f .coverage ];

then

cp .coverage ./coverage/$CIRCLE_BUILD_NUM-$CIRCLE_JOB-$CIRCLE_NODE_INDEX.coverage

fi

- persist_to_workspace:

root: coverage

paths:

- "*.coverage"

- store_artifacts:

path: coverage

setup_tox:

description: "Install tox"

steps:

- run: pip install -U tox

setup_riot:

description: "Install riot"

steps:

# Make sure we install and run riot on Python 3

- run: pip3 install riot

restore_tox_cache:

description: "Restore .tox directory from previous runs for faster installs"

steps:

- restore_cache:

# In the cache key:

# - .Environment.CIRCLE_JOB: We do separate tox environments by job name, so caching and restoring is

# much faster.

key: tox-cache-{{ .Environment.CIRCLE_JOB }}-{{ checksum "tox.ini" }}-{{ checksum "setup.py" }}

save_tox_cache:

description: "Save .tox directory into cache for faster installs next time"

steps:

- save_cache:

# In the cache key:

# - .Environment.CIRCLE_JOB: We do separate tox environments by job name, so caching and restoring is

# much faster.

key: tox-cache-{{ .Environment.CIRCLE_JOB }}-{{ checksum "tox.ini" }}-{{ checksum "setup.py" }}

paths:

- ".tox"

run_test:

description: "Run tests matching a pattern"

parameters:

pattern:

type: string

default: ""

wait:

type: string

default: ""

snapshot:

type: boolean

default: false

docker_services:

type: string

default: ""

store_coverage:

type: boolean

default: true

steps:

- attach_workspace:

at: .

- checkout

- when:

condition:

<< parameters.snapshot >>

steps:

- run: SNAPSHOT_CI=1 docker-compose up -d testagent << parameters.docker_services >>

- run:

command: docker-compose logs -f

background: true

- run:

environment:

DD_TRACE_AGENT_URL: http://localhost:9126

command: |

mv .riot .ddriot

echo -p2.7,-p3.5,-p3.6,-p3.7,-p3.8,-p3.9 | tr ',' '\n' | circleci tests split | xargs ./scripts/ddtest riot -v run --exitfirst --pass-env -s '<< parameters.pattern >>'

- unless:

condition:

<< parameters.snapshot >>

steps:

- when:

condition:

<< parameters.wait >>

steps:

- setup_tox

- run:

name: "Waiting for << parameters.wait >>"

command: tox -e 'wait' << parameters.wait >>

- setup_riot

- run:

command: "echo -p2.7,-p3.5,-p3.6,-p3.7,-p3.8,-p3.9 | tr ',' '\n' | circleci tests split | xargs riot -v run --exitfirst --pass-env -s '<< parameters.pattern >>'"

- when:

condition:

<< parameters.store_coverage >>

steps:

- save_coverage

- store_test_results:

path: test-results

- store_artifacts:

path: test-results

run_tox_scenario_with_testagent:

description: Run scripts/run-tox-scenario with setup, caching persistence and the testagent

parameters:

pattern:

type: string

wait:

type: string

default: ""

steps:

- checkout

- restore_tox_cache

- when:

condition:

<< parameters.wait >>

steps:

- run:

name: "Waiting for << parameters.wait >>"

command: tox -e 'wait' << parameters.wait >>

- run: SNAPSHOT_CI=1 docker-compose up -d memcached redis testagent

- run:

command: docker-compose logs -f

background: true

- run:

name: "Run scripts/run-tox-scenario"

environment:

DD_TRACE_AGENT_URL: http://localhost:9126

command: ./scripts/ddtest scripts/run-tox-scenario '<< parameters.pattern >>'

- save_tox_cache

run_tox_scenario:

description: "Run scripts/run-tox-scenario with setup, caching and persistence"

parameters:

pattern:

type: string

wait:

type: string

default: ""

store_coverage:

type: boolean

default: true

steps:

- checkout

- setup_tox

- restore_tox_cache

- when:

condition:

<< parameters.wait >>

steps:

- run:

name: "Waiting for << parameters.wait >>"

command: tox -e 'wait' << parameters.wait >>

- run:

name: "Run scripts/run-tox-scenario"

command: scripts/run-tox-scenario '<< parameters.pattern >>'

- save_tox_cache

- when:

condition:

<< parameters.store_coverage >>

steps:

- save_coverage

- store_test_results:

path: test-results

- store_artifacts:

path: test-results

executors:

cimg_base:

docker:

- image: *cimg_base_image

resource_class: small

python39:

docker:

- image: *python39_image

resource_class: small

ddtrace_dev:

docker:

- image: *ddtrace_dev_image

resource_class: *default_resource_class

ddtrace_dev_small:

docker:

- image: *ddtrace_dev_image

resource_class: small

# Common configuration blocks as YAML anchors

# See: https://circleci.com/blog/circleci-hacks-reuse-yaml-in-your-circleci-config-with-yaml/

httpbin_local: &httpbin_local

image: *httpbin_image

name: httpbin.org

datadog_agent: &datadog_agent

image: *datadog_agent_image

environment:

DD_API_KEY: invalid_key_but_this_is_fine

DD_APM_ENABLED: true

DD_APM_RECEIVER_SOCKET: /tmp/ddagent/trace.sock

DD_BIND_HOST: 0.0.0.0

DD_LOG_LEVEL: DEBUG

mysql_server: &mysql_server

image: *mysql_image

environment:

- MYSQL_ROOT_PASSWORD=admin

- MYSQL_PASSWORD=test

- MYSQL_USER=test

- MYSQL_DATABASE=test

postgres_server: &postgres_server

image: *postgres_image

environment:

- POSTGRES_PASSWORD=postgres

- POSTGRES_USER=postgres

- POSTGRES_DB=postgres

jobs:

pre_check:

executor: python39

steps:

- checkout

- setup_riot

- run:

name: "Black check"

command: riot run -s black --check .

- run:

name: "Flake8 check"

command: riot run -s flake8

- run:

name: "Mypy check"

command: riot run -s mypy

- run:

name: "Codespell check"

command: riot run -s codespell

ccheck:

executor: cimg_base

steps:

- checkout

- run: sudo apt-get update

- run: sudo apt-get install --yes clang-format gcc-10 python3 python3-setuptools python3-pip

- run: scripts/cformat.sh

- run: DD_COMPILE_DEBUG=1 CC=gcc-10 pip -vvv install .

coverage_report:

executor: python39

steps:

- checkout

- attach_workspace:

at: .

- run: pip install coverage codecov diff_cover

- run: ls -hal *.coverage

# Combine all job coverage reports into one

- run: coverage combine *.coverage

# Upload coverage report to Codecov

# DEV: Do not use the bash uploader, it cannot be trusted

- run: codecov

# Generate and save xml report

# DEV: "--ignore-errors" to skip over files that are missing

- run: coverage xml --ignore-errors

- store_artifacts:

path: coverage.xml

# Generate and save JSON report

# DEV: "--ignore-errors" to skip over files that are missing

- run: coverage json --ignore-errors

- store_artifacts:

path: coverage.json

# Generate and save HTML report

# DEV: "--ignore-errors" to skip over files that are missing

- run: coverage html --ignore-errors

- store_artifacts:

path: htmlcov

# Print ddtrace/ report to stdout

# DEV: "--ignore-errors" to skip over files that are missing

- run: coverage report --ignore-errors --omit=tests/

# Print tests/ report to stdout

# DEV: "--ignore-errors" to skip over files that are missing

- run: coverage report --ignore-errors --omit=ddtrace/

# Print diff-cover report to stdout (compares against origin/master)

- run: diff-cover --compare-branch origin/master coverage.xml

build_base_venvs:

executor: ddtrace_dev

parallelism: 6

steps:

- checkout

- setup_riot

- run:

name: "Run riotfile.py tests"

command: riot run -s riot-helpers

- run:

name: "Generate base virtual environments."

command: "echo '2.7,3.5,3.6,3.7,3.8,3.9' | tr ',' '\n' | circleci tests split | xargs -I PY riot -v generate --python=PY"

- persist_to_workspace:

root: .

paths:

- "."

tracer:

<<: *contrib_job

steps:

- run_test:

pattern: "tracer"

opentracer:

<<: *contrib_job

steps:

- run_tox_scenario:

pattern: '^py..-opentracer'

profile:

<<: *contrib_job

parallelism: 6

steps:

- run_tox_scenario:

store_coverage: false

pattern: '^py.\+-profile'

integration_agent5:

<<: *machine_executor

steps:

- checkout

- run: docker-compose up -d ddagent5

- run:

command: docker-compose logs -f

background: true

- run:

command: ./scripts/ddtest scripts/run-tox-scenario '^py..-integration-v5'

integration_agent:

<<: *machine_executor

steps:

- checkout

- run: docker-compose up -d ddagent

- run:

command: docker-compose logs -f

background: true

- run:

command: ./scripts/ddtest scripts/run-tox-scenario '^py..-integration-latest'

integration_testagent:

<<: *machine_executor

steps:

- checkout

- run: SNAPSHOT_CI=1 docker-compose up -d testagent

- run:

command: docker-compose logs -f

background: true

- run:

environment:

DD_TRACE_AGENT_URL: http://localhost:9126

command: ./scripts/ddtest scripts/run-tox-scenario '^py..-integration-snapshot'

vendor:

<<: *contrib_job_small

docker:

- image: *ddtrace_dev_image

steps:

- run_test:

pattern: 'vendor'

futures:

<<: *contrib_job_small

steps:

- run_tox_scenario:

pattern: '^futures_contrib-'

boto:

<<: *machine_executor

parallelism: 4

steps:

- run_test:

pattern: '^boto' # run boto and botocore

snapshot: true

docker_services: "localstack"

ddtracerun:

<<: *contrib_job

docker:

- image: *ddtrace_dev_image

- image: *redis_image

steps:

- run_test:

store_coverage: false

pattern: 'ddtracerun'

test_logging:

<<: *contrib_job_small

steps:

- run_test:

pattern: 'test_logging'

asyncio:

<<: *contrib_job_small

steps:

- run_tox_scenario:

pattern: '^asyncio_contrib-'

pylons:

<<: *contrib_job

steps:

- run_tox_scenario:

pattern: '^pylons_contrib-'

aiohttp:

<<: *contrib_job

steps:

- run_test:

pattern: 'aiohttp'

asgi:

<<: *contrib_job_small

steps:

- run_test:

pattern: 'asgi$'

tornado:

<<: *contrib_job

steps:

- run_tox_scenario:

pattern: '^tornado_contrib-'

bottle:

<<: *contrib_job

steps:

- run_tox_scenario:

pattern: '^bottle_contrib\(_autopatch\)\?-'

cassandra:

<<: *contrib_job

docker:

- image: *ddtrace_dev_image

environment:

CASS_DRIVER_NO_EXTENSIONS: 1

- image: *cassandra_image

environment:

- MAX_HEAP_SIZE=512M

- HEAP_NEWSIZE=256M

steps:

- run_test:

wait: cassandra

pattern: 'cassandra'

celery:

<<: *contrib_job

parallelism: 6

docker:

- image: *ddtrace_dev_image

- image: redis:4.0-alpine

- image: *rabbitmq_image

steps:

- run_test:

pattern: 'celery'

cherrypy:

<<: *machine_executor

parallelism: 6

steps:

- run_test:

pattern: 'cherrypy'

snapshot: true

consul:

<<: *contrib_job

docker:

- image: *ddtrace_dev_image

- image: *consul_image

steps:

- run_tox_scenario:

pattern: '^consul_contrib-'

dogpile_cache:

<<: *contrib_job

steps:

- run_tox_scenario:

pattern: '^dogpile_contrib-'

elasticsearch:

<<: *machine_executor

parallelism: 4

steps:

- run_test:

pattern: 'elasticsearch'

snapshot: true

docker_services: 'elasticsearch'

falcon:

<<: *contrib_job

steps:

- run_test:

pattern: 'falcon'

django:

<<: *machine_executor

parallelism: 6

steps:

- run_test:

pattern: 'django$'

snapshot: true

docker_services: "memcached redis postgres"

django_hosts:

<<: *machine_executor

steps:

- run_test:

pattern: 'django_hosts$'

snapshot: true

djangorestframework:

<<: *machine_executor

parallelism: 6

steps:

- run_test:

pattern: 'djangorestframework'

snapshot: true

docker_services: "memcached redis"

fastapi:

<<: *machine_executor

steps:

- run_test:

pattern: "fastapi"

snapshot: true

flask:

<<: *contrib_job

docker:

- image: *ddtrace_dev_image

- image: *redis_image

- image: *memcached_image

steps:

- run_test:

# Run both flask and flask_cache test suites

pattern: 'flask(_cache)?'

gevent:

<<: *contrib_job

steps:

- run_tox_scenario:

pattern: '^gevent_contrib-'

grpc:

<<: *machine_executor

parallelism: 6

steps:

- run_test:

pattern: "grpc"

snapshot: true

httplib:

<<: *contrib_job

steps:

- run_tox_scenario:

pattern: '^httplib_contrib'

httpx:

<<: *machine_executor

steps:

- run_test:

pattern: 'httpx'

snapshot: true

docker_services: 'httpbin_local'

mariadb:

<<: *machine_executor

steps:

- run_test:

pattern: 'mariadb$'

snapshot: true

docker_services: "mariadb"

molten:

<<: *contrib_job

steps:

- run_tox_scenario:

pattern: '^molten_contrib-'

mysqlconnector:

<<: *contrib_job

docker:

- image: *ddtrace_dev_image

- *mysql_server

steps:

- run_test:

wait: mysql

pattern: 'mysql'

mysqlpython:

<<: *contrib_job

docker:

- image: *ddtrace_dev_image

- *mysql_server

steps:

- run_tox_scenario:

wait: mysql

pattern: '^mysqldb_contrib-.*-mysqlclient'

pymysql:

<<: *contrib_job

docker:

- image: *ddtrace_dev_image

- *mysql_server

steps:

- run_tox_scenario:

wait: mysql

pattern: '^pymysql_contrib-'

pylibmc:

<<: *contrib_job

docker:

- image: *ddtrace_dev_image

- image: *memcached_image

steps:

- run_tox_scenario:

pattern: '^pylibmc_contrib-'

pytest:

executor: ddtrace_dev

steps:

- run_test:

pattern: 'pytest'

pymemcache:

<<: *contrib_job

docker:

- image: *ddtrace_dev_image

- image: *memcached_image

steps:

- run_test:

pattern: "pymemcache"

mongoengine:

<<: *machine_executor

parallelism: 1

steps:

- run_test:

pattern: 'mongoengine'

snapshot: true

docker_services: 'mongo'

pymongo:

<<: *contrib_job

docker:

- image: *ddtrace_dev_image

- image: *mongo_image

steps:

- run_test:

pattern: "pymongo"

pynamodb:

<<: *contrib_job

steps:

- run_test:

pattern: "pynamodb"

pyodbc:

<<: *contrib_job

docker:

- image: *ddtrace_dev_image

steps:

- run_tox_scenario:

pattern: '^pyodbc_contrib-'

pyramid:

<<: *machine_executor

steps:

- run_test:

pattern: 'pyramid'

snapshot: true

requests:

<<: *contrib_job

docker:

- image: *ddtrace_dev_image

- *httpbin_local

steps:

- run_test:

pattern: "requests"

requestsgevent:

<<: *contrib_job

steps:

- run_tox_scenario:

pattern: '^requests_gevent_contrib-'

sanic:

<<: *contrib_job

steps:

- run_tox_scenario:

pattern: '^sanic_contrib-'

snowflake:

<<: *machine_executor

parallelism: 4

steps:

- run_test:

pattern: "snowflake"

snapshot: true

starlette:

<<: *machine_executor

steps:

- run_test:

pattern: "starlette"

snapshot: true

sqlalchemy:

<<: *contrib_job

docker:

- image: *ddtrace_dev_image

- *postgres_server

- *mysql_server

steps:

- run_test:

wait: postgres mysql

pattern: "sqlalchemy"

dbapi:

<<: *contrib_job

steps:

- run_tox_scenario:

pattern: '^dbapi_contrib-'

psycopg:

<<: *machine_executor

parallelism: 4

steps:

- run_test:

pattern: "psycopg"

snapshot: true

docker_services: "postgres"

aiobotocore:

<<: *contrib_job

docker:

- image: *ddtrace_dev_image

- image: *moto_image

steps:

- run_test:

pattern: 'aiobotocore'

aiopg:

<<: *contrib_job

docker:

- image: *ddtrace_dev_image

- *postgres_server

steps:

- run_test:

wait: postgres

pattern: 'aiopg'

aredis:

<<: *machine_executor

parallelism: 4

steps:

- run_test:

docker_services: 'redis'

pattern: 'aredis$'

snapshot: true

yaaredis:

<<: *machine_executor

parallelism: 4

steps:

- run_test:

docker_services: 'redis'

pattern: 'yaaredis$'

snapshot: true

redis:

<<: *machine_executor

parallelism: 4

steps:

- run_test:

docker_services: 'redis'

pattern: 'redis$'

snapshot: true

rediscluster:

<<: *machine_executor

steps:

- run_test:

pattern: 'rediscluster'

docker_services: 'rediscluster'

snapshot: true

rq:

<<: *machine_executor

parallelism: 4

steps:

- run_test:

pattern: "rq"

snapshot: true

docker_services: "redis"

urllib3:

<<: *machine_executor

steps:

- run_test:

pattern: 'urllib3'

snapshot: true

docker_services: "httpbin_local"

vertica:

<<: *contrib_job

docker:

- image: *ddtrace_dev_image

- image: *vertica_image

environment:

- VP_TEST_USER=dbadmin

- VP_TEST_PASSWORD=abc123

- VP_TEST_DATABASE=docker

steps:

- run_tox_scenario:

wait: vertica

pattern: '^vertica_contrib-'

wsgi:

<<: *machine_executor

steps:

- run_test:

pattern: "wsgi"

snapshot: true

kombu:

<<: *contrib_job

docker:

- image: *ddtrace_dev_image

- image: *rabbitmq_image

steps:

- run_tox_scenario:

wait: rabbitmq

pattern: '^kombu_contrib-'

sqlite3:

<<: *contrib_job

steps:

- run_tox_scenario:

pattern: '^sqlite3_contrib-'

benchmarks:

<<: *contrib_job

steps:

- run_test:

store_coverage: false

pattern: '^benchmarks'

jinja2:

<<: *contrib_job

steps:

- run_test:

pattern: 'jinja2'

mako:

<<: *contrib_job_small

steps:

- run_test:

pattern: 'mako'

algoliasearch:

<<: *contrib_job

steps:

- run_tox_scenario:

pattern: '^algoliasearch_contrib-'

build_docs:

# build documentation and store as an artifact

executor: ddtrace_dev

steps:

- setup_riot

- checkout

- run:

command: |

riot -v run docs

mkdir -p /tmp/docs

cp -r docs/_build/html/* /tmp/docs

- store_artifacts:

path: /tmp/docs

requires_pre_check: &requires_pre_check

requires:

- pre_check

- ccheck

requires_base_venvs: &requires_base_venvs

requires:

- pre_check

- ccheck

- build_base_venvs

requires_tests: &requires_tests

requires:

- aiobotocore

- aiohttp

- aiopg

- asyncio

- algoliasearch

- asgi

- benchmarks

- boto

- bottle

- cassandra

- celery

- cherrypy

- consul

- dbapi

- ddtracerun

- dogpile_cache

- django

- django_hosts

- djangorestframework

- elasticsearch

- falcon

- fastapi

- flask

- futures

- gevent

- grpc

- httplib

- httpx

- integration_agent5

- integration_agent

- integration_testagent

- vendor

- profile

- jinja2

- kombu

- mako

- mariadb

- molten

- mongoengine

- mysqlconnector

- mysqlpython

- opentracer

- psycopg

- pylibmc

- pylons

- pymemcache

- pymongo

- pymysql

- pynamodb

- pyodbc

- pyramid

- pytest

- aredis

- yaaredis

- redis

- rediscluster