Welcome to the public home of Dependabot :dependabot:.
Table of Contents
What is Dependabot-Core?
How to run Dependabot
Contributing to Dependabot
Reporting Issues and Feature Requests
Submitting Pull Requests
New Ecosystems
Development Guide
Getting a Development Environment Running
Debugging Problems
Running Tests
Profiling
Architecture and Code Layout
Trademarks
Notes for Project Maintainers
What is Dependabot-Core?
Dependabot-Core is the library at the heart of Dependabot security / version updates.
Use it to generate automated pull requests updating dependencies for projects written in Ruby, JavaScript, Python,
PHP, Dart, Elixir, Elm, Go, Rust, Java, Julia, and .NET. It can also update git submodules, Docker files, Opentofu, and Terraform files.
Features include:
Check for the latest version of a dependency that's resolvable given a project's other dependencies
Generate updated manifest and lockfiles for a new dependency version
Generate PR descriptions that include the updated dependency's changelogs, release notes, and commits
How to run Dependabot
Most people are familiar with the Dependabot service that runs on GitHub.com and GitHub Enterprise. Enabling that is as
simple as checking a dependabot.yml configuration file in to your repository's .github directory.
However, if you want to run a custom version of Dependabot or run it on another platform, you're not left out in the cold.
This repo provides the logic necessary for hosting your own standalone Dependabot. It currently supports opening Pull Requests against repositories hosted on GitHub, Github Enterprise, Azure DevOps, GitLab, BitBucket, and AWS CodeCommit.
Dependabot-Core is a library, so you'll need an entrypoint script of some kind. Here are a few examples to help you get
started.
Note: If you're looking to run Dependabot locally for development/debugging purposes, see the Development Guide.
Dependabot CLI
The open-source Dependabot CLI is our recommended entrypoint for standalone use cases.
We use it in production here at GitHub, and advanced users can also leverage it to run a self-hosted version of Dependabot within their own projects / CI systems.
It creates dependency diffs but does not create PRs. So you will need to wire that up yourself.
To aid with that, we created the example-cli-usage repo which demonstrates how to turn those diffs into actual PR's.
Write your own Ruby-based tool
Alternatively, because Dependabot-Core is a Ruby library, you can write your own ruby-based wrapper that leverages the Dependabot-core code. The tricky bit is Dependabot assumes it's running in an isolated, throw-away environment so you'll need to handle all that yourself. For example protecting against security risks of arbitrary code execution exfiltrating credentials, ensuring the appropriate version of Go or Python or whatever language you need is available, and handling when Dependabot makes changes to its runtime environment.
Dependabot on CI
In an environment such as GitHub where Dependabot runs in a container, if you want to change your build or installation process depending on whether it's running within the context of the Dependabot container, you can check the existence of the DEPENDABOT environment variable.
Contributing to Dependabot
Reporting issues and Feature Requests
👋 Want to give us feedback on Dependabot, or contribute to it? That's great - thank you so much!
Reproducible Example
Most bug reports should be accompanied by a link to a public repository that reproduces the problem. Bug reports that
cannot be reproduced on a public repo using the CLI tool or dry-run script may be
closed as "cannot reproduce".
No "+1" Comments
Our issue tracker is quite active, and as a result there's a good chance someone already filed the same issue. If so,
please upvote that issue, because we use 👍 reactions on issues as one signal to gauge the impact of a feature request or bug.
However, please do not leave comments that contribute nothing new to the discussion. For details, see https://go.dev/wiki/NoPlusOne. This is open source, if you see something you want fixed, we are happy to coach you through contributing a pull request to fix it.
Don't file issues about Security Alerts or Dependency Graph
The issue-tracker is meant solely for issues related to Dependabot's updating logic. Issues about security alerts or Dependency Graph should instead be filed as a Code Security discussion.
A good rule of thumb is that if you have questions about the diff in a PR, it belongs here.
Disclosing Security Issues
If you believe you have found a security vulnerability in Dependabot, please review our security policy for details about disclosing them to the GitHub Bug Bounty program, so we can work to resolve the issue before it is disclosed publicly.
Submitting Pull Requests
Want to contribute to Dependabot? That's great - thank you so much!
Contribution workflow:
Fork the project.
Get the development environment running.
Make your feature addition or bug fix.
Add tests for it. This is important so we don't break it in a future version unintentionally.
Send a pull request. The tests will run on it automatically, so don't worry if you couldn't get them running locally.
Please refer to the CONTRIBUTING guidelines for more information.
New Ecosystems
If you're interested in contributing support for a new ecosystem, please refer to the contributing guidelines for more information.
Development Guide
Getting a Development Environment Running
The first step to debugging a problem or writing a new feature is getting a development environment going. We provide a
custom Docker-based developer shell that bakes in all required dependencies.
In most cases this is the best way to work with the project.
The developer shell uses volume mounts to incorporate your local changes to Dependabot's source code. This way you can
edit locally using your favorite editor and the changes are immediately reflected within the docker container for performing
dry-runs or executing tests.
Note: See caveat about editing the native package manager helper scripts.
Quickstart
The script to launch the developer shell builds the docker images from scratch if it can't find them locally. This can take a while.
Skip the wait by pulling the pre-built image for the ecosystem you want to work on. The image name uses the YAML ecosystem name
to specify the ecosystem. For example, for Go Modules, the YAML name is gomod:
Note: Pre-built images are currently only available for AMD64 / Intel architecture. They will run on ARM, but 2x-3x slower than if you manually build ARM-specific images.
Next, run the developer shell, specifying the desired ecosystem using the top-level directory name of the ecosystem in this project. For example, for Go Modules, the top-level directory is named go_modules:
$ bin/docker-dev-shell go_modules
=> running docker development shell
[dependabot-core-dev] ~ $ cd go_modules && rspec spec # to run tests for a particular package
Building Images from Scratch
Normally the Quickstart is all you need, but occasionally you'll need to rebuild the underlying images.
For example, while we don't yet publish ARM-specific images, if you are working on an ARM-based platform, we recommend
manually building the images because the resulting containers run much faster.
The developer shell runs within a Dependabot Development docker image, which is built on top of an ecosystem image.
flowchart LR
A["docker-dev-shell script"] --> B("Dependabot Development docker image")
B --> C("Dependabot Updater Ecosystem docker image (ecosystem specific)")
C --> D("Dependabot Updater Core docker image")
Changes to the docker files for any of these images requires building one or more of the images locally in order to be reflected in the development shell.
The simple but slow way is to delete any existing images and then run bin/docker-dev-shell which automatically builds
missing images.
The faster way is to pull all the pre-built images that are dependencies of the image you actually need to build.
To (re)build a specific one:
The Updater core image:
$ docker pull ghcr.io/dependabot/dependabot-updater-core # OR
$ docker build -f Dockerfile.updater-core . --tag=dependabot-manual-build/updater-core # recommended on ARM
Each language/ecosystem sits on top of the core image. You need to rebuild whichever one you’re working on so it picks up your new core bits. For instance, if you’re working on Go Modules:
The Updater ecosystem image:
$ docker pull ghcr.io/dependabot/dependabot-updater-gomod # OR
$ script/build go_modules # recommended on ARM
To view logs and stdout from the native package manager helpers, see debugging native helpers.
Debugging Problems
The first step to debugging is getting the development environment running.
Within the development environment, you have two options for simulating a dependency update job:
You can use the newly-developed CLI tool or the original Dry-run script.
CLI tool
The Dependabot CLI is a newly-developed tool that incorporates the GitHub
Credentials Proxy to more realistically simulate what's happening within
the Dependabot-at-GitHub service when talking to private registries.
It has a dedicated debugging guide, including support for dropping into the Ruby debugger.
Dry-Run Script
Note: Before running the dry-run script, you'll need to get the development environment running.
You can use the bin/dry-run.rb script to simulate a dependency update job, printing
the diff that would be generated to the terminal. It takes two positional
arguments: the package manager
and the GitHub repo name (including the account):
You can add a debugger statement anywhere in the ruby code, for example:
def latest_resolvable_version
debugger
latest_version_finder.latest_version
end
When you execute the job, the Ruby debugger will open. It should look something like this:
[11, 20] in ~/go_modules/lib/dependabot/go_modules/update_checker.rb
11| module GoModules
12| class UpdateChecker < Dependabot::UpdateCheckers::Base
13| require_relative "update_checker/latest_version_finder"
14|
15| def latest_resolvable_version
=> 16| debugger
17| latest_version_finder.latest_version
18| end
19|
20| # This is currently used to short-circuit latest_resolvable_version,
=>#0 Dependabot::GoModules::UpdateChecker#latest_resolvable_version at ~/go_modules/lib/dependabot/go_modules/update_checker.rb:16
#1 Dependabot::GoModules::UpdateChecker#latest_version at ~/go_modules/lib/dependabot/go_modules/update_checker.rb:24
and 9 frames (use `bt' command for all frames)
(rdbg)
At this prompt, you can run debugger commands to navigate around, or enter methods and variables to see what they contain. Try entering dependency to see what dependency Dependabot is currently working on.
Note While in the debugger, changes made to the source code will not be picked up. You will have to end your debugging session and restart it.
Debugging Native Package Manager Helpers
When you're debugging an issue you often need to peek inside these scripts that run in a separate process.
Print all log statements from native helpers using DEBUG_HELPERS=true:
Pause execution to debug a single native helper function using DEBUG_FUNCTION=. The function maps to a
native helper function name, for example, one of the functions in bundler/helpers/v2/lib/functions.rb.
When this function is being executed a debugger is inserted, pausing execution of the bin/dry-run.rb script, this leaves the current updates tmp directory in place allowing you to cd into the directory and run the native helper function directly:
Keep in mind that unlike changes to the ruby source, changes on your host machine to the native helpers source code are
not synced to the development container. So you have two choices for editing the native helper:
You can directly edit the temporary copy of the native helper within the development container, for example: vi /opt/bundler/v1/lib/functions/file_parser.rb. And then re-run the cd... command. This is the fastest way to debug, but any changes won't be saved outside the container.
You can edit your local copy, and then rebuild the native helper. This will require re-running the dry-run script to pickup the change.
Debugging Ignore Conditions
Most of the ecosystems in Dependabot-Core support ignore conditions which allow a user to specify dependency names or
versions to exclude from upgrades. The docs for the Dependabot service at GitHub describe the feature in more detail.
The Dependabot CLI supports passing in ignore conditions as part of the job definition. See the example.
The dry-run script supports passing in one or more ignore conditions via the env var IGNORE_CONDITIONS:
Many of the ecosystems in Dependabot-Core support security updates. These are a special form of version update where a
dependency name and range of vulnerable versions are passed in. Dependabot-Core will try to upgrade any instance of that
dependency to the minimum non-vulnerable version. This is in contrast to a normal version update which tries to update
to the latest version.
The env var SECURITY_ADVISORIES allows passing one or more security alert notifications to the dry-run script in order to simulate a security update:
There's built-in support for leveraging Visual Studio Code's ability for
debugging inside a Docker container.
After installing the recommended Dev Containers extension,
simply press Ctrl+Shift+P (⇧⌘P on macOS) and select Dev Containers: Reopen in Container.
You can also access the dropdown by clicking on the green button in the bottom-left corner of the editor.
If the development Docker image isn't present on your machine, it will be built automatically.
Once that's finished, start the Debug Dry Run configuration (F5) and you'll be prompted
to select a package manager and a repository to perform a dry run on.
Feel free to place breakpoints on the code.
There is also support to debug individual test runs by running the Debug Tests configuration (F5)
and you'll be prompted to select an ecosystem and provide an rspec path.
⚠️ The Clone Repository ... commands of the Remote Containers extension are currently
missing some functionality and are therefore not supported. You have to clone the
repository manually and use the Reopen in Container or Open Folder in Container...
command.
Running Tests
Once you get the development environment for a particular ecosystem going,
execute the tests for that ecosystem by running rspec spec inside that ecosystem's folder, e.g.
$ cd go_modules
$ rspec spec
You can also limit the tests to only the file you're working on, or only tests that previously failed, for example:
Style is enforced by RuboCop. To check for style violations, simply run rubocop in
each of the packages, e.g.
$ cd go_modules
$ rubocop
Profiling
You can profile a dry-run by passing the --profile flag when running it, or tag an rspec test with :profile.
This will generate a stackprof-.dump file in the tmp/ folder, and you can generate a flamegraph from this
by running:
Dependabot-Core is a collection of Ruby packages (gems), which contain the logic for updating dependencies in several languages.
dependabot-common
The common package contains all general-purpose/shared functionality. For instance, the code for creating pull
requests for the different supported platforms lives here, as does most of the logic for handling Git dependencies (as
most languages support Git dependencies in one way or another). There are also base classes defined for each of the
major concerns required to implement support for a language or package manager.
dependabot-{package-manager}
There is a gem for each package manager or language that Dependabot
supports. At a minimum, each of these gems will implement the following
classes:
Service Description
FileFetcher Fetches the relevant dependency files for a project (e.g., the Gemfile and Gemfile.lock). See the README for more details.
FileParser Parses a dependency file and extracts a list of dependencies for a project. See the README for more details.
UpdateChecker Checks whether a given dependency is up-to-date. See the README for more details.
FileUpdater Updates a dependency file to use the latest version of a given dependency. See the README for more details.
MetadataFinder Looks up metadata about a dependency, such as its GitHub URL. See the README for more details.
Version Describes the logic for comparing dependency versions. See the hex Version class for an example.
Requirement Describes the format of a dependency requirement (e.g. >= 1.2.3). See the hex Requirement class for an example.
The high-level flow looks like this:
dependabot-omnibus
This is a "meta" gem, that simply depends on all the others. If you want to
automatically include support for all languages, you can just include this gem
and you'll get all you need.
Private Registry Credential Management
For many ecosystems, Dependabot-Core supports private registries. Sometimes this happens by passing the private registry
credentials directly to the native package managers (npm, pip, bundler, etc), other times it happens within the
Dependabot-Core Ruby code.
While simple and straightforward, this is a security risk for ecosystems that allow running untrusted code within their
manifest files. For example setup.py and .gemspec allow running native Python and Ruby code. If a package in the
dependency tree gets hacked, an attacker could push a malicious manifest that forces the native package manager to
expose the creds.
To guard against this, for the Dependabot service that Github runs, we wrap Dependabot-Core with a credential proxy so
those private registry secrets are never exposed to Dependabot-Core.
sequenceDiagram
Dependabot-Core->>Credentials Proxy: All requests are unauthenticated
Credentials Proxy->>Package Registries: Creds are injected by the Proxy
Note left of Dependabot-Core: The Dependabot Service that GitHub Runs
Package Registries->>Credentials Proxy: Creds are stripped by the Proxy
Credentials Proxy->>Dependabot-Core: Dependabot-Core never sees private registry credentials
This also means if Dependabot-Core ever has a security vulnerability, those creds are still not at risk of being exposed.
Trademarks
This project may contain trademarks or logos for projects, products, or services. Authorized use of GitHub trademarks or logos is
subject to and must follow GitHub Logos and Usage. Use of GitHub trademarks or logos in modified versions of this project must not
cause confusion or imply GitHub sponsorship. Any use of third-party trademarks or logos are subject to those third-party’s policies.
History
Dependabot and dependabot-core started life as Bump and
Bump Core, back when @hmarr and @greysteil were working at
GoCardless.
Dependabot became a part of GitHub in 2019!
Notes for project maintainers
:book: Release guide
Publish a new release to RubyGems by running the Gems - Bump Version workflow and following the instructions on the job summary.
In a nutshell the process will be:
Run the action to generate a version bump PR.
Merge the PR.
Tag that merge commit as a new release using the format v1.2.3. The job summary contains a URL pre-populated with the correct version for the title and tag.
Once the release is tagged, another GitHub Action workflow automatically pushes it to RubyGems.
