google-cloud-debugger 0.30.0 → 0.31.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8eec075346b0460efd9940071568dd622d2ffb7685bedf218d186925d5cc7993
-  data.tar.gz: ab048f08b20449c6aa81d4a73bc081933d803f722a96d22eb4a0c5b64a589142
+  metadata.gz: 71f28cd2cdbb26aeb952111ceed9989d726fe066c7b42b15dc6abc01b77c6d80
+  data.tar.gz: 212961fe1b440ca8934468eedc899ce0304523443944fd4e882e7d07bca60157
 SHA512:
-  metadata.gz: 15052121b82c76b080c552b4036ca7ce22ecdfd84ad5071d6a587ed4a0d25f684bd9c6e58e2a5cd50884b70004bfaa22dfd4ba0ccaa60d49bb6d5b0a1dd1c85e
-  data.tar.gz: b7849a9d1e71d1acea6b253668260eadd39541534c4ce9084a55373fbe037da8c1060196d86ff19f1eca8d72b4d41deaff167147a54ada0043ebfc5ce1e77c6f
+  metadata.gz: 557129ab5d5b4010df8d7ff0baebe95fe3b20ea5615c2b50e542db0da479c14be7f8ec49e2e72bbfe0eb25d65ca630204f0097657fe26bf7d5e24b08cdc14ab4
+  data.tar.gz: e87fece9e975bd6b6a194029b880d6a682890af4df8c866b0424bed021744e689752a9454ef824ed26b2cebbb1d07157c8422c3718fbd123dc83997bcc729cf6

data/README.md

@@ -1,6 +1,12 @@
 # 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 the application state is captured. In most cases, this is not noticeable by users.
+[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/master/google/cloud/debugger)
 - [google-cloud-debugger on RubyGems](https://rubygems.org/gems/google-cloud-debugger)
@@ -8,44 +14,28 @@
 
 ## Quick Start
 
-Install the gem directly:
+### Installing the gem
 
-```sh
-$ gem install google-cloud-debugger
-```
-
-Or install through Bundler:
-
-1. Add the `google-cloud-debugger` gem to your Gemfile:
+Add the `google-cloud-debugger` gem to your Gemfile:
 
 ```ruby
 gem "google-cloud-debugger"
 ```
 
-2. Use Bundler to install the gem:
-
-```sh
-$ bundle install
-```
+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.
 
-Alternatively, check out the [`stackdriver`](../stackdriver) gem that includes
-the `google-cloud-debugger` gem.
+### Initializing the Debugger
 
-## Enable Stackdriver Debugger API
+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.
 
-The Stackdriver Debugger agent needs the [Stackdriver Debugger
-API](https://console.cloud.google.com/apis/library/clouddebugger.googleapis.com)
-to be enabled on your Google Cloud project. Make sure it's enabled if not
-already.
-
-## Enabling the Debugger agent
-
-The Stackdriver Debugger library provides a Debugger agent that helps instrument
-breakpoints in your running applications. 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.
-
-### With Ruby on Rails
+#### 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:
@@ -58,7 +48,7 @@ require "google/cloud/debugger/rails"
 If you're using the `stackdriver` gem, it automatically loads the Railtie into
 your application when it starts.
 
-### With other Rack-based frameworks
+#### Setup with other Rack-based frameworks
 
 Other Rack-based frameworks, such as Sinatra, can use the Rack Middleware
 provided by the library:
@@ -68,38 +58,42 @@ require "google/cloud/debugger"
 use Google::Cloud::Debugger::Middleware
 ```
 
-### Without Rack-based framework
+#### Setup without a Rack-based framework
 
-Non-rack-based applications can start the agent explicitly at the entry point of
-your application:
+Non-rack-based applications can start the agent explicitly during the
+initialization code:
 
 ```ruby
 require "google/cloud/debugger"
 Google::Cloud::Debugger.new.start
 ```
 
-### Configuring the agent
+### Connecting to the Debugger
 
-You can customize the behavior of the Stackdriver Debugger agent. See the
-[agent configuration](../stackdriver/docs/configuration.md) for a list of
-possible configuration options.
+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/).
 
-## Running on Google Cloud Platform
+Make sure the
+[Stackdriver Debugger API](https://console.cloud.google.com/apis/library/clouddebugger.googleapis.com)
+is enabled on your Google Cloud project.
 
-The Stackdriver Debugger agent should work without you manually providing
-authentication credentials for instances running on Google Cloud Platform, as
-long as the Stackdriver Debugger API access scope is enabled on that instance.
+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.
 
-### App Engine
+#### Connecting from Google App Engine (GAE)
 
-On Google App Engine, the Stackdriver Debugger API access scope is enabled by
-default, and the Stackdriver Debugger agent can be used without providing
-credentials or a project ID.
+If your app is running on Google App Engine, the Stackdriver Debugger agent
+authenticates automatically by default, and no additional configuration is
+required.
 
-### Container Engine
+#### Connecting from Google Kubernetes Engine (GKE)
 
-On Google Container Engine, you must explicitly add the `cloud_debugger` OAuth
-scope when creating the cluster:
+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
@@ -108,11 +102,14 @@ $ gcloud container clusters create example-cluster-name --scopes https://www.goo
 You can also do this through the Google Cloud Platform Console. Select
 **Enabled** in the Cloud Platform section of **Create a container cluster**.
 
-### Compute Engine
+After the OAuth scope is enabled, the Stackdriver Debugger agent authenticates
+automatically by default, and no additional configuration is required.
 
-To use Stackdriver Debugger, Compute Engine VM instances should have one of the
-following access scopes. These are only relevant when you use Compute Engine's
-default service account:
+#### 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`
@@ -122,25 +119,21 @@ 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 must be supplied manually using the SDK's
+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.
 
-## Running locally and elsewhere
+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. See the [Authentication section](#authentication) for
-instructions on how to do so.
-
-## Authentication
-
-This library uses Service Account 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 in several ways.
+cloud provider.
 
 The best way to provide authentication information if you're using Ruby on Rails
 is through the Rails configuration interface:
@@ -150,25 +143,25 @@ is through the Rails configuration interface:
 Rails.application.configure do |config|
   # Shared parameters
   config.google_cloud.project_id = "your-project-id"
-  config.google_cloud.keyfile = "/path/to/key.json"
+  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.keyfile = "/path/to/key.json"
+  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:
+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.keyfile = "/path/to/key.json"
+  config.credentials = "/path/to/key.json"
   # Or Stackdriver Debugger agent specific parameters
   config.debugger.project_id = "your-project-id"
-  config.debugger.keyfile = "/path/to/key.json"
+  config.debugger.credentials = "/path/to/key.json"
 end
 ```
 
@@ -184,15 +177,58 @@ 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/guides/authentication).
 
-## Supported Ruby Versions
+### 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
 
-This library is supported on Ruby 2.2+.
+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/docs/configuration.md)
+for a list of possible configuration options.
 
-## Versioning
+## Compatibility
 
-This library follows [Semantic Versioning](http://semver.org/).
+This library is supported on Ruby 2.2 or later.
 
-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.
+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
 

data/ext/google/cloud/debugger/debugger_c/evaluator.c

@@ -21,8 +21,8 @@
 static void
 eval_trace_callback(void *data, rb_trace_arg_t *trace_arg)
 {
-    rb_event_flag_t event = rb_tracearg_event_flag(trace_arg);
-    VALUE evaluator = (VALUE)data;
+    rb_event_flag_t event;
+    VALUE evaluator;
     VALUE klass;
     VALUE obj;
     VALUE method_id;
@@ -32,15 +32,16 @@ eval_trace_callback(void *data, rb_trace_arg_t *trace_arg)
     CONST_ID(trace_func_cb_id, "trace_func_callback");
     CONST_ID(trace_c_func_cb_id, "trace_c_func_callback");
 
+    event = rb_tracearg_event_flag(trace_arg);
+    evaluator = (VALUE)data;
     obj = rb_tracearg_self(trace_arg);
     method_id = rb_tracearg_method_id(trace_arg);
+    klass = rb_tracearg_defined_class(trace_arg);
 
     if (event & RUBY_EVENT_CALL) {
-        rb_funcall(evaluator, trace_func_cb_id, 2, obj, method_id);
+        rb_funcall(evaluator, trace_func_cb_id, 3, obj, klass, method_id);
     }
     if (event & RUBY_EVENT_C_CALL) {
-        klass = rb_tracearg_defined_class(trace_arg);
-
         rb_funcall(evaluator, trace_c_func_cb_id, 3, obj, klass, method_id);
     }
 
@@ -79,10 +80,13 @@ rb_enable_method_trace_for_thread(VALUE self)
     VALUE current_thread;
     VALUE thread_variables_hash;
     VALUE trace_set;
+    VALUE evaluator;
+    ID current_evaluator_id;
     ID locals_id;
     ID eval_trace_thread_id;
     VALUE eval_trace_thread_flag;
 
+    CONST_ID(current_evaluator_id, "current");
     CONST_ID(locals_id, "locals");
     CONST_ID(eval_trace_thread_id, "gcloud_eval_trace_set");
     eval_trace_thread_flag = ID2SYM(eval_trace_thread_id);
@@ -90,9 +94,10 @@ rb_enable_method_trace_for_thread(VALUE self)
     current_thread = rb_thread_current();
     thread_variables_hash = rb_ivar_get(current_thread, locals_id);
     trace_set = rb_hash_aref(thread_variables_hash, eval_trace_thread_flag);
+    evaluator = rb_funcall(self, current_evaluator_id, 0);
 
     if (!RTEST(trace_set)) {
-        rb_thread_add_event_hook2(current_thread, (rb_event_hook_func_t)eval_trace_callback, RUBY_EVENT_CALL | RUBY_EVENT_C_CALL, self, RUBY_EVENT_HOOK_FLAG_RAW_ARG | RUBY_EVENT_HOOK_FLAG_SAFE);
+        rb_thread_add_event_hook2(current_thread, (rb_event_hook_func_t)eval_trace_callback, RUBY_EVENT_CALL | RUBY_EVENT_C_CALL, evaluator, RUBY_EVENT_HOOK_FLAG_RAW_ARG | RUBY_EVENT_HOOK_FLAG_SAFE);
         rb_hash_aset(thread_variables_hash, eval_trace_thread_flag, Qtrue);
     }
 
@@ -103,8 +108,8 @@ void
 Init_evaluator(VALUE mDebugger)
 {
     VALUE cBreakpoint = rb_define_class_under(mDebugger, "Breakpoint", rb_cObject);
-    VALUE mEvaluator  = rb_define_module_under(cBreakpoint, "Evaluator");
+    VALUE cEvaluator  = rb_define_class_under(cBreakpoint, "Evaluator", rb_cObject);
 
-    rb_define_module_function(mEvaluator, "enable_method_trace_for_thread", rb_enable_method_trace_for_thread, 0);
-    rb_define_module_function(mEvaluator, "disable_method_trace_for_thread", rb_disable_method_trace_for_thread, 0);
+    rb_define_module_function(cEvaluator, "enable_method_trace_for_thread", rb_enable_method_trace_for_thread, 0);
+    rb_define_module_function(cEvaluator, "disable_method_trace_for_thread", rb_disable_method_trace_for_thread, 0);
 }

data/lib/google-cloud-debugger.rb

@@ -20,6 +20,8 @@
 
 gem "google-cloud-core"
 require "google/cloud"
+require "google/cloud/config"
+require "googleauth"
 
 module Google
   module Cloud
@@ -42,6 +44,8 @@ module Google
     #   The default scope is:
     #
     #   * `https://www.googleapis.com/auth/cloud_debugger`
+    #   * `https://www.googleapis.com/auth/logging.admin`
+    #
     # @param [Integer] timeout Default timeout to use in requests. Optional.
     # @param [Hash] client_config A hash of values to override the default
     #   behavior of the API client. Optional.
@@ -97,6 +101,8 @@ module Google
     #   The default scope is:
     #
     #   * `https://www.googleapis.com/auth/cloud_debugger`
+    #   * `https://www.googleapis.com/auth/logging.admin`
+    #
     # @param [Integer] timeout Default timeout to use in requests. Optional.
     # @param [Hash] client_config A hash of values to override the default
     #   behavior of the API client. Optional.
@@ -123,3 +129,52 @@ module Google
     end
   end
 end
+
+# Add debugger to top-level configuration
+Google::Cloud.configure do |config|
+  unless config.field? :use_debugger
+    config.add_field! :use_debugger, nil, enum: [true, false]
+  end
+  unless config.field? :service_name
+    config.add_field! :service_name, nil, match: String
+  end
+  unless config.field? :service_version
+    config.add_field! :service_version, nil, match: String
+  end
+end
+
+# Set the default debugger configuration
+Google::Cloud.configure.add_config! :debugger do |config|
+  default_project = Google::Cloud::Config.deferred do
+    ENV["DEBUGGER_PROJECT"]
+  end
+  default_creds = Google::Cloud::Config.deferred do
+    Google::Cloud::Config.credentials_from_env \
+      "DEBUGGER_CREDENTIALS", "DEBUGGER_CREDENTIALS_JSON",
+      "DEBUGGER_KEYFILE", "DEBUGGER_KEYFILE_JSON"
+  end
+  default_service = Google::Cloud::Config.deferred do
+    ENV["DEBUGGER_SERVICE_NAME"]
+  end
+  default_version = Google::Cloud::Config.deferred do
+    ENV["DEBUGGER_SERVICE_VERSION"]
+  end
+
+  config.add_field! :project_id, default_project, match: String, allow_nil: true
+  config.add_alias! :project, :project_id
+  config.add_field! :credentials, default_creds,
+                    match: [String, Hash, Google::Auth::Credentials],
+                    allow_nil: true
+  config.add_alias! :keyfile, :credentials
+  config.add_field! :service_name, default_service,
+                    match: String, allow_nil: true
+  config.add_field! :service_version, default_version,
+                    match: String, allow_nil: true
+  config.add_field! :app_root, nil, match: String
+  config.add_field! :root, nil, match: String
+  config.add_field! :scope, nil, match: [String, Array]
+  config.add_field! :timeout, nil, match: Integer
+  config.add_field! :client_config, nil, match: Hash
+  config.add_field! :allow_mutating_methods, false
+  config.add_field! :evaluation_time_limit, 0.05, match: Numeric
+end

data/lib/google/cloud/debugger.rb

@@ -15,6 +15,8 @@
 
 require "google-cloud-debugger"
 require "google/cloud/debugger/project"
+require "google/cloud/config"
+require "google/cloud/env"
 require "stackdriver/core"
 
 module Google
@@ -320,15 +322,7 @@ module Google
     # See {Google::Cloud::Debugger::V2::Debugger2Client} for details.
     #
     module Debugger
-      # Initialize :error_reporting as a nested Configuration under
-      # Google::Cloud if haven't already
-      unless Google::Cloud.configure.option? :debugger
-        Google::Cloud.configure.add_options :debugger
-
-        Google::Cloud.configure.define_singleton_method :debugger do
-          Google::Cloud.configure[:debugger]
-        end
-      end
+      # rubocop:disable all
 
       ##
       # Creates a new debugger object for instrumenting Stackdriver Debugger for
@@ -353,8 +347,15 @@ module Google
       #   the set of resources and operations that the connection can access.
       #   See [Using OAuth 2.0 to Access Google
       #   APIs](https://developers.google.com/identity/protocols/OAuth2).
-      #   The default scope is `https://www.googleapis.com/auth/cloud-platform`
+      #
+      #   The default scope is:
+      #
+      #   * `https://www.googleapis.com/auth/cloud_debugger`
+      #   * `https://www.googleapis.com/auth/logging.admin`
+      #
       # @param [Integer] timeout Default timeout to use in requests. Optional.
+      # @param [Hash] client_config A hash of values to override the default
+      #   behavior of the API client. Optional.
       # @param [String] project Project identifier for the Stackdriver Debugger
       #   service.
       # @param [String, Hash] keyfile Keyfile downloaded from Google Cloud:
@@ -371,18 +372,26 @@ module Google
       def self.new project_id: nil, credentials: nil, service_name: nil,
                    service_version: nil, scope: nil, timeout: nil,
                    client_config: nil, project: nil, keyfile: nil
-        project_id ||= (project || Debugger::Project.default_project_id)
+        project_id ||= (project || default_project_id)
         project_id = project_id.to_s # Always cast to a string
-        service_name ||= Debugger::Project.default_service_name
+
+        service_name ||= default_service_name
         service_name = service_name.to_s
-        service_version ||= Debugger::Project.default_service_version
+
+        service_version ||= default_service_version
         service_version = service_version.to_s
 
-        fail ArgumentError, "project_id is missing" if project_id.empty?
-        fail ArgumentError, "service_name is missing" if service_name.empty?
-        fail ArgumentError, "service_version is missing" if service_version.nil?
+        raise ArgumentError, "project_id is missing" if project_id.empty?
+        raise ArgumentError, "service_name is missing" if service_name.empty?
+        if service_version.nil?
+          raise ArgumentError, "service_version is missing"
+        end
+
+        scope ||= configure.scope
+        timeout ||= configure.timeout
+        client_config ||= configure.client_config
 
-        credentials ||= (keyfile || Debugger::Credentials.default(scope: scope))
+        credentials ||= (keyfile || default_credentials(scope: scope))
         unless credentials.is_a? Google::Auth::Credentials
           credentials = Debugger::Credentials.new credentials, scope: scope
         end
@@ -391,23 +400,132 @@ module Google
           Debugger::Service.new(project_id, credentials,
                                 timeout: timeout, client_config: client_config),
           service_name: service_name,
-          service_version: service_version)
+          service_version: service_version
+        )
       end
 
+      # rubocop:enable all
+
       ##
       # Configure the Stackdriver Debugger agent.
       #
+      # The following Stackdriver Debugger configuration parameters are
+      # supported:
+      #
+      # * `project_id` - (String) Project identifier for the Stackdriver
+      #   Debugger service you are connecting to. (The parameter `project` is
+      #   considered deprecated, but may also be used.)
+      # * `credentials` - (String, Hash, Google::Auth::Credentials) The path to
+      #   the keyfile as a String, the contents of the keyfile as a Hash, or a
+      #   Google::Auth::Credentials object. (See {Debugger::Credentials}) (The
+      #   parameter `keyfile` is considered deprecated, but may also be used.)
+      # * `service_name` - (String) Name for the debuggee application.
+      # * `service_version` - (String) Version identifier for the debuggee
+      #   application.
+      # * `root` - (String) The root directory of the debuggee application as an
+      #   absolute file path.
+      # * `scope` - (String, Array<String>) The OAuth 2.0 scopes controlling
+      #   the set of resources and operations that the connection can access.
+      # * `timeout` - (Integer) Default timeout to use in requests.
+      # * `client_config` - (Hash) A hash of values to override the default
+      #   behavior of the API client.
+      # * `allow_mutating_methods` - (boolean) Whether expressions and
+      #   conditional breakpoints can call methods that could modify program
+      #   state. Defaults to false.
+      # * `evaluation_time_limit` - (Numeric) Time limit in seconds for
+      #   expression evaluation. Defaults to 0.05.
+      #
       # See the [Configuration
       # Guide](https://googlecloudplatform.github.io/google-cloud-ruby/#/docs/stackdriver/guides/instrumentation_configuration)
       # for full configuration parameters.
       #
-      # @return [Stackdriver::Core::Configuration] The configuration object
-      #   the Google::Cloud::ErrorReporting module uses.
+      # @return [Google::Cloud::Config] The configuration object the
+      #   Google::Cloud::Debugger module uses.
       #
       def self.configure
-        yield Google::Cloud.configure[:debugger] if block_given?
+        yield Google::Cloud.configure.debugger if block_given?
+
+        Google::Cloud.configure.debugger
+      end
+
+      ##
+      # @private Default project.
+      def self.default_project_id
+        Google::Cloud.configure.debugger.project_id ||
+          Google::Cloud.configure.project_id ||
+          Google::Cloud.env.project_id
+      end
 
-        Google::Cloud.configure[:debugger]
+      ##
+      # @private Default service name identifier.
+      def self.default_service_name
+        Google::Cloud.configure.debugger.service_name ||
+          Google::Cloud.configure.service_name ||
+          Google::Cloud.env.app_engine_service_id ||
+          "ruby-app"
+      end
+
+      ##
+      # @private Default service version identifier.
+      def self.default_service_version
+        Google::Cloud.configure.debugger.service_version ||
+          Google::Cloud.configure.service_version ||
+          Google::Cloud.env.app_engine_service_version ||
+          ""
+      end
+
+      ##
+      # @private Default credentials.
+      def self.default_credentials scope: nil
+        Google::Cloud.configure.debugger.credentials ||
+          Google::Cloud.configure.credentials ||
+          Debugger::Credentials.default(scope: scope)
+      end
+
+      ##
+      # Allow calling of potentially state-changing methods even if mutation
+      # detection is configured to be active.
+      #
+      # Generally it is unwise to run code that may change the program state
+      # (e.g. modifying instance variables or causing other side effects) in a
+      # breakpoint expression, because it could change the behavior of your
+      # program. However, the checks are currently quite conservative, and may
+      # block code that is actually safe to run. If you are certain your
+      # expression is safe to evaluate, you may use this method to disable
+      # side effect checks.
+      #
+      # This method may be called with a block, in which case checks are
+      # disabled within the block. It may also be called without a block to
+      # disable side effect checks for the rest of the current expression; the
+      # default setting will be restored for the next expression.
+      #
+      # This method may be called only from a debugger condition or expression
+      # evaluation, and will throw an exception if you call it from normal
+      # application code. Set the `allow_mutating_methods` configuration if you
+      # want to disable the side effect checker globally for your app.
+      #
+      # @example Disabling side effect detection in a block
+      #   # This is an expression evaluated in a debugger snapshot
+      #   Google::Cloud::Debugger.allow_mutating_methods! do
+      #     obj1.method_with_potential_side_effects
+      #   end
+      #
+      # @example Disabling side effect detection for the rest of the expression
+      #   # This is an expression evaluated in a debugger snapshot
+      #   Google::Cloud::Debugger.allow_mutating_methods!
+      #   obj1.method_with_potential_side_effects
+      #   obj2.another_method_with_potential_side_effects
+      #
+      # @example Globally disabling side effect detection at app initialization
+      #   require "google/cloud/debugger"
+      #   Google::Cloud::Debugger.configure.allow_mutating_methods = true
+      #
+      def self.allow_mutating_methods! &block
+        evaluator = Breakpoint::Evaluator.current
+        if evaluator.nil?
+          raise "allow_mutating_methods can be called only during evaluation"
+        end
+        evaluator.allow_mutating_methods!(&block)
       end
     end
   end