google-cloud-debugger 0.32.3 → 0.32.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7059138deab6099684889719b6af36b209492140bc3785b0fe530fce128d9211
-  data.tar.gz: e2b0dc554a33bf6b435ac24a0f93c6338c9db3a5e46bcf8fe7d9db89e7daca98
+  metadata.gz: c8b1380c75bf6566f1a41cdcbd967b7549d5f93e0bc69b65897824c07946fffc
+  data.tar.gz: c28da13606c56e600413454b0c2f6df47f947288142747b066a61bc84481c8f2
 SHA512:
-  metadata.gz: 7b2299fac639c19c388e84f8e522388a8b175d22a522b1f60ea372102dbfc4a6767b2f6094ba69af40d5dec1e2cbb256655adfdf6474516d3c6a52b12eb6a162
-  data.tar.gz: efb19ac91c9b94fc6df8ae4af497bc20fb9d3edb96b6b554093e989d2db5ae7b74eb77f34c785f9f280d9db38ef3a91aa2bcb270a1f1014ea90a1e7589338258
+  metadata.gz: a18db0dd6ade022ebc0a25068a7dda6813040d495a859f5baf313c76f685c6d43d540796f036bf123cf9aa64d2f6c549c8aebe8efcb7ec437b25fcea0dec0a02
+  data.tar.gz: 7c5fa5db5fbeada5e5ea7d2a60d185979d498e9b6ec49d97f179d7a076f5eb4e0e897d017e4151bca10d4e61784f9bbd1a7aa2644194052a8d3ead758d581979

data/AUTHENTICATION.md

@@ -0,0 +1,178 @@
+# Authentication
+
+In general, the google-cloud-debugger library uses [Service
+Account](https://cloud.google.com/iam/docs/creating-managing-service-accounts)
+credentials to connect to Google Cloud services. When running on Compute Engine
+the credentials will be discovered automatically. When running on other
+environments, the Service Account credentials can be specified by providing the
+path to the [JSON
+keyfile](https://cloud.google.com/iam/docs/managing-service-account-keys) for
+the account (or the JSON itself) in environment variables. Additionally, Cloud
+SDK credentials can also be discovered automatically, but this is only
+recommended during development.
+
+## Project and Credential Lookup
+
+The google-cloud-debugger library aims to make authentication as simple as
+possible, and provides several mechanisms to configure your system without
+providing **Project ID** and **Service Account Credentials** directly in code.
+
+**Project ID** is discovered in the following order:
+
+1. Specify project ID in method arguments
+2. Specify project ID in configuration
+3. Discover project ID in environment variables
+4. Discover GCE project ID
+
+**Credentials** are discovered in the following order:
+
+1. Specify credentials in method arguments
+2. Specify credentials in configuration
+3. Discover credentials path in environment variables
+4. Discover credentials JSON in environment variables
+5. Discover credentials file in the Cloud SDK's path
+6. Discover GCE credentials
+
+### Google Cloud Platform environments
+
+While running on Google Cloud Platform environments such as Google Compute
+Engine, Google App Engine and Google Kubernetes Engine, no extra work is needed.
+The **Project ID** and **Credentials** and are discovered automatically. Code
+should be written as if already authenticated. Just be sure when you [set up the
+GCE instance][gce-how-to], you add the correct scopes for the APIs you want to
+access. For example:
+
+  * **All APIs**
+    * `https://www.googleapis.com/auth/cloud-platform`
+    * `https://www.googleapis.com/auth/cloud-platform.read-only`
+  * **BigQuery**
+    * `https://www.googleapis.com/auth/bigquery`
+    * `https://www.googleapis.com/auth/bigquery.insertdata`
+  * **Compute Engine**
+    * `https://www.googleapis.com/auth/compute`
+  * **Datastore**
+    * `https://www.googleapis.com/auth/datastore`
+    * `https://www.googleapis.com/auth/userinfo.email`
+  * **DNS**
+    * `https://www.googleapis.com/auth/ndev.clouddns.readwrite`
+  * **Pub/Sub**
+    * `https://www.googleapis.com/auth/pubsub`
+  * **Storage**
+    * `https://www.googleapis.com/auth/devstorage.full_control`
+    * `https://www.googleapis.com/auth/devstorage.read_only`
+    * `https://www.googleapis.com/auth/devstorage.read_write`
+
+### Environment Variables
+
+The **Project ID** and **Credentials JSON** can be placed in environment
+variables instead of declaring them directly in code. Each service has its own
+environment variable, allowing for different service accounts to be used for
+different services. (See the READMEs for the individual service gems for
+details.) The path to the **Credentials JSON** file can be stored in the
+environment variable, or the **Credentials JSON** itself can be stored for
+environments such as Docker containers where writing files is difficult or not
+encouraged.
+
+The environment variables that Debugger checks for project ID are:
+
+1. `DEBUGGER_PROJECT`
+2. `GOOGLE_CLOUD_PROJECT`
+
+The environment variables that Debugger checks for credentials are configured on {Google::Cloud::Debugger::V2::Credentials}:
+
+1. `DEBUGGER_CREDENTIALS` - Path to JSON file, or JSON contents
+2. `DEBUGGER_KEYFILE` - Path to JSON file, or JSON contents
+3. `GOOGLE_CLOUD_CREDENTIALS` - Path to JSON file, or JSON contents
+4. `GOOGLE_CLOUD_KEYFILE` - Path to JSON file, or JSON contents
+5. `GOOGLE_APPLICATION_CREDENTIALS` - Path to JSON file
+
+```ruby
+require "google/cloud/debugger"
+
+ENV["DEBUGGER_PROJECT"]     = "my-project-id"
+ENV["DEBUGGER_CREDENTIALS"] = "path/to/keyfile.json"
+
+debugger = Google::Cloud::Debugger.new
+```
+
+### Configuration
+
+The **Project ID** and **Credentials JSON** can be configured instead of placing them in environment variables or providing them as arguments.
+
+```ruby
+require "google/cloud/debugger"
+
+Google::Cloud::Debugger.configure do |config|
+  config.project_id  = "my-project-id"
+  config.credentials = "path/to/keyfile.json"
+end
+
+debugger = Google::Cloud::Debugger.new
+```
+
+### Cloud SDK
+
+This option allows for an easy way to authenticate during development. If
+credentials are not provided in code or in environment variables, then Cloud SDK
+credentials are discovered.
+
+To configure your system for this, simply:
+
+1. [Download and install the Cloud SDK](https://cloud.google.com/sdk)
+2. Authenticate using OAuth 2.0 `$ gcloud auth login`
+3. Write code as if already authenticated.
+
+**NOTE:** This is _not_ recommended for running in production. The Cloud SDK
+*should* only be used during development.
+
+[gce-how-to]: https://cloud.google.com/compute/docs/authentication#using
+[dev-console]: https://console.cloud.google.com/project
+
+[enable-apis]: https://raw.githubusercontent.com/GoogleCloudPlatform/gcloud-common/master/authentication/enable-apis.png
+
+[create-new-service-account]: https://raw.githubusercontent.com/GoogleCloudPlatform/gcloud-common/master/authentication/create-new-service-account.png
+[create-new-service-account-existing-keys]: https://raw.githubusercontent.com/GoogleCloudPlatform/gcloud-common/master/authentication/create-new-service-account-existing-keys.png
+[reuse-service-account]: https://raw.githubusercontent.com/GoogleCloudPlatform/gcloud-common/master/authentication/reuse-service-account.png
+
+## Creating a Service Account
+
+Google Cloud requires a **Project ID** and **Service Account Credentials** to
+connect to the APIs. You will use the **Project ID** and **JSON key file** to
+connect to most services with google-cloud-debugger.
+
+If you are not running this client on Google Compute Engine, you need a Google
+Developers service account.
+
+1. Visit the [Google Developers Console][dev-console].
+1. Create a new project or click on an existing project.
+1. Activate the slide-out navigation tray and select **API Manager**. From
+   here, you will enable the APIs that your application requires.
+
+   ![Enable the APIs that your application requires][enable-apis]
+
+   *Note: You may need to enable billing in order to use these services.*
+
+1. Select **Credentials** from the side navigation.
+
+   You should see a screen like one of the following.
+
+   ![Create a new service account][create-new-service-account]
+
+   ![Create a new service account With Existing Keys][create-new-service-account-existing-keys]
+
+   Find the "Add credentials" drop down and select "Service account" to be
+   guided through downloading a new JSON key file.
+
+   If you want to re-use an existing service account, you can easily generate a
+   new key file. Just select the account you wish to re-use, and click "Generate
+   new JSON key":
+
+   ![Re-use an existing service account][reuse-service-account]
+
+   The key file you download will be used by this library to authenticate API
+   requests and should be stored in a secure location.
+
+## Troubleshooting
+
+If you're having trouble authenticating you can ask for help by following the
+{file:TROUBLESHOOTING.md Troubleshooting Guide}.

data/CHANGELOG.md

@@ -0,0 +1,95 @@
+# Release History
+
+### 0.32.4 / 2018-09-12
+
+* Add missing documentation files to package.
+
+### 0.32.3 / 2018-09-10
+
+* Update documentation.
+
+### 0.32.2 / 2018-08-21
+
+* Update documentation.
+
+### 0.32.1 / 2018-07-05
+
+* Fix issue when disabling Stackdriver components with Rails.env.production.
+* Add documentation for enabling gRPC logging.
+
+### 0.32.0 / 2018-05-24
+
+* Delay starting the debugger agent until the first request to ensure it
+  happens after workers are forked. Should prevent grpc from malfunctioning in
+  this case.
+
+### 0.31.0 / 2018-02-27
+
+* Use Google Cloud Shared Configuration.
+* Fix for mutation detection using Ruby 2.5.
+* Support disabling mutation detection in debugger evaluation.
+
+### 0.30.0 / 2017-12-19
+
+* Update google-gax dependency to 1.0.
+
+### 0.29.1 / 2017-11-15
+
+* Fix credentials verification bug in Railtie.
+
+### 0.29.0 / 2017-11-14
+
+* Add `Google::Cloud::Debugger::Credentials` class.
+* Rename constructor arguments to `project_id` and `credentials`.
+  (The previous arguments `project` and `keyfile` are still supported.)
+* Document `Google::Auth::Credentials` as `credentials` value.
+* Add Debugger Agent Design Document.
+* Updated `google-gax` (`grpc`, `google-protobuf`), `googleauth` dependencies.
+
+### 0.28.2 / 2017-09-28
+
+* Improve Breakpoint tracer performance by not tracking C function calls in file tracing.
+* Add a backoff behavior in the debuggee registration to reduce spamming requests when registrations fail.
+
+### 0.28.1 / 2017-09-08
+
+* Print captured exception from asynchronous worker threads.
+
+### 0.28.0 / 2017-08-25
+
+* Support single file Rack-based applications.
+* Support none-Rack-based Ruby applications.
+* API Breaking Change:
+    * `module_name` initialization parameter renamed to `service_name`
+    * `module_version` initialization parameter renamed to `module_version`
+
+### 0.27.0 / 2017-08-07
+
+* Optimize breakpoint evaluation memory usage by adopting shared variable table.
+* Update breakpoint to error state if the breakpoint is set at an invalid position or
+    if condition evaluation fail with an error.
+* Set errored variable evaluation to error state.
+* Restrict the amount of time spent on evaluating breakpoints within each rack application request.
+* Restrict total memory usage on collecting variables within each breakpoint evaluation. Prioritize
+    memory allocation to user defined variables over local variables.
+
+### 0.26.1 / 2017-07-11
+
+* stackdriver-core 1.2.0 release
+
+### 0.26.0 / 2017-07-11
+
+* Update GAPIC configuration to exclude `UNAVAILABLE` errors from automatic retry.
+
+### 0.25.0 / 2017-05-25
+
+* Introduce new `Google::Cloud::Debugger.configure` instrumentation configuration interface.
+
+### 0.24.1 / 2017-04-07
+
+* Fixed Google::Cloud::Debugger::Railtie initialization on non-GCP environments
+    to not interfere with Rails startup
+
+### 0.24.0 / 2017-04-06
+
+* First release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,40 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, and in the interest of
+fostering an open and welcoming community, we pledge to respect all people who
+contribute through reporting issues, posting feature requests, updating
+documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free
+experience for everyone, regardless of level of experience, gender, gender
+identity and expression, sexual orientation, disability, personal appearance,
+body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic
+  addresses, without explicit permission
+* Other unethical or unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct. By adopting this Code of Conduct, project
+maintainers commit themselves to fairly and consistently applying these
+principles to every aspect of managing this project. Project maintainers who do
+not follow or enforce the Code of Conduct may be permanently removed from the
+project team.
+
+This code of conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by opening an issue or contacting one or more of the project
+maintainers.
+
+This Code of Conduct is adapted from the [Contributor
+Covenant](http://contributor-covenant.org), version 1.2.0, available at
+[http://contributor-covenant.org/version/1/2/0/](http://contributor-covenant.org/version/1/2/0/)

data/CONTRIBUTING.md

@@ -0,0 +1,188 @@
+# Contributing to Google Cloud Debugger
+
+1. **Sign one of the contributor license agreements below.**
+2. Fork the repo, develop and test your code changes.
+3. Send a pull request.
+
+## Contributor License Agreements
+
+Before we can accept your pull requests you'll need to sign a Contributor
+License Agreement (CLA):
+
+- **If you are an individual writing original source code** and **you own the
+  intellectual property**, then you'll need to sign an [individual
+  CLA](https://developers.google.com/open-source/cla/individual).
+- **If you work for a company that wants to allow you to contribute your work**,
+  then you'll need to sign a [corporate
+  CLA](https://developers.google.com/open-source/cla/corporate).
+
+You can sign these electronically (just scroll to the bottom). After that, we'll
+be able to accept your pull requests.
+
+## Setup
+
+In order to use the google-cloud-debugger console and run the project's tests,
+there is a small amount of setup:
+
+1. Install Ruby. google-cloud-debugger requires Ruby 2.3+. You may choose to
+   manage your Ruby and gem installations with [RVM](https://rvm.io/),
+   [rbenv](https://github.com/rbenv/rbenv), or
+   [chruby](https://github.com/postmodern/chruby).
+
+2. Install [Bundler](http://bundler.io/).
+
+   ```sh
+   $ gem install bundler
+   ```
+
+3. Install the top-level project dependencies.
+
+   ```sh
+   $ bundle install
+   ```
+
+4. Install the Debugger dependencies.
+
+   ```sh
+   $ cd google-cloud-debugger/
+   $ bundle exec rake bundleupdate
+   ```
+
+## Console
+
+In order to run code interactively, you can automatically load
+google-cloud-debugger and its dependencies in IRB. This requires that your
+developer environment has already been configured by following the steps
+described in the {file:AUTHENTICATION.md Authentication Guide}. An IRB console
+can be created with:
+
+```sh
+$ cd google-cloud-debugger/
+$ bundle exec rake console
+```
+
+## Debugger Tests
+
+Tests are very important part of google-cloud-debugger. All contributions
+should include tests that ensure the contributed code behaves as expected.
+
+To run the unit tests, documentation tests, and code style checks together for a
+package:
+
+``` sh
+$ cd google-cloud-debugger/
+$ bundle exec rake ci
+```
+
+To run the command above, plus all acceptance tests, use `rake ci:acceptance` or
+its handy alias, `rake ci:a`.
+
+### Debugger Unit Tests
+
+
+The project uses the [minitest](https://github.com/seattlerb/minitest) library,
+including [specs](https://github.com/seattlerb/minitest#specs),
+[mocks](https://github.com/seattlerb/minitest#mocks) and
+[minitest-autotest](https://github.com/seattlerb/minitest-autotest).
+
+To run the Debugger unit tests:
+
+``` sh
+$ cd google-cloud-debugger/
+$ bundle exec rake test
+```
+
+### Debugger Documentation Tests
+
+The project tests the code examples in the gem's
+[YARD](https://github.com/lsegal/yard)-based documentation.
+
+The example testing functions in a way that is very similar to unit testing, and
+in fact the library providing it,
+[yard-doctest](https://github.com/p0deje/yard-doctest), is based on the
+project's unit test library, [minitest](https://github.com/seattlerb/minitest).
+
+To run the Debugger documentation tests:
+
+``` sh
+$ cd google-cloud-debugger/
+$ bundle exec rake doctest
+```
+
+If you add, remove or modify documentation examples when working on a pull
+request, you may need to update the setup for the tests. The stubs and mocks
+required to run the tests are located in `support/doctest_helper.rb`. Please
+note that much of the setup is matched by the title of the
+[`@example`](http://www.rubydoc.info/gems/yard/file/docs/Tags.md#example) tag.
+If you alter an example's title, you may encounter breaking tests.
+
+### Debugger Acceptance Tests
+
+The Debugger acceptance tests interact with the live service API. Follow the
+instructions in the {file:AUTHENTICATION.md Authentication guide} for enabling
+the Debugger API. Occasionally, some API features may not yet be generally
+available, making it difficult for some contributors to successfully run the
+entire acceptance test suite. However, please ensure that you do successfully
+run acceptance tests for any code areas covered by your pull request.
+
+To run the acceptance tests, first create and configure a project in the Google
+Developers Console, as described in the {file:AUTHENTICATION.md Authentication
+guide}. Be sure to download the JSON KEY file. Make note of the PROJECT_ID and
+the KEYFILE location on your system.
+
+Before you can run the Debugger acceptance tests, you must first create indexes
+used in the tests.
+
+#### Running the Debugger acceptance tests
+
+To run the Debugger acceptance tests:
+
+``` sh
+$ cd google-cloud-debugger/
+$ bundle exec rake acceptance[\\{my-project-id},\\{/path/to/keyfile.json}]
+```
+
+Or, if you prefer you can store the values in the `GCLOUD_TEST_PROJECT` and
+`GCLOUD_TEST_KEYFILE` environment variables:
+
+``` sh
+$ cd google-cloud-debugger/
+$ export GCLOUD_TEST_PROJECT=\\{my-project-id}
+$ export GCLOUD_TEST_KEYFILE=\\{/path/to/keyfile.json}
+$ bundle exec rake acceptance
+```
+
+If you want to use a different project and credentials for acceptance tests, you
+can use the more specific `DEBUGGER_TEST_PROJECT`  and `DEBUGGER_TEST_KEYFILE`
+environment variables:
+
+``` sh
+$ cd google-cloud-debugger/
+$ export DEBUGGER_TEST_PROJECT=\\{my-project-id}
+$ export DEBUGGER_TEST_KEYFILE=\\{/path/to/keyfile.json}
+$ bundle exec rake acceptance
+```
+
+## Coding Style
+
+Please follow the established coding style in the library. The style is is
+largely based on [The Ruby Style
+Guide](https://github.com/bbatsov/ruby-style-guide) with a few exceptions based
+on seattle-style:
+
+* Avoid parenthesis when possible, including in method definitions.
+* Always use double quotes strings. ([Option
+  B](https://github.com/bbatsov/ruby-style-guide#strings))
+
+You can check your code against these rules by running Rubocop like so:
+
+```sh
+$ cd google-cloud-debugger/
+$ bundle exec rake rubocop
+```
+
+## Code of Conduct
+
+Please note that this project is released with a Contributor Code of Conduct. By
+participating in this project you agree to abide by its terms. See
+{file:CODE_OF_CONDUCT.md Code of Conduct} for more information.

data/INSTRUMENTATION.md

@@ -0,0 +1,115 @@
+# Stackdriver Debugger Instrumentation
+
+Stackdriver Debugger is a feature of the Google Cloud Platform that lets
+you inspect the state of an application at any code location without using
+logging statements and without stopping or slowing down your applications.
+Your users are not impacted during debugging. Using the production
+debugger you can capture the local variables and call stack and link it
+back to a specific line location in your source code. You can use this to
+analyze the production state of your application and understand the
+behavior of your code in production.
+
+For general information about Stackdriver Debugger, read [Stackdriver
+Debugger Documentation](https://cloud.google.com/debugger/docs/).
+
+The Stackdriver Debugger Ruby library, `google-cloud-debugger`, provides an
+easy-to-use debugger instrumentation that reports state data, such as
+value of program variables and the call stack, to Stackdriver Debugger
+when the code at a breakpoint location is executed in your Ruby
+application. See the [instrumenting your app](#instrumenting-your-app)
+section for how to debug your application, in both development and production.
+
+## Instrumenting Your App
+
+This instrumentation library provides the following features to help you
+debug your applications in production:
+
+*   Automatic application registration. It facilitates multiple running
+    instances of same version of application when hosted in production.
+*   A background debugger agent that runs side-by-side with your
+    application that automatically collects state data when code is
+    executed at breakpoint locations.
+*   A Rack middleware and Railtie that automatically manages the debugger
+    agent for Ruby on Rails and other Rack-based Ruby applications.
+
+When this library is configured in your running application, and the
+source code and breakpoints are setup through the Google Cloud Console,
+You'll be able to
+[interact](https://cloud.google.com/debugger/docs/debugging) with your
+application in real time through the [Stackdriver Debugger 
+UI](https://console.cloud.google.com/debug?_ga=1.84295834.280814654.1476313407).
+This library also integrates with Google App Engine Flexible to make debuggee
+application configuration more seemless.
+
+Note that when no breakpoints are created, the debugger agent consumes
+very little resource and has no interference with the running application.
+Once breakpoints are created and depends on where the breakpoints are
+located, the debugger agent may add a little latency onto each request.
+The application performance will be back to normal after all breakpoints
+are finished being evaluated. Be aware the more breakpoints are created,
+or the harder to reach the breakpoints, the more resource the debugger
+agent would need to consume.
+
+### Configuration
+
+The default configuration enables Stackdriver instrumentation features to run on
+Google Cloud Platform. You can easily configure the instrumentation library if 
+you want to run on a non Google Cloud environment or you want to customize 
+the default behavior.
+
+See the
+[Configuration Guide](https://googlecloudplatform.github.io/google-cloud-ruby/#/docs/stackdriver/guides/instrumentation_configuration)
+for full configuration parameters.
+
+### Using instrumentation with Ruby on Rails
+
+To install application instrumentation in your Ruby on Rails app, add this
+gem, `google-cloud-debugger`, to your Gemfile and update your bundle. Then
+add the following line to your `config/application.rb` file:
+
+```ruby
+require "google/cloud/debugger/rails"
+```
+
+This will load a Railtie that automatically integrates with the Rails
+framework by injecting a Rack middleware. 
+
+### Using instrumentation with Sinatra
+
+To install application instrumentation in your Sinatra app, add this gem,
+`google-cloud-debugger`, to your Gemfile and update your bundle. Then add
+the following lines to your main application Ruby file:
+
+```ruby
+require "google/cloud/debugger"
+use Google::Cloud::Debugger::Middleware
+```
+
+This will install the debugger middleware in your application.
+
+### Using instrumentation with other Rack-based frameworks
+
+To install application instrumentation in an app using another Rack-based
+web framework, add this gem, `google-cloud-debugger`, to your Gemfile and
+update your bundle. Then add install the debugger middleware in your
+middleware stack. In most cases, this means adding these lines to your
+`config.ru` Rack configuration file:
+
+```ruby
+require "google/cloud/debugger"
+use Google::Cloud::Debugger::Middleware
+```
+
+Some web frameworks have an alternate mechanism for modifying the
+middleware stack. Consult your web framework's documentation for more
+information.
+
+### The Stackdriver diagnostics suite
+
+The debugger library is part of the Stackdriver diagnostics suite, which
+also includes error reporting, log analysis, and tracing analysis. If you
+include the `stackdriver` gem in your Gemfile, this debugger library will
+be included automatically. In addition, if you include the `stackdriver`
+gem in an application using Ruby On Rails, the Railties will be installed
+automatically. See the documentation for the "stackdriver" gem
+for more details.

data/LOGGING.md

@@ -0,0 +1,32 @@
+# Enabling gRPC Logging
+
+To enable logging for this library, set the logger for the underlying
+[gRPC](https://github.com/grpc/grpc/tree/master/src/ruby) library. The logger
+that you set may be a Ruby stdlib
+[`Logger`](https://ruby-doc.org/stdlib-2.5.0/libdoc/logger/rdoc/Logger.html) as
+shown below, or a
+[`Google::Cloud::Logging::Logger`](https://googlecloudplatform.github.io/google-cloud-ruby/docs/google-cloud-logging/latest/Google/Cloud/Logging/Logger)
+that will write logs to [Stackdriver
+Logging](https://cloud.google.com/logging/). See
+[grpc/logconfig.rb](https://github.com/grpc/grpc/blob/master/src/ruby/lib/grpc/logconfig.rb)
+and the gRPC
+[spec_helper.rb](https://github.com/grpc/grpc/blob/master/src/ruby/spec/spec_helper.rb)
+for additional information.
+
+Configuring a Ruby stdlib logger:
+
+```ruby
+require "logger"
+
+module MyLogger
+  LOGGER = Logger.new $stderr, level: Logger::WARN
+  def logger
+    LOGGER
+  end
+end
+
+# Define a gRPC module-level logger method before grpc/logconfig.rb loads.
+module GRPC
+  extend MyLogger
+end
+```

data/OVERVIEW.md

@@ -0,0 +1,297 @@
+# Stackdriver Debugger
+
+Stackdriver Debugger is a feature of the Google Cloud Platform that lets you
+inspect the state of an application at any code location without using logging
+statements and without stopping or slowing down your applications. Your users
+are not impacted during debugging. Using the production debugger you can capture
+the local variables and call stack and link it back to a specific line location
+in your source code. You can use this to analyze the production state of your
+application and understand the behavior of your code in production.
+
+For general information about Stackdriver Debugger, read [Stackdriver Debugger
+Documentation](https://cloud.google.com/debugger/docs/).
+
+The Stackdriver Debugger Ruby library, `google-cloud-debugger`, provides:
+
+* Easy-to-use debugger instrumentation that reports state data, such as value of
+  program variables and the call stack, to Stackdriver Debugger when the code at
+  a breakpoint location is executed in your Ruby application. See the
+  [instrumenting your app](#instrumenting-your-app) section for how to debug
+  your application, in both development and production.
+* An idiomatic Ruby API for registerying debuggee application, and querying or
+  manipulating breakpoints in registered Ruby debuggee application. See
+  [Debugger API](#stackdriver-debugger-api) section for an introduction to
+  Stackdriver Debugger API.
+
+## Instrumenting Your App
+
+This instrumentation library provides the following features to help you debug
+your applications in production:
+
+* Automatic application registration. It facilitates multiple running instances
+  of same version of application when hosted in production.
+* A background debugger agent that runs side-by-side with your application that
+  automatically collects state data when code is executed at breakpoint
+  locations.
+* A Rack middleware and Railtie that automatically manages the debugger agent
+  for Ruby on Rails and other Rack-based Ruby applications.
+
+When this library is configured in your running application, and the source code
+and breakpoints are setup through the Google Cloud Console, You'll be able to
+[interact](https://cloud.google.com/debugger/docs/debugging) with your
+application in real time through the [Stackdriver Debugger
+UI](https://console.cloud.google.com/debug?_ga=1.84295834.280814654.1476313407).
+This library also integrates with Google App Engine Flexible to make debuggee
+application configuration more seemless.
+
+Note that when no breakpoints are created, the debugger agent consumes very
+little resource and has no interference with the running application. Once
+breakpoints are created and depends on where the breakpoints are located, the
+debugger agent may add a little latency onto each request. The application
+performance will be back to normal after all breakpoints are finished being
+evaluated. Be aware the more breakpoints are created, or the harder to reach the
+breakpoints, the more resource the debugger agent would need to consume.
+
+### Using instrumentation with Ruby on Rails
+
+To install application instrumentation in your Ruby on Rails app, add this gem,
+`google-cloud-debugger`, to your Gemfile and update your bundle. Then add the
+following line to your `config/application.rb` file:
+
+```ruby
+require "google/cloud/debugger/rails"
+```
+
+This will load a Railtie that automatically integrates with the Rails framework
+by injecting a Rack middleware. The Railtie also takes in the following Rails
+configuration as parameter of the debugger agent initialization:
+
+```ruby
+# Explicitly enable or disable Stackdriver Debugger Agent
+config.google_cloud.use_debugger = true
+# Shared Google Cloud Platform project identifier
+config.google_cloud.project_id = "gcloud-project"
+# Google Cloud Platform project identifier for Stackdriver Debugger only
+config.google_cloud.debugger.project_id = "debugger-project"
+# Shared Google Cloud authentication json file
+config.google_cloud.keyfile = "/path/to/keyfile.json"
+# Google Cloud authentication json file for Stackdriver Debugger only
+config.google_cloud.debugger.keyfile = "/path/to/debugger/keyfile.json"
+# Stackdriver Debugger Agent service name identifier
+config.google_cloud.debugger.service_name = "my-ruby-app"
+# Stackdriver Debugger Agent service version identifier
+config.google_cloud.debugger.service_version = "v1"
+```
+
+See the {Google::Cloud::Debugger::Railtie} class for more information.
+
+### Using instrumentation with Sinatra
+
+To install application instrumentation in your Sinatra app, add this gem,
+`google-cloud-debugger`, to your Gemfile and update your bundle. Then add the
+following lines to your main application Ruby file:
+
+```ruby
+require "google/cloud/debugger"
+use Google::Cloud::Debugger::Middleware
+```
+
+This will install the debugger middleware in your application.
+
+Configuration parameters may also be passed in as arguments to Middleware.
+
+```ruby
+require "google/cloud/debugger"
+use Google::Cloud::Debugger::Middleware project: "debugger-project-id",
+                                        keyfile: "/path/to/keyfile.json",
+                                        service_name: "my-ruby-app",
+                                        service_version: "v1"
+```
+
+### Using instrumentation with other Rack-based frameworks
+
+To install application instrumentation in an app using another Rack-based web
+framework, add this gem, `google-cloud-debugger`, to your Gemfile and update
+your bundle. Then add install the debugger middleware in your middleware stack.
+In most cases, this means adding these lines to your `config.ru` Rack
+configuration file:
+
+```ruby
+require "google/cloud/debugger"
+use Google::Cloud::Debugger::Middleware
+```
+
+Some web frameworks have an alternate mechanism for modifying the middleware
+stack. Consult your web framework's documentation for more information.
+
+### The Stackdriver diagnostics suite
+
+The debugger library is part of the Stackdriver diagnostics suite, which also
+includes error reporting, log analysis, and tracing analysis. If you include the
+`stackdriver` gem in your Gemfile, this debugger library will be included
+automatically. In addition, if you include the `stackdriver` gem in an
+application using Ruby On Rails, the Railties will be installed automatically.
+See the documentation for the "stackdriver" gem for more details.
+
+## Stackdriver Debugger API
+
+This library also includes an easy to use Ruby client for the Stackdriver
+Debugger API. This API provides calls to register debuggee application, as well
+as creating or modifying breakpoints.
+
+For further information on the Debugger API, see
+{Google::Cloud::Debugger::Project}
+
+### Registering debuggee application
+
+```ruby
+require "google/cloud/debugger/v2"
+
+Controller2Client = Google::Cloud::Debugger::V2::Controller2Client
+Debuggee = Google::Devtools::Clouddebugger::V2::Debuggee
+
+controller2_client = Controller2Client.new
+debuggee = Debuggee.new
+response = controller2_client.register_debuggee(debuggee)
+debuggee_id = response.debuggee.id
+```
+See [Stackdriver Debugger Debuggee
+doc](https://cloud.google.com/debugger/api/reference/rpc/google.devtools.clouddebugger.v2#google.devtools.clouddebugger.v2.Debuggee)
+on fields necessary for registerying a debuggee.
+
+Upon successful registration, the response debuggee object will contain a
+debuggee_id that's later needed to interact with the other Stackdriver Debugger
+API.
+
+See {Google::Cloud::Debugger::V2::Controller2Client} for details.
+
+### List Active Breakpoints
+
+```ruby
+require "google/cloud/debugger/v2"
+
+Controller2Client = Google::Cloud::Debugger::V2::Controller2Client
+controller2_client = Controller2Client.new
+
+debuggee_id = ''
+response = controller2_client.list_active_breakpoints(debuggee_id)
+breakpoints = response.breakpoints
+```
+
+See {Google::Cloud::Debugger::V2::Controller2Client} for details.
+
+### Update Active Breakpoint
+
+Users can send custom snapshots for active breakpoints using this API.
+
+```ruby
+require "google/cloud/debugger/v2"
+
+Breakpoint = Google::Devtools::Clouddebugger::V2::Breakpoint
+Controller2Client = Google::Cloud::Debugger::V2::Controller2Client
+
+controller2_client = Controller2Client.new
+debuggee_id = ''
+breakpoint = Breakpoint.new
+response =
+  controller2_client.update_active_breakpoint(debuggee_id, breakpoint)
+```
+
+See [Stackdriver Debugger Breakpoint
+doc](https://cloud.google.com/debugger/api/reference/rpc/google.devtools.clouddebugger.v2#google.devtools.clouddebugger.v2.Breakpoint)
+for all available fields for breakpoint.
+
+See {Google::Cloud::Debugger::V2::Controller2Client} for details.
+
+### Set Breakpoint
+
+```ruby
+require "google/cloud/debugger/v2"
+
+Breakpoint = Google::Devtools::Clouddebugger::V2::Breakpoint
+Debugger2Client = Google::Cloud::Debugger::V2::Debugger2Client
+
+debugger2_client = Debugger2Client.new
+debuggee_id = ''
+breakpoint = Breakpoint.new
+client_version = ''
+response = debugger2_client.set_breakpoint(
+             debuggee_id, breakpoint, client_version)
+```
+
+See [Stackdriver Debugger Breakpoint
+doc](https://cloud.google.com/debugger/api/reference/rpc/google.devtools.clouddebugger.v2#google.devtools.clouddebugger.v2.Breakpoint)
+for fields needed to specify breakpoint location.
+
+See {Google::Cloud::Debugger::V2::Debugger2Client} for details.
+
+### Get Breakpoint
+
+```ruby
+require "google/cloud/debugger/v2"
+
+Debugger2Client = Google::Cloud::Debugger::V2::Debugger2Client
+
+debugger2_client = Debugger2Client.new
+debuggee_id = ''
+breakpoint_id = ''
+client_version = ''
+response = debugger2_client.get_breakpoint(
+             debuggee_id, breakpoint_id, client_version)
+```
+
+See {Google::Cloud::Debugger::V2::Debugger2Client} for details.
+
+### Delete Breakpoint
+
+```ruby
+require "google/cloud/debugger/v2"
+
+Debugger2Client = Google::Cloud::Debugger::V2::Debugger2Client
+
+debugger2_client = Debugger2Client.new
+debuggee_id = ''
+breakpoint_id = ''
+client_version = ''
+debugger2_client.delete_breakpoint(
+  debuggee_id, breakpoint_id, client_version)
+```
+
+See {Google::Cloud::Debugger::V2::Debugger2Client} for details.
+
+### List Breakpoints
+
+```ruby
+require "google/cloud/debugger/v2"
+
+Debugger2Client = Google::Cloud::Debugger::V2::Debugger2Client
+
+Debugger2Client = Google::Cloud::Debugger::V2::Debugger2Client
+
+debugger2_client = Debugger2Client.new
+debuggee_id = ''
+client_version = ''
+response = debugger2_client.list_breakpoints(debuggee_id, client_version)
+```
+
+See {Google::Cloud::Debugger::V2::Debugger2Client} for details.
+
+### List Debuggees
+
+```ruby
+require "google/cloud/debugger/v2"
+
+Debugger2Client = Google::Cloud::Debugger::V2::Debugger2Client
+
+debugger2_client = Debugger2Client.new
+project = ''
+client_version = ''
+response = debugger2_client.list_debuggees(project, client_version)
+```
+
+See {Google::Cloud::Debugger::V2::Debugger2Client} for details.
+
+## Additional information
+
+Stackdriver Debugger can be configured to use gRPC's logging. To learn more, see
+the {file:LOGGING.md Logging guide}.

data/TROUBLESHOOTING.md

@@ -0,0 +1,37 @@
+# Troubleshooting
+
+## Where can I get more help?
+
+### Ask the Community
+
+If you have a question about how to use a Google Cloud client library in your
+project or are stuck in the Developer's console and don't know where to turn,
+it's possible your questions have already been addressed by the community.
+
+First, check out the appropriate tags on StackOverflow:
+  - [`google-cloud-platform+ruby+debugger`][so-ruby]
+
+Next, try searching through the issues on GitHub:
+
+  - [`api:debugger` issues][gh-search-ruby]
+
+Still nothing?
+
+### Ask the Developers
+
+If you're experiencing a bug with the code, or have an idea for how it can be
+improved, *please* create a new issue on GitHub so we can talk about it.
+
+  - [New issue][gh-ruby]
+
+Or, you can ask questions on the [Google Cloud Platform Slack][slack-ruby]. You
+can use the "ruby" channel for general Ruby questions, or use the
+"google-cloud-ruby" channel if you have questions about this gem in particular.
+
+[so-ruby]: http://stackoverflow.com/questions/tagged/google-cloud-platform+ruby+debugger
+
+[gh-search-ruby]: https://github.com/googlecloudplatform/google-cloud-ruby/issues?q=label%3A%22api%3A+debugger%22
+
+[gh-ruby]: https://github.com/googlecloudplatform/google-cloud-ruby/issues/new
+
+[slack-ruby]: https://gcp-slack.appspot.com/

data/lib/google/cloud/debugger/version.rb

@@ -16,7 +16,7 @@
 module Google
   module Cloud
     module Debugger
-      VERSION = "0.32.3".freeze
+      VERSION = "0.32.4".freeze
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: google-cloud-debugger
 version: !ruby/object:Gem::Version
-  version: 0.32.3
+  version: 0.32.4
 platform: ruby
 authors:
 - Heng Xiong
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-10 00:00:00.000000000 Z
+date: 2018-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: binding_of_caller
@@ -271,8 +271,15 @@ extensions:
 extra_rdoc_files: []
 files:
 - ".yardopts"
+- AUTHENTICATION.md
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- CONTRIBUTING.md
+- INSTRUMENTATION.md
 - LICENSE
-- README.md
+- LOGGING.md
+- OVERVIEW.md
+- TROUBLESHOOTING.md
 - ext/google/cloud/debugger/debugger_c/debugger.c
 - ext/google/cloud/debugger/debugger_c/debugger.h
 - ext/google/cloud/debugger/debugger_c/evaluator.c

data/README.md

@@ -1,286 +0,0 @@
-# google-cloud-debugger
-
-[Stackdriver Debugger](https://cloud.google.com/debugger/) lets you inspect the
-state of a running application at any code location in real time, without
-stopping or slowing down the application, and without modifying the code to add
-logging statements. You can use Stackdriver Debugger with any deployment of
-your application, including test, development, and production. The Ruby
-debugger adds minimal request latency, typically less than 50ms, and only when
-application state is captured. In most cases, this is not noticeable by users.
-
-- [google-cloud-debugger documentation](http://googlecloudplatform.github.io/google-cloud-ruby/docs/google-cloud-debugger/latest)
-- [google-cloud-debugger on RubyGems](https://rubygems.org/gems/google-cloud-debugger)
-- [Stackdriver Debugger documentation](https://cloud.google.com/debugger/docs/)
-
-## Quick Start
-
-### Installing the gem
-
-Add the `google-cloud-debugger` gem to your Gemfile:
-
-```ruby
-gem "google-cloud-debugger"
-```
-
-Alternatively, consider installing the [`stackdriver`](../stackdriver) gem. It
-includes the `google-cloud-debugger` gem as a dependency, and automatically
-initializes it for some application frameworks.
-
-### Initializing the Debugger
-
-The Stackdriver Debugger library provides a Debugger agent that helps create
-breakpoints in your running applications. It then collects application snapshot
-data and transmits it to the Stackdriver Debugger service for you to view on
-the Google Cloud Console. The library also comes with a Railtie and a Rack
-Middleware to help control the Debugger agent in popular Rack based frameworks,
-such as Ruby on Rails and Sinatra.
-
-#### Setup with Ruby on Rails
-
-You can load the Railtie that comes with the library into your Ruby
-on Rails application by explicitly requiring it during the application startup:
-
-```ruby
-# In config/application.rb
-require "google/cloud/debugger/rails"
-```
-
-If you're using the `stackdriver` gem, it automatically loads the Railtie into
-your application when it starts.
-
-#### Setup with other Rack-based frameworks
-
-Other Rack-based frameworks, such as Sinatra, can use the Rack Middleware
-provided by the library:
-
-```ruby
-require "google/cloud/debugger"
-use Google::Cloud::Debugger::Middleware
-```
-
-#### Setup without a Rack-based framework
-
-Non-rack-based applications can start the agent explicitly during the
-initialization code:
-
-```ruby
-require "google/cloud/debugger"
-Google::Cloud::Debugger.new.start
-```
-
-### Connecting to the Debugger
-
-You can set breakpoints and view snapshots using the Google Cloud Console.
-If your app is hosted on Google Cloud (such as on Google App Engine, Google
-Kubernetes Engine, or Google Compute Engine), you can use the same project.
-Otherwise, if your application is hosted elsewhere, create a new project on
-[Google Cloud](https://console.cloud.google.com/).
-
-Make sure the
-[Stackdriver Debugger API](https://console.cloud.google.com/apis/library/clouddebugger.googleapis.com)
-is enabled on your Google Cloud project.
-
-To connect to the Stackdriver Debugger service, the agent needs to be
-authenticated. If your application is hosted on Google Cloud Platform, much of
-this is handled for you automatically.
-
-#### Connecting from Google App Engine (GAE)
-
-If your app is running on Google App Engine, the Stackdriver Debugger agent
-authenticates automatically by default, and no additional configuration is
-required.
-
-#### Connecting from Google Kubernetes Engine (GKE)
-
-If your app is running on Google Kubernetes Engine, you must explicitly add the
-`cloud_debugger` OAuth scope when creating the cluster:
-
-```sh
-$ gcloud container clusters create example-cluster-name --scopes https://www.googleapis.com/auth/cloud_debugger
-```
-
-You can also do this through the Google Cloud Platform Console. Select
-**Enabled** in the Cloud Platform section of **Create a container cluster**.
-
-After the OAuth scope is enabled, the Stackdriver Debugger agent authenticates
-automatically by default, and no additional configuration is required.
-
-#### Connecting from Google Compute Engine (GCE)
-
-If your app is running on Google Compute Engine, its VM instances should have
-one of the following access scopes. These are only relevant when you use
-Compute Engine's default service account:
-
-* `https://www.googleapis.com/auth/cloud-platform`
-* `https://www.googleapis.com/auth/cloud_debugger`
-
-The `cloud-platform` access scope can be supplied when creating a new instance
-through the Google Cloud Platform Console. Select **Allow full access to all
-Cloud APIs** in the **Identity and API access** section of **Create an
-instance**.
-
-The `cloud_debugger` access scope can be supplied manually using the SDK's
-`gcloud compute instances create` command or the `gcloud compute instances
-set-service-account` command.
-
-After the OAuth scope is enabled, the Stackdriver Debugger agent authenticates
-automatically by default using the VM's service account, and no additional
-configuration is required.
-
-#### Connecting from other hosting environments
-
-To run the Stackdriver Debugger agent outside of Google Cloud Platform, you must
-supply your GCP project ID and appropriate service account credentials directly
-to the Stackdriver Debugger agent. This applies to running the agent on your own
-workstation, on your datacenter's computers, or on the VM instances of another
-cloud provider.
-
-The best way to provide authentication information if you're using Ruby on Rails
-is through the Rails configuration interface:
-
-```ruby
-# in config/environments/*.rb
-Rails.application.configure do |config|
-  # Shared parameters
-  config.google_cloud.project_id = "your-project-id"
-  config.google_cloud.credentials = "/path/to/key.json"
-  # Or Stackdriver Debugger agent specific parameters
-  config.google_cloud.debugger.project_id = "your-project-id"
-  config.google_cloud.debugger.credentials = "/path/to/key.json"
-end
-```
-
-Other Rack-based applications that are loading the Rack Middleware directly can
-use the configration interface:
-
-```ruby
-require "google/cloud/debugger"
-Google::Cloud.configure do |config|
-  # Shared parameters
-  config.project_id = "your-project-id"
-  config.credentials = "/path/to/key.json"
-  # Or Stackdriver Debugger agent specific parameters
-  config.debugger.project_id = "your-project-id"
-  config.debugger.credentials = "/path/to/key.json"
-end
-```
-
-Or provide the parameters to the Stackdriver Debugger agent when it starts:
-
-```ruby
-require "google/cloud/debugger"
-Google::Cloud::Debugger.new(project_id: "your-project-id",
-                            credentials: "/path/to/key.json").start
-```
-
-This library also supports the other authentication methods provided by the
-`google-cloud-ruby` suite. Instructions and configuration options are covered
-in the [Authentication Guide](https://googlecloudplatform.github.io/google-cloud-ruby/docs/google-cloud-debugger/latest/file.AUTHENTICATION).
-
-### Using the Debugger
-
-When you set a breakpoint in the Stackdriver Debugger console, the agent takes
-a snapshot of application data when the breakpoint is hit. The application then
-continues running with minimal slowdown, and you can view the snapshot offline
-in the console.
-
-By default, the snapshot includes the local variables from the current and four
-most recent stack frames. You may include additional data in the snapshot by
-providing a list of _expressions_ when you create the breakpoint. Expressions
-may be instance variables, global variables, or the result of calling Ruby
-methods, or indeed, any Ruby expression.
-
-For more information on using the debugger features, see the
-[Stackdriver Debugger Documentation](https://cloud.google.com/debugger/docs/).
-
-#### Working with Mutation Protection
-
-To reduce the risk of corrupting your application data or changing your
-application's behavior, the debugger agent checks all expressions you provide
-for possible side effects before it runs them. If an expression calls any code
-that could modify the program state, by changing an instance variable for
-example, it is not evaluated.
-
-This check is rather conservative, so if you are receiving mutation errors on
-an expression you know to be safe, you may disable the check by wrapping your
-expression in a call to `Google::Cloud::Debugger.allow_mutating_methods!`. For
-example:
-
-```ruby
-Google::Cloud::Debugger.allow_mutating_methods! { my_expression() }
-```
-
-You may disable side effect checks globally by setting the
-`allow_mutating_methods` configuration. See the next section on configuring the
-agent.
-
-#### Configuring the agent
-
-You can customize the behavior of the Stackdriver Debugger agent. This includes
-setting the Google Cloud project and authentication, and customizing the
-behavior of the debugger itself, such as side effect protection and data
-size limits. See [agent configuration](../stackdriver/CONFIGURATION.md)
-for a list of possible configuration options.
-
-## Enabling Logging
-
-To enable logging for this library, set the logger for the underlying [gRPC](https://github.com/grpc/grpc/tree/master/src/ruby) library. The logger that you set may be a Ruby stdlib [`Logger`](https://ruby-doc.org/stdlib-2.5.0/libdoc/logger/rdoc/Logger.html) as shown below, or a [`Google::Cloud::Logging::Logger`](https://googlecloudplatform.github.io/google-cloud-ruby/docs/google-cloud-logging/latest/Google/Cloud/Logging/Logger) that will write logs to [Stackdriver Logging](https://cloud.google.com/logging/). See [grpc/logconfig.rb](https://github.com/grpc/grpc/blob/master/src/ruby/lib/grpc/logconfig.rb) and the gRPC [spec_helper.rb](https://github.com/grpc/grpc/blob/master/src/ruby/spec/spec_helper.rb) for additional information.
-
-Configuring a Ruby stdlib logger:
-
-```ruby
-require "logger"
-
-module MyLogger
-  LOGGER = Logger.new $stderr, level: Logger::WARN
-  def logger
-    LOGGER
-  end
-end
-
-# Define a gRPC module-level logger method before grpc/logconfig.rb loads.
-module GRPC
-  extend MyLogger
-end
-```
-
-## Supported Ruby Versions
-
-This library is supported on Ruby 2.3+.
-
-Google provides official support for Ruby versions that are actively supported
-by Ruby Core—that is, Ruby versions that are either in normal maintenance or in
-security maintenance, and not end of life. Currently, this means Ruby 2.3 and
-later. Older versions of Ruby _may_ still work, but are unsupported and not
-recommended. See https://www.ruby-lang.org/en/downloads/branches/ for details
-about the Ruby support schedule.
-
-This library follows [Semantic Versioning](http://semver.org/). It is currently
-in major version zero (0.y.z), which means that anything may change at any time
-and the public API should not be considered stable.
-
-## Contributing
-
-Contributions to this library are always welcome and highly encouraged.
-
-See the [Contributing
-Guide](https://googlecloudplatform.github.io/google-cloud-ruby/docs/google-cloud-debugger/latest/file.CONTRIBUTING)
-for more information on how to get started.
-
-Please note that this project is released with a Contributor Code of Conduct. By
-participating in this project you agree to abide by its terms. See [Code of
-Conduct](https://googlecloudplatform.github.io/google-cloud-ruby/docs/google-cloud-debugger/latest/file.CODE_OF_CONDUCT)
-for more information.
-
-## License
-
-This library is licensed under Apache 2.0. Full license text is available in
-[LICENSE](https://googlecloudplatform.github.io/google-cloud-ruby/docs/google-cloud-debugger/latest/file.LICENSE).
-
-## Support
-
-Please [report bugs at the project on
-Github](https://github.com/GoogleCloudPlatform/google-cloud-ruby/issues). Don't
-hesitate to [ask
-questions](http://stackoverflow.com/questions/tagged/google-cloud-platform+ruby)
-about the client or APIs on [StackOverflow](http://stackoverflow.com).