Package: appoptics-apm
appoptics_apmThe 'appoptics_apm' module provides automatic instrumentation and metrics/tracing SDK hooks for use withAppOptics.The appoptics_apm module provides middleware and other instrumentation for popular web frameworks such as Django, Tornado, Pyramid, and WSGI, as well as commonly used libraries like SQLAlchemy, httplib, redis, memcached.  Read more atour full documentation.InstallingThe Python instrumentation for AppOptics uses a module namedappoptics_apm, which is distributed via pypi.pipinstallappoptics_apmAlternately, you can use this repository to build a local copy.ConfiguringSee our documentation onconfiguring the python instrumentation.UpgradingTo upgrade an existing installation, you simply need to run:pipinstall--upgradeappoptics_apmBuilding the AgentPrerequisitesInstall Docker on your local machine.Build the Docker container which provides all necessary build tools:dockerbuild-tpython-appoptics:dev-container.How to Build the AgentSwitch into the build container by running./run_docker_dev.shInside the docker container, you can now build the agent with the provided Makefile. Please consult the output ofmakefor more details.Running the TestsTest Suite OrganizationThe test suite is organized into three main components, which are described in the following sections. All components
are configured to run in a docker environment, which is provided undertest/docker. All test can be executed locally,
and the unit tests are configured to run automatically in Travis.Unit Tests -- Verifies Python agent functionalityThese are actually functional tests; naming is for historic reasons.These are tests that exercise the actual c-lib extension.The C-extension is loaded, but certain C-library methods are modified to intercept the events which would otherwise be reported to the production collectorAll unit tests are configured to run automatically in Travis when a commit is pushed to the Github repo.When running the unit tests locally, a pre-built agent distribution found underdistwill be used. The agent version of the pre-built distribution is determined by theAPPOPTICS_APM_VERSIONenvironment variable and the tests will fail if no source distribution or compatible wheel can be found underdist. If the environment variable is unset, the version as specified by the source code currently checked out will be assumed.Location of test filesPython test scripts are located undertest/unitDocker configuration and setup scripts are located undertest/docker/unitTest logs will be located undertest/docker/unit/logsCode coverage report will be located undertest/docker/unit/reportsInstall Tests -- Verifies correct installation of agent under a variety of operating systemsThese tests install the Python agent from the source distribution as well as from the Python wheel (if applicable).After successful installation, a minimal startup test will be performed to check that the agent installed from the source/ binary distribution starts up properly and can connect to the collector.On non-compatible operating systems (such as CentOs 6), a check will be performed that the agent goes into no-nop mode.When running the install tests locally, a pre-built agent distribution found underdistwill be used. The agent version of the pre-built distribution is determined by theAPPOPTICS_APM_VERSIONenvironment variable and the tests will fail no source distribution or compatible wheel can be found underdist. If the environment variable is unset, the version as specified by the source code currently checked out will be assumed.Location of test filesThere are currently no Python test scripts needed for the install testsDocker configuration and setup scripts and test code is located undertest/docker/installTest logs will be located undertest/docker/install/logsAWS Lambda Layer Tests -- Verifies AWS Lambda LayerChecks the content of the AWS Lambda layer zip archiveVerifies that the AWS Lambda layer can be loaded in an AWS Lambda environmentWhen running the unit tests locally, a pre-built agent distribution found underdistwill be used.Location of test filesPython test scripts are located undertest/unitDocker configuration and test script are located undertest/docker/lambda_layerTest logs can be retrieved from the docker-compose (docker container) logsManual Tests -- Manual verification of certain behaviorThese tests are currently not maintained.Running the tests locally via docker-composePrerequisitesInstall Docker and Docker Compose on your local machine.Build agent distribution under your localdist/directory usingmake package.This will create a source distribution (tar.gz archive) as well as Python wheels under thedist/directory.To speed up the process, you can only build the source distribution withmake sdistwhen you only want to run the unit tests.Run testsTo run unit, install and AWS Lambda tests locally, simply navigate totest/docker/unit,test/docker/install,test/docker/lambda_layer, respectively.In the directory you can now execute the following commands:To see the test matrix as defined by the Compose environment:docker-compose configTo run the entire test suite:docker-compose up -dTo run the entire test suite against a specific version of the Python agent:APPOPTICS_APM_VERSION=1.2.3 docker-compose up -dNote that the source and binary distribution of the version as specified inAPPOPTICS_APM_VERSIONmust be available underdist/already, otherwise all tests will fail.Test logs are written totest/docker/unit|install/logs, and each composed service (i.e. test run) will exit 1 if there are test failures,  you can check via:docker-compose psTo tear down the docker-compose environment, run:docker-compose down --remove-orphansCode Coverage Report for Unit and Extension TestsTo activate code coverage reports for the unit tests, you can simply set the following environment variable in your shell:PYTHON_APPOPTICS_CODECOVERAGE=1This will measure your code coverage with thecoveragePython module and create html-reports in thetest/docker/unit/reportsdirectory for the unit tests. The reports will be stored under<project_root>/test/docker/unit/reports/<service>/unit/index.htmland can simply be viewed with your browser.For example, if the project is checked out under~/source/python-appoptics:Run the desired service<service>with temporarily activated coverage measurement:PYTHON_APPOPTICS_CODECOVERAGE=1 docker-compose up <service> -dAfter the tests have been completed, you should find the coverage report for this service under~/source/python-appoptics/test/docker/unit/reports/<service>To view e.g. the unit test results, just open~/source/python-appoptics/test/docker/unit/reports/<service>/unit/index.htmlin your browser.SupportIf you find a bug or would like to request an enhancement, feel free to file
an issue. For all other support requests, please emailtechnicalsupport@solarwinds.com.ContributingYou are obviously a person of great sense and intelligence. We happily
appreciate all contributions to the appoptics_apm module whether it is documentation,
a bug fix, new instrumentation for a library or framework or anything else
we haven't thought of.We welcome you to send us PRs. We also humbly request that any new
instrumentation submissions have corresponding tests that accompany
them. This way we don't break any of your additions when we (and others)
make changes after the fact.How to Publish ReleasesThe release process is handled through GitHub Actions. There are two different actions to release the agent which are
described in more detail below.Publish Release Candidate to TestPyPiYou can manually publish a release candidate toTestPyPiby running thePublish to TestPyPiaction through the manual workflow trigger. When running this action, you can manually select which branch you would
like to publish the release candidate from.Publish to PyPiTo publish the agent toPyPi, perform the following steps:Create a release using theCreate Release Workflowthrough the
manual workflow trigger in the Github UI. You must provide the semantic version of the release you want to
create when triggering the workflow. Note that the workflow will fail if the version string you provided already
exists. This workflow will:create a branchrelease/rel-<release-version>modify theappoptics_apm/version.pyfile to change the__version__variable to the correct release versioncommit the above change to the branchopen a new Pull Request to merge branchrelease/rel-<release-version>to mastercreate a draft releaserel-<release-version>Update the newly created draft release as needed (i.e. add release notes) and publish this release. Publishing
automatically triggers thePublish to PyPiworkflow which
will build and upload the artifacts to PyPi.Approve and merge the pull request created in step 1 to reflect the update of the agent version in the master branch.Activating Git hooksThis repo provides a folder hooks, in which all git hook related scripts can be found. Currently, there is only a pre-commit hook which runs Pylint on the changed *.py files.To set up the pre-commit hook, simply run theinstall_hook.shscript in this folder. This will install a project-specific virtual Python environment under which the code will be linted. Note that this requires Pyenv and Pyenv-virtualenv to be installed on your system.Note:
Pyenv-virtualenv provides a functionality to automatically detect your project-specific virtual environment (e.g. when changing into the project folder in the terminal). To activate the auto-detection, you only need to make sure that you addedpyenv virtualenv-initto your shell (refer to the installation section forpyenv-virtualenvfor more details).PylintTo make sure that the code conforms the standards defined in the.pylintrcfile, the pre-commit hook will not allow you to commit code if Pylint does issue any errors or warnings on the files you changed.You can change this behaviour by setting certain environment variables when invokinggit commit.Ignore Pylint warning messagesYou can commit your code even though Pylint issued warning messages by settingPYTHON_APPOPTICS_PYLINT_IGNORE_WARNINGS=1when invoking git commit.Ignore Pylint error messagesYou can commit your code even though Pylint issued error messages by settingPYTHON_APPOPTICS_PYLINT_IGNORE_ERRORS=1when invoking git commit. Please use this option with great care as Pylint error messages usually indicate genuine bugs in your code.Code Formatting with YapfFor a more consistent formatting of the Python files, this repository comes with the code formatter Yapf pre-installed in the virtual environment. The configurations of Yapf are stored in the.style.yapffile in the root directory of this repository. Please consult theYapf documentationfor more information about the auto-formatter.Currently, the formatting is not enforced through any commit hooks, but you can invoke Yapf with the provided configuration in your local development environment.Developer ResourcesWe have made a large effort to expose as much technical information
as possible to assist developers wishing to contribute to the AppOptics module.
Below are the three major sources for information and help for developers:TheAppOptics Knowledge Basehas a large collection of technical articles or, if needed, you can submit a support request directly to the team.If you have any questions or ideas, don't hesitate to contact us anytime.To see the code related to the C++ extension, take a look inappoptics_apm/swig.LicenseCopyright (c) 2017 SolarWinds, LLCReleased under theApache License 2.0